Use Use templetized operations for Score and Value
[stockfish] / src / evaluate.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 ////
22 //// Includes
23 ////
24
25 #include <cassert>
26 #include <cstring>
27
28 #include "bitcount.h"
29 #include "evaluate.h"
30 #include "material.h"
31 #include "pawns.h"
32 #include "thread.h"
33 #include "ucioption.h"
34
35
36 ////
37 //// Local definitions
38 ////
39
40 namespace {
41
42   const int Sign[2] = { 1, -1 };
43
44   // Evaluation grain size, must be a power of 2
45   const int GrainSize = 8;
46
47   // Evaluation weights, initialized from UCI options
48   enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
49   Score Weights[6];
50
51   typedef Value V;
52   #define S(mg, eg) make_score(mg, eg)
53
54   // Internal evaluation weights. These are applied on top of the evaluation
55   // weights read from UCI parameters. The purpose is to be able to change
56   // the evaluation weights while keeping the default values of the UCI
57   // parameters at 100, which looks prettier.
58   //
59   // Values modified by Joona Kiiski
60   const Score WeightsInternal[] = {
61       S(248, 271), S(233, 201), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
62   };
63
64   // Knight mobility bonus in middle game and endgame, indexed by the number
65   // of attacked squares not occupied by friendly piecess.
66   const Score KnightMobilityBonus[16] = {
67     S(-38,-33), S(-25,-23), S(-12,-13), S( 0,-3),
68     S( 12,  7), S( 25, 17), S( 31, 22), S(38, 27), S(38, 27)
69   };
70
71   // Bishop mobility bonus in middle game and endgame, indexed by the number
72   // of attacked squares not occupied by friendly pieces. X-ray attacks through
73   // queens are also included.
74   const Score BishopMobilityBonus[16] = {
75     S(-25,-30), S(-11,-16), S( 3, -2), S(17, 12),
76     S( 31, 26), S( 45, 40), S(57, 52), S(65, 60),
77     S( 71, 65), S( 74, 69), S(76, 71), S(78, 73),
78     S( 79, 74), S( 80, 75), S(81, 76), S(81, 76)
79   };
80
81   // Rook mobility bonus in middle game and endgame, indexed by the number
82   // of attacked squares not occupied by friendly pieces. X-ray attacks through
83   // queens and rooks are also included.
84   const Score RookMobilityBonus[16] = {
85     S(-20,-36), S(-14,-19), S(-8, -3), S(-2, 13),
86     S(  4, 29), S( 10, 46), S(14, 62), S(19, 79),
87     S( 23, 95), S( 26,106), S(27,111), S(28,114),
88     S( 29,116), S( 30,117), S(31,118), S(32,118)
89   };
90
91   // Queen mobility bonus in middle game and endgame, indexed by the number
92   // of attacked squares not occupied by friendly pieces.
93   const Score QueenMobilityBonus[32] = {
94     S(-10,-18), S(-8,-13), S(-6, -7), S(-3, -2), S(-1,  3), S( 1,  8),
95     S(  3, 13), S( 5, 19), S( 8, 23), S(10, 27), S(12, 32), S(15, 34),
96     S( 16, 35), S(17, 35), S(18, 35), S(20, 35), S(20, 35), S(20, 35),
97     S( 20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35),
98     S( 20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35),
99     S( 20, 35), S(20, 35)
100   };
101
102   // Pointers table to access mobility tables through piece type
103   const Score* MobilityBonus[8] = { 0, 0, KnightMobilityBonus, BishopMobilityBonus,
104                                     RookMobilityBonus, QueenMobilityBonus, 0, 0 };
105
106   // Outpost bonuses for knights and bishops, indexed by square (from white's
107   // point of view).
108   const Value KnightOutpostBonus[64] = {
109   //  A     B     C     D     E     F     G     H
110     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
111     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
112     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0), // 3
113     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0), // 4
114     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0), // 5
115     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0), // 6
116     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
117     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
118   };
119
120   const Value BishopOutpostBonus[64] = {
121   //  A     B     C     D     E     F     G     H
122     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
123     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
124     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), // 3
125     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), // 4
126     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0), // 5
127     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0), // 6
128     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
129     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
130   };
131
132   // ThreatBonus[attacking][attacked] contains bonus according to which
133   // piece type attacks which one.
134   const Score ThreatBonus[8][8] = {
135     {}, {},
136     { S(0, 0), S( 7, 39), S( 0,  0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
137     { S(0, 0), S( 7, 39), S(24, 49), S( 0,  0), S(41,100), S(41,100) }, // BISHOP
138     { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0,  0), S(24, 49) }, // ROOK
139     { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0,  0) }  // QUEEN
140   };
141
142   // ThreatedByPawnPenalty[] contains a penalty according to which piece
143   // type is attacked by an enemy pawn.
144   const Score ThreatedByPawnPenalty[8] = {
145     S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
146   };
147
148   #undef S
149
150   // Bonus for unstoppable passed pawns
151   const Value UnstoppablePawnValue = Value(0x500);
152
153   // Rooks and queens on the 7th rank (modified by Joona Kiiski)
154   const Score RookOn7thBonus  = make_score(47, 98);
155   const Score QueenOn7thBonus = make_score(27, 54);
156
157   // Rooks on open files (modified by Joona Kiiski)
158   const Score RookOpenFileBonus = make_score(43, 43);
159   const Score RookHalfOpenFileBonus = make_score(19, 19);
160
161   // Penalty for rooks trapped inside a friendly king which has lost the
162   // right to castle.
163   const Value TrappedRookPenalty = Value(180);
164
165   // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
166   // enemy pawns.
167   const Score TrappedBishopA7H7Penalty = make_score(300, 300);
168
169   // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
170   const Bitboard MaskA7H7[2] = {
171     ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
172     ((1ULL << SQ_A2) | (1ULL << SQ_H2))
173   };
174
175   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
176   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
177   // happen in Chess960 games.
178   const Score TrappedBishopA1H1Penalty = make_score(100, 100);
179
180   // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
181   const Bitboard MaskA1H1[2] = {
182     ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
183     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
184   };
185
186   // The SpaceMask[color] contains the area of the board which is considered
187   // by the space evaluation. In the middle game, each side is given a bonus
188   // based on how many squares inside this area are safe and available for
189   // friendly minor pieces.
190   const Bitboard SpaceMask[2] = {
191     (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
192     (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
193     (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
194     (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
195     (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
196     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
197   };
198
199   /// King danger constants and variables. The king danger scores are taken
200   /// from the KingDangerTable[]. Various little "meta-bonuses" measuring
201   /// the strength of the enemy attack are added up into an integer, which
202   /// is used as an index to KingDangerTable[].
203
204   // KingAttackWeights[] contains king attack weights by piece type
205   const int KingAttackWeights[8] = { 0, 0, 2, 2, 3, 5 };
206
207   // Bonuses for enemy's safe checks
208   const int QueenContactCheckBonus = 3;
209   const int QueenCheckBonus        = 2;
210   const int RookCheckBonus         = 1;
211   const int BishopCheckBonus       = 1;
212   const int KnightCheckBonus       = 1;
213
214   // InitKingDanger[] contains bonuses based on the position of the defending
215   // king.
216   const int InitKingDanger[64] = {
217      2,  0,  2,  5,  5,  2,  0,  2,
218      2,  2,  4,  8,  8,  4,  2,  2,
219      7, 10, 12, 12, 12, 12, 10,  7,
220     15, 15, 15, 15, 15, 15, 15, 15,
221     15, 15, 15, 15, 15, 15, 15, 15,
222     15, 15, 15, 15, 15, 15, 15, 15,
223     15, 15, 15, 15, 15, 15, 15, 15,
224     15, 15, 15, 15, 15, 15, 15, 15
225   };
226
227   // KingDangerTable[color][] contains the actual king danger weighted scores
228   Score KingDangerTable[2][128];
229
230   // Pawn and material hash tables, indexed by the current thread id.
231   // Note that they will be initialized at 0 being global variables.
232   MaterialInfoTable* MaterialTable[MAX_THREADS];
233   PawnInfoTable* PawnTable[MAX_THREADS];
234
235   // Sizes of pawn and material hash tables
236   const int PawnTableSize = 16384;
237   const int MaterialTableSize = 1024;
238
239   // Function prototypes
240   template<bool HasPopCnt>
241   Value do_evaluate(const Position& pos, EvalInfo& ei);
242
243   template<Color Us, bool HasPopCnt>
244   void init_attack_tables(const Position& pos, EvalInfo& ei);
245
246   template<Color Us, bool HasPopCnt>
247   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
248
249   template<Color Us, bool HasPopCnt>
250   void evaluate_king(const Position& pos, EvalInfo& ei);
251
252   template<Color Us>
253   void evaluate_threats(const Position& pos, EvalInfo& ei);
254
255   template<Color Us, bool HasPopCnt>
256   int evaluate_space(const Position& pos, EvalInfo& ei);
257
258   template<Color Us>
259   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
260
261   void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
262   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo& ei);
263   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei);
264   inline Score apply_weight(Score v, Score weight);
265   Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
266   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
267   void init_safety();
268 }
269
270
271 ////
272 //// Functions
273 ////
274
275 /// evaluate() is the main evaluation function. It always computes two
276 /// values, an endgame score and a middle game score, and interpolates
277 /// between them based on the remaining material.
278 Value evaluate(const Position& pos, EvalInfo& ei) {
279
280     return CpuHasPOPCNT ? do_evaluate<true>(pos, ei)
281                         : do_evaluate<false>(pos, ei);
282 }
283
284 namespace {
285
286 template<bool HasPopCnt>
287 Value do_evaluate(const Position& pos, EvalInfo& ei) {
288
289   ScaleFactor factor[2];
290
291   assert(pos.is_ok());
292   assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
293   assert(!pos.is_check());
294
295   memset(&ei, 0, sizeof(EvalInfo));
296
297   // Initialize by reading the incrementally updated scores included in the
298   // position object (material + piece square tables)
299   ei.value = pos.value();
300
301   // Probe the material hash table
302   ei.mi = MaterialTable[pos.thread()]->get_material_info(pos);
303   ei.value += ei.mi->material_value();
304
305   // If we have a specialized evaluation function for the current material
306   // configuration, call it and return
307   if (ei.mi->specialized_eval_exists())
308       return ei.mi->evaluate(pos);
309
310   // After get_material_info() call that modifies them
311   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
312   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
313
314   // Probe the pawn hash table
315   ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
316   ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
317
318   // Initialize attack bitboards with pawns evaluation
319   init_attack_tables<WHITE, HasPopCnt>(pos, ei);
320   init_attack_tables<BLACK, HasPopCnt>(pos, ei);
321
322   // Evaluate pieces
323   evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
324   evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
325
326   // Kings. Kings are evaluated after all other pieces for both sides,
327   // because we need complete attack information for all pieces when computing
328   // the king safety evaluation.
329   evaluate_king<WHITE, HasPopCnt>(pos, ei);
330   evaluate_king<BLACK, HasPopCnt>(pos, ei);
331
332   // Evaluate tactical threats, we need full attack info including king
333   evaluate_threats<WHITE>(pos, ei);
334   evaluate_threats<BLACK>(pos, ei);
335
336   // Evaluate passed pawns, we need full attack info including king
337   evaluate_passed_pawns<WHITE>(pos, ei);
338   evaluate_passed_pawns<BLACK>(pos, ei);
339
340   // If one side has only a king, check whether exsists any unstoppable passed pawn
341   if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
342       evaluate_unstoppable_pawns(pos, ei);
343
344   Phase phase = ei.mi->game_phase();
345
346   // Middle-game specific evaluation terms
347   if (phase > PHASE_ENDGAME)
348   {
349       // Pawn storms in positions with opposite castling
350       if (   square_file(pos.king_square(WHITE)) >= FILE_E
351           && square_file(pos.king_square(BLACK)) <= FILE_D)
352
353           ei.value += make_score(ei.pi->queenside_storm_value(WHITE) - ei.pi->kingside_storm_value(BLACK), 0);
354
355       else if (   square_file(pos.king_square(WHITE)) <= FILE_D
356                && square_file(pos.king_square(BLACK)) >= FILE_E)
357
358           ei.value += make_score(ei.pi->kingside_storm_value(WHITE) - ei.pi->queenside_storm_value(BLACK), 0);
359
360       // Evaluate space for both sides
361       if (ei.mi->space_weight() > 0)
362       {
363           int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
364           ei.value += apply_weight(make_score(s * ei.mi->space_weight(), 0), Weights[Space]);
365       }
366   }
367
368   // Mobility
369   ei.value += apply_weight(ei.mobility, Weights[Mobility]);
370
371   // If we don't already have an unusual scale factor, check for opposite
372   // colored bishop endgames, and use a lower scale for those
373   if (   phase < PHASE_MIDGAME
374       && pos.opposite_colored_bishops()
375       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && eg_value(ei.value) > Value(0))
376           || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(ei.value) < Value(0))))
377   {
378       ScaleFactor sf;
379
380       // Only the two bishops ?
381       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
382           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
383       {
384           // Check for KBP vs KB with only a single pawn that is almost
385           // certainly a draw or at least two pawns.
386           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
387           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
388       }
389       else
390           // Endgame with opposite-colored bishops, but also other pieces. Still
391           // a bit drawish, but not as drawish as with only the two bishops.
392            sf = ScaleFactor(50);
393
394       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
395           factor[WHITE] = sf;
396       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
397           factor[BLACK] = sf;
398   }
399
400   // Interpolate between the middle game and the endgame score
401   return Sign[pos.side_to_move()] * scale_by_game_phase(ei.value, phase, factor);
402 }
403
404 } // namespace
405
406 /// init_eval() initializes various tables used by the evaluation function
407
408 void init_eval(int threads) {
409
410   assert(threads <= MAX_THREADS);
411
412   for (int i = 0; i < MAX_THREADS; i++)
413   {
414     if (i >= threads)
415     {
416         delete PawnTable[i];
417         delete MaterialTable[i];
418         PawnTable[i] = NULL;
419         MaterialTable[i] = NULL;
420         continue;
421     }
422     if (!PawnTable[i])
423         PawnTable[i] = new PawnInfoTable(PawnTableSize);
424     if (!MaterialTable[i])
425         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
426   }
427 }
428
429
430 /// quit_eval() releases heap-allocated memory at program termination
431
432 void quit_eval() {
433
434   for (int i = 0; i < MAX_THREADS; i++)
435   {
436       delete PawnTable[i];
437       delete MaterialTable[i];
438       PawnTable[i] = NULL;
439       MaterialTable[i] = NULL;
440   }
441 }
442
443
444 /// read_weights() reads evaluation weights from the corresponding UCI parameters
445
446 void read_weights(Color us) {
447
448   // King safety is asymmetrical. Our king danger level is weighted by
449   // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
450   const int kingDangerUs   = (us == WHITE ? KingDangerUs   : KingDangerThem);
451   const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
452
453   Weights[Mobility]       = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
454   Weights[PawnStructure]  = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
455   Weights[PassedPawns]    = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
456   Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
457   Weights[kingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
458   Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
459
460   // If running in analysis mode, make sure we use symmetrical king safety. We do this
461   // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
462   if (get_option_value_bool("UCI_AnalyseMode"))
463       Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
464
465   init_safety();
466 }
467
468
469 namespace {
470
471   // init_attack_tables() initializes king bitboards for both sides adding
472   // pawn attacks. To be done before other evaluations.
473
474   template<Color Us, bool HasPopCnt>
475   void init_attack_tables(const Position& pos, EvalInfo& ei) {
476
477     const Color Them = (Us == WHITE ? BLACK : WHITE);
478
479     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
480     ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
481     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
482     b &= ei.attackedBy[Us][PAWN];
483     if (b)
484         ei.kingAttackersCount[Us] = count_1s_max_15<HasPopCnt>(b) / 2;
485   }
486
487
488   // evaluate_outposts() evaluates bishop and knight outposts squares
489
490   template<PieceType Piece, Color Us>
491   void evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
492
493     const Color Them = (Us == WHITE ? BLACK : WHITE);
494
495     // Initial bonus based on square
496     Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
497                                    : KnightOutpostBonus[relative_square(Us, s)]);
498
499     // Increase bonus if supported by pawn, especially if the opponent has
500     // no minor piece which can exchange the outpost piece
501     if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
502     {
503         if (    pos.pieces(KNIGHT, Them) == EmptyBoardBB
504             && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
505             bonus += bonus + bonus / 2;
506         else
507             bonus += bonus / 2;
508     }
509     ei.value += Sign[Us] * make_score(bonus, bonus);
510   }
511
512
513   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
514
515   template<PieceType Piece, Color Us, bool HasPopCnt>
516   void evaluate_pieces(const Position& pos, EvalInfo& ei, Bitboard no_mob_area) {
517
518     Bitboard b;
519     Square s, ksq;
520     int mob;
521     File f;
522
523     const Color Them = (Us == WHITE ? BLACK : WHITE);
524     const Square* ptr = pos.piece_list_begin(Us, Piece);
525
526     while ((s = *ptr++) != SQ_NONE)
527     {
528         // Find attacked squares, including x-ray attacks for bishops and rooks
529         if (Piece == KNIGHT || Piece == QUEEN)
530             b = pos.attacks_from<Piece>(s);
531         else if (Piece == BISHOP)
532             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
533         else if (Piece == ROOK)
534             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
535         else
536             assert(false);
537
538         // Update attack info
539         ei.attackedBy[Us][Piece] |= b;
540
541         // King attacks
542         if (b & ei.kingZone[Us])
543         {
544             ei.kingAttackersCount[Us]++;
545             ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
546             Bitboard bb = (b & ei.attackedBy[Them][KING]);
547             if (bb)
548                 ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
549         }
550
551         // Mobility
552         mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & no_mob_area)
553                               : count_1s<HasPopCnt>(b & no_mob_area));
554
555         ei.mobility += Sign[Us] * MobilityBonus[Piece][mob];
556
557         // Decrease score if we are attacked by an enemy pawn. Remaining part
558         // of threat evaluation must be done later when we have full attack info.
559         if (bit_is_set(ei.attackedBy[Them][PAWN], s))
560             ei.value -= Sign[Us] * ThreatedByPawnPenalty[Piece];
561
562         // Bishop and knight outposts squares
563         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
564             evaluate_outposts<Piece, Us>(pos, ei, s);
565
566         // Special patterns: trapped bishops on a7/h7/a2/h2
567         // and trapped bishops on a1/h1/a8/h8 in Chess960.
568         if (Piece == BISHOP)
569         {
570             if (bit_is_set(MaskA7H7[Us], s))
571                 evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
572
573             if (Chess960 && bit_is_set(MaskA1H1[Us], s))
574                 evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
575         }
576
577         // Queen or rook on 7th rank
578         if (  (Piece == ROOK || Piece == QUEEN)
579             && relative_rank(Us, s) == RANK_7
580             && relative_rank(Us, pos.king_square(Them)) == RANK_8)
581         {
582             ei.value += Sign[Us] * (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
583         }
584
585         // Special extra evaluation for rooks
586         if (Piece == ROOK)
587         {
588             // Open and half-open files
589             f = square_file(s);
590             if (ei.pi->file_is_half_open(Us, f))
591             {
592                 if (ei.pi->file_is_half_open(Them, f))
593                     ei.value += Sign[Us] * RookOpenFileBonus;
594                 else
595                     ei.value += Sign[Us] * RookHalfOpenFileBonus;
596             }
597
598             // Penalize rooks which are trapped inside a king. Penalize more if
599             // king has lost right to castle.
600             if (mob > 6 || ei.pi->file_is_half_open(Us, f))
601                 continue;
602
603             ksq = pos.king_square(Us);
604
605             if (    square_file(ksq) >= FILE_E
606                 &&  square_file(s) > square_file(ksq)
607                 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
608             {
609                 // Is there a half-open file between the king and the edge of the board?
610                 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
611                     ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
612                                                                          : (TrappedRookPenalty - mob * 16), 0);
613             }
614             else if (    square_file(ksq) <= FILE_D
615                      &&  square_file(s) < square_file(ksq)
616                      && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
617             {
618                 // Is there a half-open file between the king and the edge of the board?
619                 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
620                     ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
621                                                                          : (TrappedRookPenalty - mob * 16), 0);
622             }
623         }
624     }
625   }
626
627
628   // evaluate_threats<>() assigns bonuses according to the type of attacking piece
629   // and the type of attacked one.
630
631   template<Color Us>
632   void evaluate_threats(const Position& pos, EvalInfo& ei) {
633
634     const Color Them = (Us == WHITE ? BLACK : WHITE);
635
636     Bitboard b;
637     Score bonus = make_score(0, 0);
638
639     // Enemy pieces not defended by a pawn and under our attack
640     Bitboard weakEnemies =  pos.pieces_of_color(Them)
641                           & ~ei.attackedBy[Them][PAWN]
642                           & ei.attackedBy[Us][0];
643     if (!weakEnemies)
644         return;
645
646     // Add bonus according to type of attacked enemy pieces and to the
647     // type of attacking piece, from knights to queens. Kings are not
648     // considered because are already special handled in king evaluation.
649     for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
650     {
651         b = ei.attackedBy[Us][pt1] & weakEnemies;
652         if (b)
653             for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
654                 if (b & pos.pieces(pt2))
655                     bonus += ThreatBonus[pt1][pt2];
656     }
657     ei.value += Sign[Us] * bonus;
658   }
659
660
661   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
662   // pieces of a given color.
663
664   template<Color Us, bool HasPopCnt>
665   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
666
667     const Color Them = (Us == WHITE ? BLACK : WHITE);
668
669     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
670     const Bitboard no_mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
671
672     evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, no_mob_area);
673     evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, no_mob_area);
674     evaluate_pieces<ROOK,   Us, HasPopCnt>(pos, ei, no_mob_area);
675     evaluate_pieces<QUEEN,  Us, HasPopCnt>(pos, ei, no_mob_area);
676
677     // Sum up all attacked squares
678     ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
679                            | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
680                            | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
681   }
682
683
684   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
685
686   template<Color Us, bool HasPopCnt>
687   void evaluate_king(const Position& pos, EvalInfo& ei) {
688
689     const Color Them = (Us == WHITE ? BLACK : WHITE);
690
691     Bitboard undefended, b, b1, b2, safe;
692     bool sente;
693     int attackUnits, shelter = 0;
694     const Square ksq = pos.king_square(Us);
695
696     // King shelter
697     if (relative_rank(Us, ksq) <= RANK_4)
698     {
699         shelter = ei.pi->get_king_shelter(pos, Us, ksq);
700         ei.value += Sign[Us] * make_score(shelter, 0);
701     }
702
703     // King safety. This is quite complicated, and is almost certainly far
704     // from optimally tuned.
705     if (   pos.piece_count(Them, QUEEN) >= 1
706         && ei.kingAttackersCount[Them]  >= 2
707         && pos.non_pawn_material(Them)  >= QueenValueMidgame + RookValueMidgame
708         && ei.kingAdjacentZoneAttacksCount[Them])
709     {
710         // Is it the attackers turn to move?
711         sente = (Them == pos.side_to_move());
712
713         // Find the attacked squares around the king which has no defenders
714         // apart from the king itself
715         undefended = ei.attacked_by(Them) & ei.attacked_by(Us, KING);
716         undefended &= ~(  ei.attacked_by(Us, PAWN)   | ei.attacked_by(Us, KNIGHT)
717                         | ei.attacked_by(Us, BISHOP) | ei.attacked_by(Us, ROOK)
718                         | ei.attacked_by(Us, QUEEN));
719
720         // Initialize the 'attackUnits' variable, which is used later on as an
721         // index to the KingDangerTable[] array. The initial value is based on
722         // the number and types of the enemy's attacking pieces, the number of
723         // attacked and undefended squares around our king, the square of the
724         // king, and the quality of the pawn shelter.
725         attackUnits =  Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
726                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended))
727                      + InitKingDanger[relative_square(Us, ksq)]
728                      - shelter / 32;
729
730         // Analyse enemy's safe queen contact checks. First find undefended
731         // squares around the king attacked by enemy queen...
732         b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
733         if (b)
734         {
735             // ...then remove squares not supported by another enemy piece
736             b &= (  ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
737                   | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK));
738             if (b)
739                 attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
740         }
741
742         // Analyse enemy's safe distance checks for sliders and knights
743         safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us));
744
745         b1 = pos.attacks_from<ROOK>(ksq) & safe;
746         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
747
748         // Enemy queen safe checks
749         b = (b1 | b2) & ei.attacked_by(Them, QUEEN);
750         if (b)
751             attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
752
753         // Enemy rooks safe checks
754         b = b1 & ei.attacked_by(Them, ROOK);
755         if (b)
756             attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
757
758         // Enemy bishops safe checks
759         b = b2 & ei.attacked_by(Them, BISHOP);
760         if (b)
761             attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
762
763         // Enemy knights safe checks
764         b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe;
765         if (b)
766             attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
767
768         // To index KingDangerTable[] attackUnits must be in [0, 99] range
769         attackUnits = Min(99, Max(0, attackUnits));
770
771         // Finally, extract the king danger score from the KingDangerTable[]
772         // array and subtract the score from evaluation. Set also ei.kingDanger[]
773         // value that will be used for pruning because this value can sometimes
774         // be very big, and so capturing a single attacking piece can therefore
775         // result in a score change far bigger than the value of the captured piece.
776         ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
777         ei.kingDanger[Us] = mg_value(KingDangerTable[Us][attackUnits]);
778     }
779   }
780
781
782   // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
783
784   template<Color Us>
785   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
786
787     const Color Them = (Us == WHITE ? BLACK : WHITE);
788
789     Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
790     Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(Us);
791
792     while (b)
793     {
794         Square s = pop_1st_bit(&b);
795
796         assert(pos.pawn_is_passed(Us, s));
797
798         int r = int(relative_rank(Us, s) - RANK_2);
799         int tr = r * (r - 1);
800
801         // Base bonus based on rank
802         Value mbonus = Value(20 * tr);
803         Value ebonus = Value(10 + r * r * 10);
804
805         if (tr)
806         {
807             Square blockSq = s + pawn_push(Us);
808
809             // Adjust bonus based on kings proximity
810             ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * tr);
811             ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * 1 * tr);
812             ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * tr);
813
814             // If the pawn is free to advance, increase bonus
815             if (pos.square_is_empty(blockSq))
816             {
817                 squaresToQueen = squares_in_front_of(Us, s);
818                 defendedSquares = squaresToQueen & ei.attacked_by(Us);
819
820                 // If there is an enemy rook or queen attacking the pawn from behind,
821                 // add all X-ray attacks by the rook or queen. Otherwise consider only
822                 // the squares in the pawn's path attacked or occupied by the enemy.
823                 if (   (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
824                     && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
825                     unsafeSquares = squaresToQueen;
826                 else
827                     unsafeSquares = squaresToQueen & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
828
829                 // If there aren't enemy attacks or pieces along the path to queen give
830                 // huge bonus. Even bigger if we protect the pawn's path.
831                 if (!unsafeSquares)
832                     ebonus += Value(tr * (squaresToQueen == defendedSquares ? 17 : 15));
833                 else
834                     // OK, there are enemy attacks or pieces (but not pawns). Are those
835                     // squares which are attacked by the enemy also attacked by us ?
836                     // If yes, big bonus (but smaller than when there are no enemy attacks),
837                     // if no, somewhat smaller bonus.
838                     ebonus += Value(tr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
839
840                 // At last, add a small bonus when there are no *friendly* pieces
841                 // in the pawn's path.
842                 if (!(squaresToQueen & pos.pieces_of_color(Us)))
843                     ebonus += Value(tr);
844             }
845         } // tr != 0
846
847         // Increase the bonus if the passed pawn is supported by a friendly pawn
848         // on the same rank and a bit smaller if it's on the previous rank.
849         supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
850         if (supportingPawns & rank_bb(s))
851             ebonus += Value(r * 20);
852         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
853             ebonus += Value(r * 12);
854
855         // Rook pawns are a special case: They are sometimes worse, and
856         // sometimes better than other passed pawns. It is difficult to find
857         // good rules for determining whether they are good or bad. For now,
858         // we try the following: Increase the value for rook pawns if the
859         // other side has no pieces apart from a knight, and decrease the
860         // value if the other side has a rook or queen.
861         if (square_file(s) == FILE_A || square_file(s) == FILE_H)
862         {
863             if (pos.non_pawn_material(Them) <= KnightValueMidgame)
864                 ebonus += ebonus / 4;
865             else if (pos.pieces(ROOK, QUEEN, Them))
866                 ebonus -= ebonus / 4;
867         }
868
869         // Add the scores for this pawn to the middle game and endgame eval
870         ei.value += Sign[Us] * apply_weight(make_score(mbonus, ebonus), Weights[PassedPawns]);
871
872     } // while
873   }
874
875
876   // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides
877
878   void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
879
880     int movesToGo[2] = {0, 0};
881     Square pawnToGo[2] = {SQ_NONE, SQ_NONE};
882
883     for (Color c = WHITE; c <= BLACK; c++)
884     {
885         // Skip evaluation if other side has non-pawn pieces
886         if (pos.non_pawn_material(opposite_color(c)))
887             continue;
888
889         Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(c);
890
891         while (b)
892         {
893             Square s = pop_1st_bit(&b);
894             Square queeningSquare = relative_square(c, make_square(square_file(s), RANK_8));
895             int d =  square_distance(s, queeningSquare)
896                    - int(relative_rank(c, s) == RANK_2) // Double pawn push
897                    - square_distance(pos.king_square(opposite_color(c)), queeningSquare)
898                    + int(c != pos.side_to_move());
899
900             // Do we protect the path to queening ?
901             bool pathDefended = (ei.attacked_by(c) & squares_in_front_of(c, s)) == squares_in_front_of(c, s);
902
903             if (d < 0 || pathDefended)
904             {
905                 int mtg = RANK_8 - relative_rank(c, s) - int(relative_rank(c, s) == RANK_2);
906                 int blockerCount = count_1s_max_15(squares_in_front_of(c, s) & pos.occupied_squares());
907                 mtg += blockerCount;
908                 d += blockerCount;
909                 if ((d < 0 || pathDefended) && (!movesToGo[c] || movesToGo[c] > mtg))
910                 {
911                     movesToGo[c] = mtg;
912                     pawnToGo[c] = s;
913                 }
914             }
915         }
916     }
917
918     // Neither side has an unstoppable passed pawn?
919     if (!(movesToGo[WHITE] | movesToGo[BLACK]))
920         return;
921
922     // Does only one side have an unstoppable passed pawn?
923     if (!movesToGo[WHITE] || !movesToGo[BLACK])
924     {
925         Color winnerSide = movesToGo[WHITE] ? WHITE : BLACK;
926         ei.value += make_score(0, Sign[winnerSide] * (UnstoppablePawnValue - Value(0x40 * movesToGo[winnerSide])));
927     }
928     else
929     {   // Both sides have unstoppable pawns! Try to find out who queens
930         // first. We begin by transforming 'movesToGo' to the number of
931         // plies until the pawn queens for both sides.
932         movesToGo[WHITE] *= 2;
933         movesToGo[BLACK] *= 2;
934         movesToGo[pos.side_to_move()]--;
935
936         Color winnerSide = movesToGo[WHITE] < movesToGo[BLACK] ? WHITE : BLACK;
937         Color loserSide = opposite_color(winnerSide);
938
939         // If one side queens at least three plies before the other, that side wins
940         if (movesToGo[winnerSide] <= movesToGo[loserSide] - 3)
941             ei.value += Sign[winnerSide] * make_score(0, UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2)));
942
943         // If one side queens one ply before the other and checks the king or attacks
944         // the undefended opponent's queening square, that side wins. To avoid cases
945         // where the opponent's king could move somewhere before first pawn queens we
946         // consider only free paths to queen for both pawns.
947         else if (   !(squares_in_front_of(WHITE, pawnToGo[WHITE]) & pos.occupied_squares())
948                  && !(squares_in_front_of(BLACK, pawnToGo[BLACK]) & pos.occupied_squares()))
949         {
950             assert(movesToGo[loserSide] - movesToGo[winnerSide] == 1);
951
952             Square winnerQSq = relative_square(winnerSide, make_square(square_file(pawnToGo[winnerSide]), RANK_8));
953             Square loserQSq = relative_square(loserSide, make_square(square_file(pawnToGo[loserSide]), RANK_8));
954
955             Bitboard b = pos.occupied_squares();
956             clear_bit(&b, pawnToGo[winnerSide]);
957             clear_bit(&b, pawnToGo[loserSide]);
958             b = queen_attacks_bb(winnerQSq, b);
959
960             if (  (b & pos.pieces(KING, loserSide))
961                 ||(bit_is_set(b, loserQSq) && !bit_is_set(ei.attacked_by(loserSide), loserQSq)))
962                 ei.value += Sign[winnerSide] * make_score(0, UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2)));
963         }
964     }
965   }
966
967
968   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
969   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
970   // if it is.
971
972   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo &ei) {
973
974     assert(square_is_ok(s));
975     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
976
977     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
978     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
979
980     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
981         && pos.see(s, b6) < 0
982         && pos.see(s, b8) < 0)
983     {
984         ei.value -= Sign[us] * TrappedBishopA7H7Penalty;
985     }
986   }
987
988
989   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
990   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
991   // black), and assigns a penalty if it is. This pattern can obviously
992   // only occur in Chess960 games.
993
994   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei) {
995
996     Piece pawn = piece_of_color_and_type(us, PAWN);
997     Square b2, b3, c3;
998
999     assert(Chess960);
1000     assert(square_is_ok(s));
1001     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1002
1003     if (square_file(s) == FILE_A)
1004     {
1005         b2 = relative_square(us, SQ_B2);
1006         b3 = relative_square(us, SQ_B3);
1007         c3 = relative_square(us, SQ_C3);
1008     }
1009     else
1010     {
1011         b2 = relative_square(us, SQ_G2);
1012         b3 = relative_square(us, SQ_G3);
1013         c3 = relative_square(us, SQ_F3);
1014     }
1015
1016     if (pos.piece_on(b2) == pawn)
1017     {
1018         Score penalty;
1019
1020         if (!pos.square_is_empty(b3))
1021             penalty = 2 * TrappedBishopA1H1Penalty;
1022         else if (pos.piece_on(c3) == pawn)
1023             penalty = TrappedBishopA1H1Penalty;
1024         else
1025             penalty = TrappedBishopA1H1Penalty / 2;
1026
1027         ei.value -= Sign[us] * penalty;
1028     }
1029   }
1030
1031
1032   // evaluate_space() computes the space evaluation for a given side. The
1033   // space evaluation is a simple bonus based on the number of safe squares
1034   // available for minor pieces on the central four files on ranks 2--4. Safe
1035   // squares one, two or three squares behind a friendly pawn are counted
1036   // twice. Finally, the space bonus is scaled by a weight taken from the
1037   // material hash table.
1038   template<Color Us, bool HasPopCnt>
1039   int evaluate_space(const Position& pos, EvalInfo& ei) {
1040
1041     const Color Them = (Us == WHITE ? BLACK : WHITE);
1042
1043     // Find the safe squares for our pieces inside the area defined by
1044     // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
1045     // pawn, or if it is undefended and attacked by an enemy piece.
1046     Bitboard safe =   SpaceMask[Us]
1047                    & ~pos.pieces(PAWN, Us)
1048                    & ~ei.attacked_by(Them, PAWN)
1049                    & (ei.attacked_by(Us) | ~ei.attacked_by(Them));
1050
1051     // Find all squares which are at most three squares behind some friendly pawn
1052     Bitboard behind = pos.pieces(PAWN, Us);
1053     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
1054     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
1055
1056     return count_1s_max_15<HasPopCnt>(safe) + count_1s_max_15<HasPopCnt>(behind & safe);
1057   }
1058
1059
1060   // apply_weight() applies an evaluation weight to a value trying to prevent overflow
1061
1062   inline Score apply_weight(Score v, Score w) {
1063       return make_score((int(mg_value(v)) * mg_value(w)) / 0x100, (int(eg_value(v)) * eg_value(w)) / 0x100);
1064   }
1065
1066
1067   // scale_by_game_phase() interpolates between a middle game and an endgame score,
1068   // based on game phase. It also scales the return value by a ScaleFactor array.
1069
1070   Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]) {
1071
1072     assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
1073     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
1074     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1075
1076     Value eg = eg_value(v);
1077     ScaleFactor f = sf[eg > Value(0) ? WHITE : BLACK];
1078     Value ev = Value((eg * int(f)) / SCALE_FACTOR_NORMAL);
1079
1080     int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
1081     return Value(result & ~(GrainSize - 1));
1082   }
1083
1084
1085   // weight_option() computes the value of an evaluation weight, by combining
1086   // two UCI-configurable weights (midgame and endgame) with an internal weight.
1087
1088   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
1089
1090     // Scale option value from 100 to 256
1091     int mg = get_option_value_int(mgOpt) * 256 / 100;
1092     int eg = get_option_value_int(egOpt) * 256 / 100;
1093
1094     return apply_weight(make_score(mg, eg), internalWeight);
1095   }
1096
1097   // init_safety() initizes the king safety evaluation, based on UCI
1098   // parameters. It is called from read_weights().
1099
1100   void init_safety() {
1101
1102     const Value MaxSlope = Value(30);
1103     const Value Peak = Value(1280);
1104     Value t[100];
1105
1106     // First setup the base table
1107     for (int i = 0; i < 100; i++)
1108     {
1109         t[i] = Value(int(0.4 * i * i));
1110
1111         if (i > 0)
1112             t[i] = Min(t[i], t[i - 1] + MaxSlope);
1113
1114         t[i] = Min(t[i], Peak);
1115     }
1116
1117     // Then apply the weights and get the final KingDangerTable[] array
1118     for (Color c = WHITE; c <= BLACK; c++)
1119         for (int i = 0; i < 100; i++)
1120             KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);
1121   }
1122 }