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