Better naming borrowed from Critter
[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 #include <cassert>
21 #include <iostream>
22 #include <iomanip>
23 #include <sstream>
24
25 #include "bitcount.h"
26 #include "evaluate.h"
27 #include "material.h"
28 #include "pawns.h"
29 #include "thread.h"
30 #include "ucioption.h"
31
32 namespace {
33
34   // Struct EvalInfo contains various information computed and collected
35   // by the evaluation functions.
36   struct EvalInfo {
37
38     // Pointers to material and pawn hash table entries
39     MaterialInfo* mi;
40     PawnInfo* pi;
41
42     // attackedBy[color][piece type] is a bitboard representing all squares
43     // attacked by a given color and piece type, attackedBy[color][0] contains
44     // all squares attacked by the given color.
45     Bitboard attackedBy[2][8];
46
47     // kingRing[color] is the zone around the king which is considered
48     // by the king safety evaluation. This consists of the squares directly
49     // adjacent to the king, and the three (or two, for a king on an edge file)
50     // squares two ranks in front of the king. For instance, if black's king
51     // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
52     // f7, g7, h7, f6, g6 and h6.
53     Bitboard kingRing[2];
54
55     // kingAttackersCount[color] is the number of pieces of the given color
56     // which attack a square in the kingRing of the enemy king.
57     int kingAttackersCount[2];
58
59     // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
60     // given color which attack a square in the kingRing of the enemy king. The
61     // weights of the individual piece types are given by the variables
62     // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
63     // KnightAttackWeight in evaluate.cpp
64     int kingAttackersWeight[2];
65
66     // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
67     // directly adjacent to the king of the given color. Pieces which attack
68     // more than one square are counted multiple times. For instance, if black's
69     // king is on g8 and there's a white knight on g5, this knight adds
70     // 2 to kingAdjacentZoneAttacksCount[BLACK].
71     int kingAdjacentZoneAttacksCount[2];
72   };
73
74   // Evaluation grain size, must be a power of 2
75   const int GrainSize = 8;
76
77   // Evaluation weights, initialized from UCI options
78   enum { Mobility, PassedPawns, Space, KingDangerUs, KingDangerThem };
79   Score Weights[6];
80
81   typedef Value V;
82   #define S(mg, eg) make_score(mg, eg)
83
84   // Internal evaluation weights. These are applied on top of the evaluation
85   // weights read from UCI parameters. The purpose is to be able to change
86   // the evaluation weights while keeping the default values of the UCI
87   // parameters at 100, which looks prettier.
88   //
89   // Values modified by Joona Kiiski
90   const Score WeightsInternal[] = {
91       S(248, 271), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
92   };
93
94   // MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
95   // end game, indexed by piece type and number of attacked squares not occupied
96   // by friendly pieces.
97   const Score MobilityBonus[][32] = {
98      {}, {},
99      { S(-38,-33), S(-25,-23), S(-12,-13), S( 0, -3), S(12,  7), S(25, 17), // Knights
100        S( 31, 22), S( 38, 27), S( 38, 27) },
101      { S(-25,-30), S(-11,-16), S(  3, -2), S(17, 12), S(31, 26), S(45, 40), // Bishops
102        S( 57, 52), S( 65, 60), S( 71, 65), S(74, 69), S(76, 71), S(78, 73),
103        S( 79, 74), S( 80, 75), S( 81, 76), S(81, 76) },
104      { S(-20,-36), S(-14,-19), S( -8, -3), S(-2, 13), S( 4, 29), S(10, 46), // Rooks
105        S( 14, 62), S( 19, 79), S( 23, 95), S(26,106), S(27,111), S(28,114),
106        S( 29,116), S( 30,117), S( 31,118), S(32,118) },
107      { S(-10,-18), S( -8,-13), S( -6, -7), S(-3, -2), S(-1,  3), S( 1,  8), // Queens
108        S(  3, 13), S(  5, 19), S(  8, 23), S(10, 27), S(12, 32), S(15, 34),
109        S( 16, 35), S( 17, 35), S( 18, 35), S(20, 35), S(20, 35), S(20, 35),
110        S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
111        S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
112        S( 20, 35), S( 20, 35) }
113   };
114
115   // OutpostBonus[PieceType][Square] contains outpost bonuses of knights and
116   // bishops, indexed by piece type and square (from white's point of view).
117   const Value OutpostBonus[][64] = {
118   {
119   //  A     B     C     D     E     F     G     H
120     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
121     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
122     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
123     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
124     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
125     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) },
126   {
127     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
128     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
129     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
130     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
131     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
132     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
133   };
134
135   // ThreatBonus[attacking][attacked] contains threat bonuses according to
136   // which piece type attacks which one.
137   const Score ThreatBonus[][8] = {
138     {}, {},
139     { S(0, 0), S( 7, 39), S( 0,  0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
140     { S(0, 0), S( 7, 39), S(24, 49), S( 0,  0), S(41,100), S(41,100) }, // BISHOP
141     { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0,  0), S(24, 49) }, // ROOK
142     { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0,  0) }  // QUEEN
143   };
144
145   // ThreatenedByPawnPenalty[PieceType] contains a penalty according to which
146   // piece type is attacked by an enemy pawn.
147   const Score ThreatenedByPawnPenalty[] = {
148     S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
149   };
150
151   #undef S
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 a1/h1 (a8/h8 for black) which is trapped by
166   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
167   // happen in Chess960 games.
168   const Score TrappedBishopA1H1Penalty = make_score(100, 100);
169
170   // The SpaceMask[Color] contains the area of the board which is considered
171   // by the space evaluation. In the middle game, each side is given a bonus
172   // based on how many squares inside this area are safe and available for
173   // friendly minor pieces.
174   const Bitboard SpaceMask[] = {
175     (1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
176     (1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
177     (1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
178     (1ULL << SQ_C7) | (1ULL << SQ_D7) | (1ULL << SQ_E7) | (1ULL << SQ_F7) |
179     (1ULL << SQ_C6) | (1ULL << SQ_D6) | (1ULL << SQ_E6) | (1ULL << SQ_F6) |
180     (1ULL << SQ_C5) | (1ULL << SQ_D5) | (1ULL << SQ_E5) | (1ULL << SQ_F5)
181   };
182
183   // King danger constants and variables. The king danger scores are taken
184   // from the KingDangerTable[]. Various little "meta-bonuses" measuring
185   // the strength of the enemy attack are added up into an integer, which
186   // is used as an index to KingDangerTable[].
187   //
188   // KingAttackWeights[PieceType] contains king attack weights by piece type
189   const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
190
191   // Bonuses for enemy's safe checks
192   const int QueenContactCheckBonus = 6;
193   const int RookContactCheckBonus  = 4;
194   const int QueenCheckBonus        = 3;
195   const int RookCheckBonus         = 2;
196   const int BishopCheckBonus       = 1;
197   const int KnightCheckBonus       = 1;
198
199   // InitKingDanger[Square] contains penalties based on the position of the
200   // defending king, indexed by king's square (from white's point of view).
201   const int InitKingDanger[] = {
202      2,  0,  2,  5,  5,  2,  0,  2,
203      2,  2,  4,  8,  8,  4,  2,  2,
204      7, 10, 12, 12, 12, 12, 10,  7,
205     15, 15, 15, 15, 15, 15, 15, 15,
206     15, 15, 15, 15, 15, 15, 15, 15,
207     15, 15, 15, 15, 15, 15, 15, 15,
208     15, 15, 15, 15, 15, 15, 15, 15,
209     15, 15, 15, 15, 15, 15, 15, 15
210   };
211
212   // KingDangerTable[Color][attackUnits] contains the actual king danger
213   // weighted scores, indexed by color and by a calculated integer number.
214   Score KingDangerTable[2][128];
215
216   // TracedTerms[Color][PieceType || TracedType] contains a breakdown of the
217   // evaluation terms, used when tracing.
218   Score TracedScores[2][16];
219   std::stringstream TraceStream;
220
221   enum TracedType {
222       PST = 8, IMBALANCE = 9, MOBILITY = 10, THREAT = 11,
223       PASSED = 12, UNSTOPPABLE = 13, SPACE = 14, TOTAL = 15
224   };
225
226   // Function prototypes
227   template<bool HasPopCnt, bool Trace>
228   Value do_evaluate(const Position& pos, Value& margin);
229
230   template<Color Us, bool HasPopCnt>
231   void init_eval_info(const Position& pos, EvalInfo& ei);
232
233   template<Color Us, bool HasPopCnt, bool Trace>
234   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
235
236   template<Color Us, bool HasPopCnt, bool Trace>
237   Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
238
239   template<Color Us>
240   Score evaluate_threats(const Position& pos, EvalInfo& ei);
241
242   template<Color Us, bool HasPopCnt>
243   int evaluate_space(const Position& pos, EvalInfo& ei);
244
245   template<Color Us>
246   Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
247
248   template<bool HasPopCnt>
249   Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
250
251   inline Score apply_weight(Score v, Score weight);
252   Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf);
253   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
254   void init_safety();
255   double to_cp(Value v);
256   void trace_add(int idx, Score term_w, Score term_b = SCORE_ZERO);
257 }
258
259
260 /// evaluate() is the main evaluation function. It always computes two
261 /// values, an endgame score and a middle game score, and interpolates
262 /// between them based on the remaining material.
263 Value evaluate(const Position& pos, Value& margin) {
264
265   return CpuHasPOPCNT ? do_evaluate<true, false>(pos, margin)
266                       : do_evaluate<false, false>(pos, margin);
267 }
268
269 namespace {
270
271 template<bool HasPopCnt, bool Trace>
272 Value do_evaluate(const Position& pos, Value& margin) {
273
274   EvalInfo ei;
275   Value margins[2];
276   Score score, mobilityWhite, mobilityBlack;
277
278   assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
279   assert(!pos.in_check());
280
281   // Initialize score by reading the incrementally updated scores included
282   // in the position object (material + piece square tables).
283   score = pos.value();
284
285   // margins[] store the uncertainty estimation of position's evaluation
286   // that typically is used by the search for pruning decisions.
287   margins[WHITE] = margins[BLACK] = VALUE_ZERO;
288
289   // Probe the material hash table
290   ei.mi = Threads[pos.thread()].materialTable.get_material_info(pos);
291   score += ei.mi->material_value();
292
293   // If we have a specialized evaluation function for the current material
294   // configuration, call it and return.
295   if (ei.mi->specialized_eval_exists())
296   {
297       margin = VALUE_ZERO;
298       return ei.mi->evaluate(pos);
299   }
300
301   // Probe the pawn hash table
302   ei.pi = Threads[pos.thread()].pawnTable.get_pawn_info(pos);
303   score += ei.pi->pawns_value();
304
305   // Initialize attack and king safety bitboards
306   init_eval_info<WHITE, HasPopCnt>(pos, ei);
307   init_eval_info<BLACK, HasPopCnt>(pos, ei);
308
309   // Evaluate pieces and mobility
310   score +=  evaluate_pieces_of_color<WHITE, HasPopCnt, Trace>(pos, ei, mobilityWhite)
311           - evaluate_pieces_of_color<BLACK, HasPopCnt, Trace>(pos, ei, mobilityBlack);
312
313   score += apply_weight(mobilityWhite - mobilityBlack, Weights[Mobility]);
314
315   // Evaluate kings after all other pieces because we need complete attack
316   // information when computing the king safety evaluation.
317   score +=  evaluate_king<WHITE, HasPopCnt, Trace>(pos, ei, margins)
318           - evaluate_king<BLACK, HasPopCnt, Trace>(pos, ei, margins);
319
320   // Evaluate tactical threats, we need full attack information including king
321   score +=  evaluate_threats<WHITE>(pos, ei)
322           - evaluate_threats<BLACK>(pos, ei);
323
324   // Evaluate passed pawns, we need full attack information including king
325   score +=  evaluate_passed_pawns<WHITE>(pos, ei)
326           - evaluate_passed_pawns<BLACK>(pos, ei);
327
328   // If one side has only a king, check whether exists any unstoppable passed pawn
329   if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
330       score += evaluate_unstoppable_pawns<HasPopCnt>(pos, ei);
331
332   // Evaluate space for both sides, only in middle-game.
333   if (ei.mi->space_weight())
334   {
335       int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
336       score += apply_weight(make_score(s * ei.mi->space_weight(), 0), Weights[Space]);
337   }
338
339   // Scale winning side if position is more drawish that what it appears
340   ScaleFactor sf = eg_value(score) > VALUE_DRAW ? ei.mi->scale_factor(pos, WHITE)
341                                                 : ei.mi->scale_factor(pos, BLACK);
342
343   // If we don't already have an unusual scale factor, check for opposite
344   // colored bishop endgames, and use a lower scale for those.
345   if (   ei.mi->game_phase() < PHASE_MIDGAME
346       && pos.opposite_colored_bishops()
347       && sf == SCALE_FACTOR_NORMAL)
348   {
349       // Only the two bishops ?
350       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
351           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
352       {
353           // Check for KBP vs KB with only a single pawn that is almost
354           // certainly a draw or at least two pawns.
355           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
356           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
357       }
358       else
359           // Endgame with opposite-colored bishops, but also other pieces. Still
360           // a bit drawish, but not as drawish as with only the two bishops.
361            sf = ScaleFactor(50);
362   }
363
364   // Interpolate between the middle game and the endgame score
365   margin = margins[pos.side_to_move()];
366   Value v = scale_by_game_phase(score, ei.mi->game_phase(), sf);
367
368   // In case of tracing add all single evaluation contributions for both white and black
369   if (Trace)
370   {
371       trace_add(PST, pos.value());
372       trace_add(IMBALANCE, ei.mi->material_value());
373       trace_add(PAWN, ei.pi->pawns_value());
374       trace_add(MOBILITY, apply_weight(mobilityWhite, Weights[Mobility]), apply_weight(mobilityBlack, Weights[Mobility]));
375       trace_add(THREAT, evaluate_threats<WHITE>(pos, ei), evaluate_threats<BLACK>(pos, ei));
376       trace_add(PASSED, evaluate_passed_pawns<WHITE>(pos, ei), evaluate_passed_pawns<BLACK>(pos, ei));
377       trace_add(UNSTOPPABLE, evaluate_unstoppable_pawns<false>(pos, ei));
378       Score w = make_score(ei.mi->space_weight() * evaluate_space<WHITE, false>(pos, ei), 0);
379       Score b = make_score(ei.mi->space_weight() * evaluate_space<BLACK, false>(pos, ei), 0);
380       trace_add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
381       trace_add(TOTAL, score);
382       TraceStream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
383                   << ", Black: " << to_cp(margins[BLACK])
384                   << "\nScaling: " << std::noshowpos
385                   << std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
386                   << std::setw(6) << 100.0 * (1.0 - ei.mi->game_phase() / 128.0) << "% * "
387                   << std::setw(6) << (100.0 * sf) / SCALE_FACTOR_NORMAL << "% EG.\n"
388                   << "Total evaluation: " << to_cp(v);
389   }
390
391   return pos.side_to_move() == WHITE ? v : -v;
392 }
393
394 } // namespace
395
396
397 /// read_weights() reads evaluation weights from the corresponding UCI parameters
398
399 void read_evaluation_uci_options(Color us) {
400
401   // King safety is asymmetrical. Our king danger level is weighted by
402   // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
403   const int kingDangerUs   = (us == WHITE ? KingDangerUs   : KingDangerThem);
404   const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
405
406   Weights[Mobility]       = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
407   Weights[PassedPawns]    = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
408   Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
409   Weights[kingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
410   Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
411
412   // If running in analysis mode, make sure we use symmetrical king safety. We do this
413   // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
414   if (Options["UCI_AnalyseMode"].value<bool>())
415       Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
416
417   init_safety();
418 }
419
420
421 namespace {
422
423   // init_eval_info() initializes king bitboards for given color adding
424   // pawn attacks. To be done at the beginning of the evaluation.
425
426   template<Color Us, bool HasPopCnt>
427   void init_eval_info(const Position& pos, EvalInfo& ei) {
428
429     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
430     const Color Them = (Us == WHITE ? BLACK : WHITE);
431
432     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
433     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
434
435     // Init king safety tables only if we are going to use them
436     if (   pos.piece_count(Us, QUEEN)
437         && pos.non_pawn_material(Us) >= QueenValueMidgame + RookValueMidgame)
438     {
439         ei.kingRing[Them] = (b | (Us == WHITE ? b >> 8 : b << 8));
440         b &= ei.attackedBy[Us][PAWN];
441         ei.kingAttackersCount[Us] = b ? count_1s<Max15>(b) / 2 : 0;
442         ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
443     } else
444         ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
445   }
446
447
448   // evaluate_outposts() evaluates bishop and knight outposts squares
449
450   template<PieceType Piece, Color Us>
451   Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
452
453     const Color Them = (Us == WHITE ? BLACK : WHITE);
454
455     assert (Piece == BISHOP || Piece == KNIGHT);
456
457     // Initial bonus based on square
458     Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
459
460     // Increase bonus if supported by pawn, especially if the opponent has
461     // no minor piece which can exchange the outpost piece.
462     if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
463     {
464         if (    pos.pieces(KNIGHT, Them) == EmptyBoardBB
465             && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
466             bonus += bonus + bonus / 2;
467         else
468             bonus += bonus / 2;
469     }
470     return make_score(bonus, bonus);
471   }
472
473
474   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
475
476   template<PieceType Piece, Color Us, bool HasPopCnt, bool Trace>
477   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
478
479     Bitboard b;
480     Square s, ksq;
481     int mob;
482     File f;
483     Score score = SCORE_ZERO;
484
485     const BitCountType Full  = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64 : CNT32;
486     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
487     const Color Them = (Us == WHITE ? BLACK : WHITE);
488     const Square* pl = pos.piece_list(Us, Piece);
489
490     ei.attackedBy[Us][Piece] = EmptyBoardBB;
491
492     while ((s = *pl++) != SQ_NONE)
493     {
494         // Find attacked squares, including x-ray attacks for bishops and rooks
495         if (Piece == KNIGHT || Piece == QUEEN)
496             b = pos.attacks_from<Piece>(s);
497         else if (Piece == BISHOP)
498             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
499         else if (Piece == ROOK)
500             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
501         else
502             assert(false);
503
504         // Update attack info
505         ei.attackedBy[Us][Piece] |= b;
506
507         // King attacks
508         if (b & ei.kingRing[Them])
509         {
510             ei.kingAttackersCount[Us]++;
511             ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
512             Bitboard bb = (b & ei.attackedBy[Them][KING]);
513             if (bb)
514                 ei.kingAdjacentZoneAttacksCount[Us] += count_1s<Max15>(bb);
515         }
516
517         // Mobility
518         mob = (Piece != QUEEN ? count_1s<Max15>(b & mobilityArea)
519                               : count_1s<Full >(b & mobilityArea));
520
521         mobility += MobilityBonus[Piece][mob];
522
523         // Decrease score if we are attacked by an enemy pawn. Remaining part
524         // of threat evaluation must be done later when we have full attack info.
525         if (bit_is_set(ei.attackedBy[Them][PAWN], s))
526             score -= ThreatenedByPawnPenalty[Piece];
527
528         // Bishop and knight outposts squares
529         if (    (Piece == BISHOP || Piece == KNIGHT)
530             && !(pos.pieces(PAWN, Them) & attack_span_mask(Us, s)))
531             score += evaluate_outposts<Piece, Us>(pos, ei, s);
532
533         // Queen or rook on 7th rank
534         if (  (Piece == ROOK || Piece == QUEEN)
535             && relative_rank(Us, s) == RANK_7
536             && relative_rank(Us, pos.king_square(Them)) == RANK_8)
537         {
538             score += (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
539         }
540
541         // Special extra evaluation for bishops
542         if (Piece == BISHOP && pos.is_chess960())
543         {
544             // An important Chess960 pattern: A cornered bishop blocked by
545             // a friendly pawn diagonally in front of it is a very serious
546             // problem, especially when that pawn is also blocked.
547             if (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1))
548             {
549                 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
550                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
551                 {
552                     if (!pos.square_is_empty(s + d + pawn_push(Us)))
553                         score -= 2*TrappedBishopA1H1Penalty;
554                     else if (pos.piece_on(s + 2*d) == make_piece(Us, PAWN))
555                         score -= TrappedBishopA1H1Penalty;
556                     else
557                         score -= TrappedBishopA1H1Penalty / 2;
558                 }
559             }
560         }
561
562         // Special extra evaluation for rooks
563         if (Piece == ROOK)
564         {
565             // Open and half-open files
566             f = file_of(s);
567             if (ei.pi->file_is_half_open(Us, f))
568             {
569                 if (ei.pi->file_is_half_open(Them, f))
570                     score += RookOpenFileBonus;
571                 else
572                     score += RookHalfOpenFileBonus;
573             }
574
575             // Penalize rooks which are trapped inside a king. Penalize more if
576             // king has lost right to castle.
577             if (mob > 6 || ei.pi->file_is_half_open(Us, f))
578                 continue;
579
580             ksq = pos.king_square(Us);
581
582             if (    file_of(ksq) >= FILE_E
583                 &&  file_of(s) > file_of(ksq)
584                 && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
585             {
586                 // Is there a half-open file between the king and the edge of the board?
587                 if (!ei.pi->has_open_file_to_right(Us, file_of(ksq)))
588                     score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
589                                                            : (TrappedRookPenalty - mob * 16), 0);
590             }
591             else if (    file_of(ksq) <= FILE_D
592                      &&  file_of(s) < file_of(ksq)
593                      && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
594             {
595                 // Is there a half-open file between the king and the edge of the board?
596                 if (!ei.pi->has_open_file_to_left(Us, file_of(ksq)))
597                     score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
598                                                            : (TrappedRookPenalty - mob * 16), 0);
599             }
600         }
601     }
602
603     if (Trace)
604         TracedScores[Us][Piece] = score;
605
606     return score;
607   }
608
609
610   // evaluate_threats<>() assigns bonuses according to the type of attacking piece
611   // and the type of attacked one.
612
613   template<Color Us>
614   Score evaluate_threats(const Position& pos, EvalInfo& ei) {
615
616     const Color Them = (Us == WHITE ? BLACK : WHITE);
617
618     Bitboard b;
619     Score score = SCORE_ZERO;
620
621     // Enemy pieces not defended by a pawn and under our attack
622     Bitboard weakEnemies =  pos.pieces(Them)
623                           & ~ei.attackedBy[Them][PAWN]
624                           & ei.attackedBy[Us][0];
625     if (!weakEnemies)
626         return SCORE_ZERO;
627
628     // Add bonus according to type of attacked enemy piece and to the
629     // type of attacking piece, from knights to queens. Kings are not
630     // considered because are already handled in king evaluation.
631     for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
632     {
633         b = ei.attackedBy[Us][pt1] & weakEnemies;
634         if (b)
635             for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
636                 if (b & pos.pieces(pt2))
637                     score += ThreatBonus[pt1][pt2];
638     }
639     return score;
640   }
641
642
643   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
644   // pieces of a given color.
645
646   template<Color Us, bool HasPopCnt, bool Trace>
647   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {
648
649     const Color Them = (Us == WHITE ? BLACK : WHITE);
650
651     Score score = mobility = SCORE_ZERO;
652
653     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
654     const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us));
655
656     score += evaluate_pieces<KNIGHT, Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
657     score += evaluate_pieces<BISHOP, Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
658     score += evaluate_pieces<ROOK,   Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
659     score += evaluate_pieces<QUEEN,  Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
660
661     // Sum up all attacked squares
662     ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
663                            | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
664                            | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
665     return score;
666   }
667
668
669   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
670
671   template<Color Us, bool HasPopCnt, bool Trace>
672   Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
673
674     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
675     const Color Them = (Us == WHITE ? BLACK : WHITE);
676
677     Bitboard undefended, b, b1, b2, safe;
678     int attackUnits;
679     const Square ksq = pos.king_square(Us);
680
681     // King shelter
682     Score score = ei.pi->king_shelter<Us>(pos, ksq);
683
684     // King safety. This is quite complicated, and is almost certainly far
685     // from optimally tuned.
686     if (   ei.kingAttackersCount[Them] >= 2
687         && ei.kingAdjacentZoneAttacksCount[Them])
688     {
689         // Find the attacked squares around the king which has no defenders
690         // apart from the king itself
691         undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
692         undefended &= ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
693                         | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
694                         | ei.attackedBy[Us][QUEEN]);
695
696         // Initialize the 'attackUnits' variable, which is used later on as an
697         // index to the KingDangerTable[] array. The initial value is based on
698         // the number and types of the enemy's attacking pieces, the number of
699         // attacked and undefended squares around our king, the square of the
700         // king, and the quality of the pawn shelter.
701         attackUnits =  Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
702                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s<Max15>(undefended))
703                      + InitKingDanger[relative_square(Us, ksq)]
704                      - mg_value(ei.pi->king_shelter<Us>(pos, ksq)) / 32;
705
706         // Analyse enemy's safe queen contact checks. First find undefended
707         // squares around the king attacked by enemy queen...
708         b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
709         if (b)
710         {
711             // ...then remove squares not supported by another enemy piece
712             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
713                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
714             if (b)
715                 attackUnits +=  QueenContactCheckBonus
716                               * count_1s<Max15>(b)
717                               * (Them == pos.side_to_move() ? 2 : 1);
718         }
719
720         // Analyse enemy's safe rook contact checks. First find undefended
721         // squares around the king attacked by enemy rooks...
722         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
723
724         // Consider only squares where the enemy rook gives check
725         b &= RookPseudoAttacks[ksq];
726
727         if (b)
728         {
729             // ...then remove squares not supported by another enemy piece
730             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
731                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
732             if (b)
733                 attackUnits +=  RookContactCheckBonus
734                               * count_1s<Max15>(b)
735                               * (Them == pos.side_to_move() ? 2 : 1);
736         }
737
738         // Analyse enemy's safe distance checks for sliders and knights
739         safe = ~(pos.pieces(Them) | ei.attackedBy[Us][0]);
740
741         b1 = pos.attacks_from<ROOK>(ksq) & safe;
742         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
743
744         // Enemy queen safe checks
745         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
746         if (b)
747             attackUnits += QueenCheckBonus * count_1s<Max15>(b);
748
749         // Enemy rooks safe checks
750         b = b1 & ei.attackedBy[Them][ROOK];
751         if (b)
752             attackUnits += RookCheckBonus * count_1s<Max15>(b);
753
754         // Enemy bishops safe checks
755         b = b2 & ei.attackedBy[Them][BISHOP];
756         if (b)
757             attackUnits += BishopCheckBonus * count_1s<Max15>(b);
758
759         // Enemy knights safe checks
760         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
761         if (b)
762             attackUnits += KnightCheckBonus * count_1s<Max15>(b);
763
764         // To index KingDangerTable[] attackUnits must be in [0, 99] range
765         attackUnits = Min(99, Max(0, attackUnits));
766
767         // Finally, extract the king danger score from the KingDangerTable[]
768         // array and subtract the score from evaluation. Set also margins[]
769         // value that will be used for pruning because this value can sometimes
770         // be very big, and so capturing a single attacking piece can therefore
771         // result in a score change far bigger than the value of the captured piece.
772         score -= KingDangerTable[Us][attackUnits];
773         margins[Us] += mg_value(KingDangerTable[Us][attackUnits]);
774     }
775
776     if (Trace)
777         TracedScores[Us][KING] = score;
778
779     return score;
780   }
781
782
783   // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
784
785   template<Color Us>
786   Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
787
788     const Color Them = (Us == WHITE ? BLACK : WHITE);
789
790     Bitboard b, squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
791     Score score = SCORE_ZERO;
792
793     b = ei.pi->passed_pawns(Us);
794
795     if (!b)
796         return SCORE_ZERO;
797
798     do {
799         Square s = pop_1st_bit(&b);
800
801         assert(pos.pawn_is_passed(Us, s));
802
803         int r = int(relative_rank(Us, s) - RANK_2);
804         int rr = r * (r - 1);
805
806         // Base bonus based on rank
807         Value mbonus = Value(20 * rr);
808         Value ebonus = Value(10 * (rr + r + 1));
809
810         if (rr)
811         {
812             Square blockSq = s + pawn_push(Us);
813
814             // Adjust bonus based on kings proximity
815             ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * rr);
816             ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * rr);
817
818             // If blockSq is not the queening square then consider also a second push
819             if (rank_of(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
820                 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
821
822             // If the pawn is free to advance, increase bonus
823             if (pos.square_is_empty(blockSq))
824             {
825                 squaresToQueen = squares_in_front_of(Us, s);
826                 defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
827
828                 // If there is an enemy rook or queen attacking the pawn from behind,
829                 // add all X-ray attacks by the rook or queen. Otherwise consider only
830                 // the squares in the pawn's path attacked or occupied by the enemy.
831                 if (   (squares_in_front_of(Them, s) & pos.pieces(ROOK, QUEEN, Them))
832                     && (squares_in_front_of(Them, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
833                     unsafeSquares = squaresToQueen;
834                 else
835                     unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces(Them));
836
837                 // If there aren't enemy attacks or pieces along the path to queen give
838                 // huge bonus. Even bigger if we protect the pawn's path.
839                 if (!unsafeSquares)
840                     ebonus += Value(rr * (squaresToQueen == defendedSquares ? 17 : 15));
841                 else
842                     // OK, there are enemy attacks or pieces (but not pawns). Are those
843                     // squares which are attacked by the enemy also attacked by us ?
844                     // If yes, big bonus (but smaller than when there are no enemy attacks),
845                     // if no, somewhat smaller bonus.
846                     ebonus += Value(rr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
847
848                 // At last, add a small bonus when there are no *friendly* pieces
849                 // in the pawn's path.
850                 if (!(squaresToQueen & pos.pieces(Us)))
851                     ebonus += Value(rr);
852             }
853         } // rr != 0
854
855         // Increase the bonus if the passed pawn is supported by a friendly pawn
856         // on the same rank and a bit smaller if it's on the previous rank.
857         supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
858         if (supportingPawns & rank_bb(s))
859             ebonus += Value(r * 20);
860         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
861             ebonus += Value(r * 12);
862
863         // Rook pawns are a special case: They are sometimes worse, and
864         // sometimes better than other passed pawns. It is difficult to find
865         // good rules for determining whether they are good or bad. For now,
866         // we try the following: Increase the value for rook pawns if the
867         // other side has no pieces apart from a knight, and decrease the
868         // value if the other side has a rook or queen.
869         if (file_of(s) == FILE_A || file_of(s) == FILE_H)
870         {
871             if (pos.non_pawn_material(Them) <= KnightValueMidgame)
872                 ebonus += ebonus / 4;
873             else if (pos.pieces(ROOK, QUEEN, Them))
874                 ebonus -= ebonus / 4;
875         }
876         score += make_score(mbonus, ebonus);
877
878     } while (b);
879
880     // Add the scores to the middle game and endgame eval
881     return apply_weight(score, Weights[PassedPawns]);
882   }
883
884
885   // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides, this is quite
886   // conservative and returns a winning score only when we are very sure that the pawn is winning.
887
888   template<bool HasPopCnt>
889   Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
890
891     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
892
893     Bitboard b, b2, blockers, supporters, queeningPath, candidates;
894     Square s, blockSq, queeningSquare;
895     Color c, winnerSide, loserSide;
896     bool pathDefended, opposed;
897     int pliesToGo, movesToGo, oppMovesToGo, sacptg, blockersCount, minKingDist, kingptg, d;
898     int pliesToQueen[] = { 256, 256 };
899
900     // Step 1. Hunt for unstoppable passed pawns. If we find at least one,
901     // record how many plies are required for promotion.
902     for (c = WHITE; c <= BLACK; c++)
903     {
904         // Skip if other side has non-pawn pieces
905         if (pos.non_pawn_material(flip(c)))
906             continue;
907
908         b = ei.pi->passed_pawns(c);
909
910         while (b)
911         {
912             s = pop_1st_bit(&b);
913             queeningSquare = relative_square(c, make_square(file_of(s), RANK_8));
914             queeningPath = squares_in_front_of(c, s);
915
916             // Compute plies to queening and check direct advancement
917             movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
918             oppMovesToGo = square_distance(pos.king_square(flip(c)), queeningSquare) - int(c != pos.side_to_move());
919             pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
920
921             if (movesToGo >= oppMovesToGo && !pathDefended)
922                 continue;
923
924             // Opponent king cannot block because path is defended and position
925             // is not in check. So only friendly pieces can be blockers.
926             assert(!pos.in_check());
927             assert((queeningPath & pos.occupied_squares()) == (queeningPath & pos.pieces(c)));
928
929             // Add moves needed to free the path from friendly pieces and retest condition
930             movesToGo += count_1s<Max15>(queeningPath & pos.pieces(c));
931
932             if (movesToGo >= oppMovesToGo && !pathDefended)
933                 continue;
934
935             pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
936             pliesToQueen[c] = Min(pliesToQueen[c], pliesToGo);
937         }
938     }
939
940     // Step 2. If either side cannot promote at least three plies before the other side then situation
941     // becomes too complex and we give up. Otherwise we determine the possibly "winning side"
942     if (abs(pliesToQueen[WHITE] - pliesToQueen[BLACK]) < 3)
943         return SCORE_ZERO;
944
945     winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
946     loserSide = flip(winnerSide);
947
948     // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
949     b = candidates = pos.pieces(PAWN, loserSide);
950
951     while (b)
952     {
953         s = pop_1st_bit(&b);
954
955         // Compute plies from queening
956         queeningSquare = relative_square(loserSide, make_square(file_of(s), RANK_8));
957         movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
958         pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
959
960         // Check if (without even considering any obstacles) we're too far away or doubled
961         if (   pliesToQueen[winnerSide] + 3 <= pliesToGo
962             || (squares_in_front_of(loserSide, s) & pos.pieces(PAWN, loserSide)))
963             clear_bit(&candidates, s);
964     }
965
966     // If any candidate is already a passed pawn it _may_ promote in time. We give up.
967     if (candidates & ei.pi->passed_pawns(loserSide))
968         return SCORE_ZERO;
969
970     // Step 4. Check new passed pawn creation through king capturing and pawn sacrifices
971     b = candidates;
972
973     while (b)
974     {
975         s = pop_1st_bit(&b);
976         sacptg = blockersCount = 0;
977         minKingDist = kingptg = 256;
978
979         // Compute plies from queening
980         queeningSquare = relative_square(loserSide, make_square(file_of(s), RANK_8));
981         movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
982         pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
983
984         // Generate list of blocking pawns and supporters
985         supporters = neighboring_files_bb(s) & candidates;
986         opposed = squares_in_front_of(loserSide, s) & pos.pieces(PAWN, winnerSide);
987         blockers = passed_pawn_mask(loserSide, s) & pos.pieces(PAWN, winnerSide);
988
989         assert(blockers);
990
991         // How many plies does it take to remove all the blocking pawns?
992         while (blockers)
993         {
994             blockSq = pop_1st_bit(&blockers);
995             movesToGo = 256;
996
997             // Check pawns that can give support to overcome obstacle, for instance
998             // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
999             if (!opposed)
1000             {
1001                 b2 = supporters & in_front_bb(winnerSide, blockSq + pawn_push(winnerSide));
1002
1003                 while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
1004                 {
1005                     d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
1006                     movesToGo = Min(movesToGo, d);
1007                 }
1008             }
1009
1010             // Check pawns that can be sacrificed against the blocking pawn
1011             b2 = attack_span_mask(winnerSide, blockSq) & candidates & ~(1ULL << s);
1012
1013             while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
1014             {
1015                 d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
1016                 movesToGo = Min(movesToGo, d);
1017             }
1018
1019             // If obstacle can be destroyed with an immediate pawn exchange / sacrifice,
1020             // it's not a real obstacle and we have nothing to add to pliesToGo.
1021             if (movesToGo <= 0)
1022                 continue;
1023
1024             // Plies needed to sacrifice against all the blocking pawns
1025             sacptg += movesToGo * 2;
1026             blockersCount++;
1027
1028             // Plies needed for the king to capture all the blocking pawns
1029             d = square_distance(pos.king_square(loserSide), blockSq);
1030             minKingDist = Min(minKingDist, d);
1031             kingptg = (minKingDist + blockersCount) * 2;
1032         }
1033
1034         // Check if pawn sacrifice plan _may_ save the day
1035         if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
1036             return SCORE_ZERO;
1037
1038         // Check if king capture plan _may_ save the day (contains some false positives)
1039         if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
1040             return SCORE_ZERO;
1041     }
1042
1043     // Winning pawn is unstoppable and will promote as first, return big score
1044     Score score = make_score(0, (Value) 0x500 - 0x20 * pliesToQueen[winnerSide]);
1045     return winnerSide == WHITE ? score : -score;
1046   }
1047
1048
1049   // evaluate_space() computes the space evaluation for a given side. The
1050   // space evaluation is a simple bonus based on the number of safe squares
1051   // available for minor pieces on the central four files on ranks 2--4. Safe
1052   // squares one, two or three squares behind a friendly pawn are counted
1053   // twice. Finally, the space bonus is scaled by a weight taken from the
1054   // material hash table. The aim is to improve play on game opening.
1055   template<Color Us, bool HasPopCnt>
1056   int evaluate_space(const Position& pos, EvalInfo& ei) {
1057
1058     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
1059     const Color Them = (Us == WHITE ? BLACK : WHITE);
1060
1061     // Find the safe squares for our pieces inside the area defined by
1062     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
1063     // pawn, or if it is undefended and attacked by an enemy piece.
1064     Bitboard safe =   SpaceMask[Us]
1065                    & ~pos.pieces(PAWN, Us)
1066                    & ~ei.attackedBy[Them][PAWN]
1067                    & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
1068
1069     // Find all squares which are at most three squares behind some friendly pawn
1070     Bitboard behind = pos.pieces(PAWN, Us);
1071     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
1072     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
1073
1074     return count_1s<Max15>(safe) + count_1s<Max15>(behind & safe);
1075   }
1076
1077
1078   // apply_weight() applies an evaluation weight to a value trying to prevent overflow
1079
1080   inline Score apply_weight(Score v, Score w) {
1081     return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
1082                       (int(eg_value(v)) * eg_value(w)) / 0x100);
1083   }
1084
1085
1086   // scale_by_game_phase() interpolates between a middle game and an endgame score,
1087   // based on game phase. It also scales the return value by a ScaleFactor array.
1088
1089   Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf) {
1090
1091     assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
1092     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
1093     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1094
1095     int ev = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
1096     int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
1097     return Value((result + GrainSize / 2) & ~(GrainSize - 1));
1098   }
1099
1100
1101   // weight_option() computes the value of an evaluation weight, by combining
1102   // two UCI-configurable weights (midgame and endgame) with an internal weight.
1103
1104   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
1105
1106     // Scale option value from 100 to 256
1107     int mg = Options[mgOpt].value<int>() * 256 / 100;
1108     int eg = Options[egOpt].value<int>() * 256 / 100;
1109
1110     return apply_weight(make_score(mg, eg), internalWeight);
1111   }
1112
1113
1114   // init_safety() initizes the king safety evaluation, based on UCI
1115   // parameters. It is called from read_weights().
1116
1117   void init_safety() {
1118
1119     const Value MaxSlope = Value(30);
1120     const Value Peak = Value(1280);
1121     Value t[100];
1122
1123     // First setup the base table
1124     for (int i = 0; i < 100; i++)
1125     {
1126         t[i] = Value(int(0.4 * i * i));
1127
1128         if (i > 0)
1129             t[i] = Min(t[i], t[i - 1] + MaxSlope);
1130
1131         t[i] = Min(t[i], Peak);
1132     }
1133
1134     // Then apply the weights and get the final KingDangerTable[] array
1135     for (Color c = WHITE; c <= BLACK; c++)
1136         for (int i = 0; i < 100; i++)
1137             KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);
1138   }
1139
1140
1141   // A couple of little helpers used by tracing code, to_cp() converts a value to
1142   // a double in centipawns scale, trace_add() stores white and black scores.
1143
1144   double to_cp(Value v) { return double(v) / double(PawnValueMidgame); }
1145
1146   void trace_add(int idx, Score wScore, Score bScore) {
1147
1148       TracedScores[WHITE][idx] = wScore;
1149       TracedScores[BLACK][idx] = bScore;
1150   }
1151
1152   // trace_row() is an helper function used by tracing code to register the
1153   // values of a single evaluation term.
1154
1155   void trace_row(const char *name, int idx) {
1156
1157     Score wScore = TracedScores[WHITE][idx];
1158     Score bScore = TracedScores[BLACK][idx];
1159
1160     switch (idx) {
1161     case PST: case IMBALANCE: case PAWN: case UNSTOPPABLE: case TOTAL:
1162         TraceStream << std::setw(20) << name << " |   ---   --- |   ---   --- | "
1163                     << std::setw(6)  << to_cp(mg_value(wScore)) << " "
1164                     << std::setw(6)  << to_cp(eg_value(wScore)) << " \n";
1165         break;
1166     default:
1167         TraceStream << std::setw(20) << name << " | " << std::noshowpos
1168                     << std::setw(5)  << to_cp(mg_value(wScore)) << " "
1169                     << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
1170                     << std::setw(5)  << to_cp(mg_value(bScore)) << " "
1171                     << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
1172                     << std::showpos
1173                     << std::setw(6)  << to_cp(mg_value(wScore - bScore)) << " "
1174                     << std::setw(6)  << to_cp(eg_value(wScore - bScore)) << " \n";
1175     }
1176   }
1177 }
1178
1179
1180 /// trace_evaluate() is like evaluate() but instead of a value returns a string
1181 /// suitable to be print on stdout with the detailed descriptions and values of
1182 /// each evaluation term. Used mainly for debugging.
1183
1184 std::string trace_evaluate(const Position& pos) {
1185
1186     Value margin;
1187     std::string totals;
1188
1189     TraceStream.str("");
1190     TraceStream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
1191     memset(TracedScores, 0, 2 * 16 * sizeof(Score));
1192
1193     do_evaluate<false, true>(pos, margin);
1194
1195     totals = TraceStream.str();
1196     TraceStream.str("");
1197
1198     TraceStream << std::setw(21) << "Eval term " << "|    White    |    Black    |     Total     \n"
1199                 <<             "                     |   MG    EG  |   MG    EG  |   MG     EG   \n"
1200                 <<             "---------------------+-------------+-------------+---------------\n";
1201
1202     trace_row("Material, PST, Tempo", PST);
1203     trace_row("Material imbalance", IMBALANCE);
1204     trace_row("Pawns", PAWN);
1205     trace_row("Knights", KNIGHT);
1206     trace_row("Bishops", BISHOP);
1207     trace_row("Rooks", ROOK);
1208     trace_row("Queens", QUEEN);
1209     trace_row("Mobility", MOBILITY);
1210     trace_row("King safety", KING);
1211     trace_row("Threats", THREAT);
1212     trace_row("Passed pawns", PASSED);
1213     trace_row("Unstoppable pawns", UNSTOPPABLE);
1214     trace_row("Space", SPACE);
1215
1216     TraceStream <<             "---------------------+-------------+-------------+---------------\n";
1217     trace_row("Total", TOTAL);
1218     TraceStream << totals;
1219
1220     return TraceStream.str();
1221 }