409024f1112685bcc97e0008d0bb23ee28c38dc9
[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, BISHOP, KNIGHT)
681                       & ~ei.attackedBy[Them][ALL_PIECES];
682
683     if (undefendedMinors)
684         score += UndefendedMinorPenalty;
685
686     // Enemy pieces not defended by a pawn and under our attack
687     weakEnemies =  pos.pieces(Them)
688                  & ~ei.attackedBy[Them][PAWN]
689                  & ei.attackedBy[Us][ALL_PIECES];
690
691     if (!weakEnemies)
692         return score;
693
694     // Add bonus according to type of attacked enemy piece and to the
695     // type of attacking piece, from knights to queens. Kings are not
696     // considered because are already handled in king evaluation.
697     for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
698     {
699         b = ei.attackedBy[Us][pt1] & weakEnemies;
700         if (b)
701             for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
702                 if (b & pos.pieces(pt2))
703                     score += ThreatBonus[pt1][pt2];
704     }
705     return score;
706   }
707
708
709   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
710   // pieces of a given color.
711
712   template<Color Us, bool Trace>
713   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {
714
715     const Color Them = (Us == WHITE ? BLACK : WHITE);
716
717     Score score = mobility = SCORE_ZERO;
718
719     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
720     const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us, PAWN, KING));
721
722     score += evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea);
723     score += evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea);
724     score += evaluate_pieces<ROOK,   Us, Trace>(pos, ei, mobility, mobilityArea);
725     score += evaluate_pieces<QUEEN,  Us, Trace>(pos, ei, mobility, mobilityArea);
726
727     // Sum up all attacked squares
728     ei.attackedBy[Us][ALL_PIECES] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
729                                     | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
730                                     | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
731     return score;
732   }
733
734
735   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
736
737   template<Color Us, bool Trace>
738   Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
739
740     const Color Them = (Us == WHITE ? BLACK : WHITE);
741
742     Bitboard undefended, b, b1, b2, safe;
743     int attackUnits;
744     const Square ksq = pos.king_square(Us);
745
746     // King shelter and enemy pawns storm
747     Score score = ei.pi->king_safety<Us>(pos, ksq);
748
749     // King safety. This is quite complicated, and is almost certainly far
750     // from optimally tuned.
751     if (   ei.kingAttackersCount[Them] >= 2
752         && ei.kingAdjacentZoneAttacksCount[Them])
753     {
754         // Find the attacked squares around the king which has no defenders
755         // apart from the king itself
756         undefended = ei.attackedBy[Them][ALL_PIECES] & ei.attackedBy[Us][KING];
757         undefended &= ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
758                         | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
759                         | ei.attackedBy[Us][QUEEN]);
760
761         // Initialize the 'attackUnits' variable, which is used later on as an
762         // index to the KingDangerTable[] array. The initial value is based on
763         // the number and types of the enemy's attacking pieces, the number of
764         // attacked and undefended squares around our king, the square of the
765         // king, and the quality of the pawn shelter.
766         attackUnits =  std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
767                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
768                      + InitKingDanger[relative_square(Us, ksq)]
769                      - mg_value(score) / 32;
770
771         // Analyse enemy's safe queen contact checks. First find undefended
772         // squares around the king attacked by enemy queen...
773         b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
774         if (b)
775         {
776             // ...then remove squares not supported by another enemy piece
777             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
778                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
779             if (b)
780                 attackUnits +=  QueenContactCheckBonus
781                               * popcount<Max15>(b)
782                               * (Them == pos.side_to_move() ? 2 : 1);
783         }
784
785         // Analyse enemy's safe rook contact checks. First find undefended
786         // squares around the king attacked by enemy rooks...
787         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
788
789         // Consider only squares where the enemy rook gives check
790         b &= PseudoAttacks[ROOK][ksq];
791
792         if (b)
793         {
794             // ...then remove squares not supported by another enemy piece
795             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
796                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
797             if (b)
798                 attackUnits +=  RookContactCheckBonus
799                               * popcount<Max15>(b)
800                               * (Them == pos.side_to_move() ? 2 : 1);
801         }
802
803         // Analyse enemy's safe distance checks for sliders and knights
804         safe = ~(pos.pieces(Them) | ei.attackedBy[Us][ALL_PIECES]);
805
806         b1 = pos.attacks_from<ROOK>(ksq) & safe;
807         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
808
809         // Enemy queen safe checks
810         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
811         if (b)
812             attackUnits += QueenCheckBonus * popcount<Max15>(b);
813
814         // Enemy rooks safe checks
815         b = b1 & ei.attackedBy[Them][ROOK];
816         if (b)
817             attackUnits += RookCheckBonus * popcount<Max15>(b);
818
819         // Enemy bishops safe checks
820         b = b2 & ei.attackedBy[Them][BISHOP];
821         if (b)
822             attackUnits += BishopCheckBonus * popcount<Max15>(b);
823
824         // Enemy knights safe checks
825         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
826         if (b)
827             attackUnits += KnightCheckBonus * popcount<Max15>(b);
828
829         // To index KingDangerTable[] attackUnits must be in [0, 99] range
830         attackUnits = std::min(99, std::max(0, attackUnits));
831
832         // Finally, extract the king danger score from the KingDangerTable[]
833         // array and subtract the score from evaluation. Set also margins[]
834         // value that will be used for pruning because this value can sometimes
835         // be very big, and so capturing a single attacking piece can therefore
836         // result in a score change far bigger than the value of the captured piece.
837         score -= KingDangerTable[Us == Search::RootColor][attackUnits];
838         margins[Us] += mg_value(KingDangerTable[Us == Search::RootColor][attackUnits]);
839     }
840
841     if (Trace)
842         TracedScores[Us][KING] = score;
843
844     return score;
845   }
846
847
848   // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
849
850   template<Color Us>
851   Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
852
853     const Color Them = (Us == WHITE ? BLACK : WHITE);
854
855     Bitboard b, squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
856     Score score = SCORE_ZERO;
857
858     b = ei.pi->passed_pawns(Us);
859
860     if (!b)
861         return SCORE_ZERO;
862
863     do {
864         Square s = pop_lsb(&b);
865
866         assert(pos.pawn_is_passed(Us, s));
867
868         int r = int(relative_rank(Us, s) - RANK_2);
869         int rr = r * (r - 1);
870
871         // Base bonus based on rank
872         Value mbonus = Value(20 * rr);
873         Value ebonus = Value(10 * (rr + r + 1));
874
875         if (rr)
876         {
877             Square blockSq = s + pawn_push(Us);
878
879             // Adjust bonus based on kings proximity
880             ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr);
881             ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 2 * rr);
882
883             // If blockSq is not the queening square then consider also a second push
884             if (rank_of(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
885                 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
886
887             // If the pawn is free to advance, increase bonus
888             if (pos.is_empty(blockSq))
889             {
890                 squaresToQueen = forward_bb(Us, s);
891                 defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
892
893                 // If there is an enemy rook or queen attacking the pawn from behind,
894                 // add all X-ray attacks by the rook or queen. Otherwise consider only
895                 // the squares in the pawn's path attacked or occupied by the enemy.
896                 if (   (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN))
897                     && (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
898                     unsafeSquares = squaresToQueen;
899                 else
900                     unsafeSquares = squaresToQueen & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
901
902                 // If there aren't enemy attacks huge bonus, a bit smaller if at
903                 // least block square is not attacked, otherwise smallest bonus.
904                 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 3;
905
906                 // Big bonus if the path to queen is fully defended, a bit less
907                 // if at least block square is defended.
908                 if (defendedSquares == squaresToQueen)
909                     k += 6;
910
911                 else if (defendedSquares & blockSq)
912                     k += (unsafeSquares & defendedSquares) == unsafeSquares ? 4 : 2;
913
914                 mbonus += Value(k * rr), ebonus += Value(k * rr);
915             }
916         } // rr != 0
917
918         // Increase the bonus if the passed pawn is supported by a friendly pawn
919         // on the same rank and a bit smaller if it's on the previous rank.
920         supportingPawns = pos.pieces(Us, PAWN) & adjacent_files_bb(file_of(s));
921         if (supportingPawns & rank_bb(s))
922             ebonus += Value(r * 20);
923
924         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
925             ebonus += Value(r * 12);
926
927         // Rook pawns are a special case: They are sometimes worse, and
928         // sometimes better than other passed pawns. It is difficult to find
929         // good rules for determining whether they are good or bad. For now,
930         // we try the following: Increase the value for rook pawns if the
931         // other side has no pieces apart from a knight, and decrease the
932         // value if the other side has a rook or queen.
933         if (file_of(s) == FILE_A || file_of(s) == FILE_H)
934         {
935             if (pos.non_pawn_material(Them) <= KnightValueMg)
936                 ebonus += ebonus / 4;
937             else if (pos.pieces(Them, ROOK, QUEEN))
938                 ebonus -= ebonus / 4;
939         }
940         score += make_score(mbonus, ebonus);
941
942     } while (b);
943
944     // Add the scores to the middle game and endgame eval
945     return apply_weight(score, Weights[PassedPawns]);
946   }
947
948
949   // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides, this is quite
950   // conservative and returns a winning score only when we are very sure that the pawn is winning.
951
952   Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
953
954     Bitboard b, b2, blockers, supporters, queeningPath, candidates;
955     Square s, blockSq, queeningSquare;
956     Color c, winnerSide, loserSide;
957     bool pathDefended, opposed;
958     int pliesToGo, movesToGo, oppMovesToGo, sacptg, blockersCount, minKingDist, kingptg, d;
959     int pliesToQueen[] = { 256, 256 };
960
961     // Step 1. Hunt for unstoppable passed pawns. If we find at least one,
962     // record how many plies are required for promotion.
963     for (c = WHITE; c <= BLACK; c++)
964     {
965         // Skip if other side has non-pawn pieces
966         if (pos.non_pawn_material(~c))
967             continue;
968
969         b = ei.pi->passed_pawns(c);
970
971         while (b)
972         {
973             s = pop_lsb(&b);
974             queeningSquare = relative_square(c, file_of(s) | RANK_8);
975             queeningPath = forward_bb(c, s);
976
977             // Compute plies to queening and check direct advancement
978             movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
979             oppMovesToGo = square_distance(pos.king_square(~c), queeningSquare) - int(c != pos.side_to_move());
980             pathDefended = ((ei.attackedBy[c][ALL_PIECES] & queeningPath) == queeningPath);
981
982             if (movesToGo >= oppMovesToGo && !pathDefended)
983                 continue;
984
985             // Opponent king cannot block because path is defended and position
986             // is not in check. So only friendly pieces can be blockers.
987             assert(!pos.checkers());
988             assert((queeningPath & pos.pieces()) == (queeningPath & pos.pieces(c)));
989
990             // Add moves needed to free the path from friendly pieces and retest condition
991             movesToGo += popcount<Max15>(queeningPath & pos.pieces(c));
992
993             if (movesToGo >= oppMovesToGo && !pathDefended)
994                 continue;
995
996             pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
997             pliesToQueen[c] = std::min(pliesToQueen[c], pliesToGo);
998         }
999     }
1000
1001     // Step 2. If either side cannot promote at least three plies before the other side then situation
1002     // becomes too complex and we give up. Otherwise we determine the possibly "winning side"
1003     if (abs(pliesToQueen[WHITE] - pliesToQueen[BLACK]) < 3)
1004         return SCORE_ZERO;
1005
1006     winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
1007     loserSide = ~winnerSide;
1008
1009     // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
1010     b = candidates = pos.pieces(loserSide, PAWN);
1011
1012     while (b)
1013     {
1014         s = pop_lsb(&b);
1015
1016         // Compute plies from queening
1017         queeningSquare = relative_square(loserSide, file_of(s) | RANK_8);
1018         movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
1019         pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
1020
1021         // Check if (without even considering any obstacles) we're too far away or doubled
1022         if (   pliesToQueen[winnerSide] + 3 <= pliesToGo
1023             || (forward_bb(loserSide, s) & pos.pieces(loserSide, PAWN)))
1024             candidates ^= s;
1025     }
1026
1027     // If any candidate is already a passed pawn it _may_ promote in time. We give up.
1028     if (candidates & ei.pi->passed_pawns(loserSide))
1029         return SCORE_ZERO;
1030
1031     // Step 4. Check new passed pawn creation through king capturing and pawn sacrifices
1032     b = candidates;
1033
1034     while (b)
1035     {
1036         s = pop_lsb(&b);
1037         sacptg = blockersCount = 0;
1038         minKingDist = kingptg = 256;
1039
1040         // Compute plies from queening
1041         queeningSquare = relative_square(loserSide, file_of(s) | RANK_8);
1042         movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
1043         pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
1044
1045         // Generate list of blocking pawns and supporters
1046         supporters = adjacent_files_bb(file_of(s)) & candidates;
1047         opposed = forward_bb(loserSide, s) & pos.pieces(winnerSide, PAWN);
1048         blockers = passed_pawn_mask(loserSide, s) & pos.pieces(winnerSide, PAWN);
1049
1050         assert(blockers);
1051
1052         // How many plies does it take to remove all the blocking pawns?
1053         while (blockers)
1054         {
1055             blockSq = pop_lsb(&blockers);
1056             movesToGo = 256;
1057
1058             // Check pawns that can give support to overcome obstacle, for instance
1059             // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
1060             if (!opposed)
1061             {
1062                 b2 = supporters & in_front_bb(winnerSide, blockSq + pawn_push(winnerSide));
1063
1064                 while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
1065                 {
1066                     d = square_distance(blockSq, pop_lsb(&b2)) - 2;
1067                     movesToGo = std::min(movesToGo, d);
1068                 }
1069             }
1070
1071             // Check pawns that can be sacrificed against the blocking pawn
1072             b2 = attack_span_mask(winnerSide, blockSq) & candidates & ~(1ULL << s);
1073
1074             while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
1075             {
1076                 d = square_distance(blockSq, pop_lsb(&b2)) - 2;
1077                 movesToGo = std::min(movesToGo, d);
1078             }
1079
1080             // If obstacle can be destroyed with an immediate pawn exchange / sacrifice,
1081             // it's not a real obstacle and we have nothing to add to pliesToGo.
1082             if (movesToGo <= 0)
1083                 continue;
1084
1085             // Plies needed to sacrifice against all the blocking pawns
1086             sacptg += movesToGo * 2;
1087             blockersCount++;
1088
1089             // Plies needed for the king to capture all the blocking pawns
1090             d = square_distance(pos.king_square(loserSide), blockSq);
1091             minKingDist = std::min(minKingDist, d);
1092             kingptg = (minKingDist + blockersCount) * 2;
1093         }
1094
1095         // Check if pawn sacrifice plan _may_ save the day
1096         if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
1097             return SCORE_ZERO;
1098
1099         // Check if king capture plan _may_ save the day (contains some false positives)
1100         if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
1101             return SCORE_ZERO;
1102     }
1103
1104     // Winning pawn is unstoppable and will promote as first, return big score
1105     Score score = make_score(0, (Value) 1280 - 32 * pliesToQueen[winnerSide]);
1106     return winnerSide == WHITE ? score : -score;
1107   }
1108
1109
1110   // evaluate_space() computes the space evaluation for a given side. The
1111   // space evaluation is a simple bonus based on the number of safe squares
1112   // available for minor pieces on the central four files on ranks 2--4. Safe
1113   // squares one, two or three squares behind a friendly pawn are counted
1114   // twice. Finally, the space bonus is scaled by a weight taken from the
1115   // material hash table. The aim is to improve play on game opening.
1116   template<Color Us>
1117   int evaluate_space(const Position& pos, EvalInfo& ei) {
1118
1119     const Color Them = (Us == WHITE ? BLACK : WHITE);
1120
1121     // Find the safe squares for our pieces inside the area defined by
1122     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
1123     // pawn, or if it is undefended and attacked by an enemy piece.
1124     Bitboard safe =   SpaceMask[Us]
1125                    & ~pos.pieces(Us, PAWN)
1126                    & ~ei.attackedBy[Them][PAWN]
1127                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
1128
1129     // Find all squares which are at most three squares behind some friendly pawn
1130     Bitboard behind = pos.pieces(Us, PAWN);
1131     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
1132     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
1133
1134     // Since SpaceMask[Us] is fully on our half of the board
1135     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
1136
1137     // Count safe + (behind & safe) with a single popcount
1138     return popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
1139   }
1140
1141
1142   // interpolate() interpolates between a middle game and an endgame score,
1143   // based on game phase. It also scales the return value by a ScaleFactor array.
1144
1145   Value interpolate(const Score& v, Phase ph, ScaleFactor sf) {
1146
1147     assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
1148     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
1149     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1150
1151     int ev = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
1152     int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
1153     return Value((result + GrainSize / 2) & ~(GrainSize - 1));
1154   }
1155
1156
1157   // weight_option() computes the value of an evaluation weight, by combining
1158   // two UCI-configurable weights (midgame and endgame) with an internal weight.
1159
1160   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
1161
1162     // Scale option value from 100 to 256
1163     int mg = Options[mgOpt] * 256 / 100;
1164     int eg = Options[egOpt] * 256 / 100;
1165
1166     return apply_weight(make_score(mg, eg), internalWeight);
1167   }
1168
1169
1170   // A couple of little helpers used by tracing code, to_cp() converts a value to
1171   // a double in centipawns scale, trace_add() stores white and black scores.
1172
1173   double to_cp(Value v) { return double(v) / double(PawnValueMg); }
1174
1175   void trace_add(int idx, Score wScore, Score bScore) {
1176
1177     TracedScores[WHITE][idx] = wScore;
1178     TracedScores[BLACK][idx] = bScore;
1179   }
1180
1181
1182   // trace_row() is an helper function used by tracing code to register the
1183   // values of a single evaluation term.
1184
1185   void trace_row(const char* name, int idx) {
1186
1187     Score wScore = TracedScores[WHITE][idx];
1188     Score bScore = TracedScores[BLACK][idx];
1189
1190     switch (idx) {
1191     case PST: case IMBALANCE: case PAWN: case UNSTOPPABLE: case TOTAL:
1192         TraceStream << std::setw(20) << name << " |   ---   --- |   ---   --- | "
1193                     << std::setw(6)  << to_cp(mg_value(wScore)) << " "
1194                     << std::setw(6)  << to_cp(eg_value(wScore)) << " \n";
1195         break;
1196     default:
1197         TraceStream << std::setw(20) << name << " | " << std::noshowpos
1198                     << std::setw(5)  << to_cp(mg_value(wScore)) << " "
1199                     << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
1200                     << std::setw(5)  << to_cp(mg_value(bScore)) << " "
1201                     << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
1202                     << std::showpos
1203                     << std::setw(6)  << to_cp(mg_value(wScore - bScore)) << " "
1204                     << std::setw(6)  << to_cp(eg_value(wScore - bScore)) << " \n";
1205     }
1206   }
1207 }