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