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