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