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