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