Retire eval margin and gains
[stockfish] / src / evaluate.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <cassert>
21 #include <iomanip>
22 #include <sstream>
23 #include <algorithm>
24
25 #include "bitcount.h"
26 #include "evaluate.h"
27 #include "material.h"
28 #include "pawns.h"
29 #include "thread.h"
30 #include "ucioption.h"
31
32 namespace {
33
34   enum ExtendedPieceType { // Used for tracing
35     PST = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL
36   };
37
38   namespace Tracing {
39
40     Score scores[COLOR_NB][TOTAL + 1];
41     std::stringstream stream;
42
43     void add(int idx, Score term_w, Score term_b = SCORE_ZERO);
44     void row(const char* name, int idx);
45     std::string do_trace(const Position& pos);
46   }
47
48   // Struct EvalInfo contains various information computed and collected
49   // by the evaluation functions.
50   struct EvalInfo {
51
52     // Pointers to material and pawn hash table entries
53     Material::Entry* mi;
54     Pawns::Entry* pi;
55
56     // attackedBy[color][piece type] is a bitboard representing all squares
57     // attacked by a given color and piece type, attackedBy[color][ALL_PIECES]
58     // contains all squares attacked by the given color.
59     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
60
61     // kingRing[color] is the zone around the king which is considered
62     // by the king safety evaluation. This consists of the squares directly
63     // adjacent to the king, and the three (or two, for a king on an edge file)
64     // squares two ranks in front of the king. For instance, if black's king
65     // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
66     // f7, g7, h7, f6, g6 and h6.
67     Bitboard kingRing[COLOR_NB];
68
69     // kingAttackersCount[color] is the number of pieces of the given color
70     // which attack a square in the kingRing of the enemy king.
71     int kingAttackersCount[COLOR_NB];
72
73     // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
74     // given color which attack a square in the kingRing of the enemy king. The
75     // weights of the individual piece types are given by the variables
76     // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
77     // KnightAttackWeight in evaluate.cpp
78     int kingAttackersWeight[COLOR_NB];
79
80     // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
81     // directly adjacent to the king of the given color. Pieces which attack
82     // more than one square are counted multiple times. For instance, if black's
83     // king is on g8 and there's a white knight on g5, this knight adds
84     // 2 to kingAdjacentZoneAttacksCount[BLACK].
85     int kingAdjacentZoneAttacksCount[COLOR_NB];
86   };
87
88   // Evaluation grain size, must be a power of 2
89   const int GrainSize = 4;
90
91   // Evaluation weights, initialized from UCI options
92   enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
93   Score Weights[6];
94
95   typedef Value V;
96   #define S(mg, eg) make_score(mg, eg)
97
98   // Internal evaluation weights. These are applied on top of the evaluation
99   // weights read from UCI parameters. The purpose is to be able to change
100   // the evaluation weights while keeping the default values of the UCI
101   // parameters at 100, which looks prettier.
102   //
103   // Values modified by Joona Kiiski
104   const Score WeightsInternal[] = {
105       S(289, 344), S(233, 201), S(221, 273), S(46, 0), S(271, 0), S(307, 0)
106   };
107
108   // MobilityBonus[PieceType][attacked] contains bonuses for middle and end
109   // game, indexed by piece type and number of attacked squares not occupied by
110   // friendly pieces.
111   const Score MobilityBonus[][32] = {
112      {}, {},
113      { S(-35,-30), S(-22,-20), S(-9,-10), S( 3,  0), S(15, 10), S(27, 20), // Knights
114        S( 37, 28), S( 42, 31), S(44, 33) },
115      { S(-22,-27), S( -8,-13), S( 6,  1), S(20, 15), S(34, 29), S(48, 43), // Bishops
116        S( 60, 55), S( 68, 63), S(74, 68), S(77, 72), S(80, 75), S(82, 77),
117        S( 84, 79), S( 86, 81) },
118      { S(-17,-33), S(-11,-16), S(-5,  0), S( 1, 16), S( 7, 32), S(13, 48), // Rooks
119        S( 18, 64), S( 22, 80), S(26, 96), S(29,109), S(31,115), S(33,119),
120        S( 35,122), S( 36,123), S(37,124) },
121      { S(-12,-20), S( -8,-13), S(-5, -7), S(-2, -1), S( 1,  5), S( 4, 11), // Queens
122        S(  7, 17), S( 10, 23), S(13, 29), S(16, 34), S(18, 38), S(20, 40),
123        S( 22, 41), S( 23, 41), S(24, 41), S(25, 41), S(25, 41), S(25, 41),
124        S( 25, 41), S( 25, 41), S(25, 41), S(25, 41), S(25, 41), S(25, 41),
125        S( 25, 41), S( 25, 41), S(25, 41), S(25, 41) }
126   };
127
128   // Outpost[PieceType][Square] contains bonuses of knights and bishops, indexed
129   // by piece type and square (from white's point of view).
130   const Value Outpost[][SQUARE_NB] = {
131   {
132   //  A     B     C     D     E     F     G     H
133     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
134     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
135     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
136     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
137     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
138     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) },
139   {
140     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
141     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
142     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
143     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
144     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
145     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
146   };
147
148   // Threat[attacking][attacked] contains bonuses according to which piece
149   // type attacks which one.
150   const Score Threat[][PIECE_TYPE_NB] = {
151     {}, {},
152     { S(0, 0), S( 7, 39), S( 0,  0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
153     { S(0, 0), S( 7, 39), S(24, 49), S( 0,  0), S(41,100), S(41,100) }, // BISHOP
154     { S(0, 0), S( 0, 22), S(15, 49), S(15, 49), S( 0,  0), S(24, 49) }, // ROOK
155     { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0,  0) }  // QUEEN
156   };
157
158   // ThreatenedByPawn[PieceType] contains a penalty according to which piece
159   // type is attacked by an enemy pawn.
160   const Score ThreatenedByPawn[] = {
161     S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
162   };
163
164   #undef S
165
166   const Score Tempo            = make_score(24, 11);
167   const Score BishopPin        = make_score(66, 11);
168   const Score RookOn7th        = make_score(11, 20);
169   const Score QueenOn7th       = make_score( 3,  8);
170   const Score RookOnPawn       = make_score(10, 28);
171   const Score QueenOnPawn      = make_score( 4, 20);
172   const Score RookOpenFile     = make_score(43, 21);
173   const Score RookSemiopenFile = make_score(19, 10);
174   const Score BishopPawns      = make_score( 8, 12);
175   const Score KnightPawns      = make_score( 8,  4);
176   const Score MinorBehindPawn  = make_score(16,  0);
177   const Score UndefendedMinor  = make_score(25, 10);
178   const Score TrappedRook      = make_score(90,  0);
179   const Score Unstoppable      = make_score( 0, 20);
180
181   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
182   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
183   // happen in Chess960 games.
184   const Score TrappedBishopA1H1 = make_score(50, 50);
185
186   // The SpaceMask[Color] contains the area of the board which is considered
187   // by the space evaluation. In the middle game, each side is given a bonus
188   // based on how many squares inside this area are safe and available for
189   // friendly minor pieces.
190   const Bitboard SpaceMask[] = {
191     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
192     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
193   };
194
195   // King danger constants and variables. The king danger scores are taken
196   // from the KingDanger[]. Various little "meta-bonuses" measuring
197   // the strength of the enemy attack are added up into an integer, which
198   // is used as an index to KingDanger[].
199   //
200   // KingAttackWeights[PieceType] contains king attack weights by piece type
201   const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
202
203   // Bonuses for enemy's safe checks
204   const int QueenContactCheck = 24;
205   const int RookContactCheck  = 16;
206   const int QueenCheck        = 12;
207   const int RookCheck         = 8;
208   const int BishopCheck       = 2;
209   const int KnightCheck       = 3;
210
211   // KingExposed[Square] contains penalties based on the position of the
212   // defending king, indexed by king's square (from white's point of view).
213   const int KingExposed[] = {
214      2,  0,  2,  5,  5,  2,  0,  2,
215      2,  2,  4,  8,  8,  4,  2,  2,
216      7, 10, 12, 12, 12, 12, 10,  7,
217     15, 15, 15, 15, 15, 15, 15, 15,
218     15, 15, 15, 15, 15, 15, 15, 15,
219     15, 15, 15, 15, 15, 15, 15, 15,
220     15, 15, 15, 15, 15, 15, 15, 15,
221     15, 15, 15, 15, 15, 15, 15, 15
222   };
223
224   // KingDanger[Color][attackUnits] contains the actual king danger weighted
225   // scores, indexed by color and by a calculated integer number.
226   Score KingDanger[COLOR_NB][128];
227
228   // Function prototypes
229   template<bool Trace>
230   Value do_evaluate(const Position& pos);
231
232   template<Color Us>
233   void init_eval_info(const Position& pos, EvalInfo& ei);
234
235   template<Color Us, bool Trace>
236   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score* mobility);
237
238   template<Color Us, bool Trace>
239   Score evaluate_king(const Position& pos, const EvalInfo& ei);
240
241   template<Color Us, bool Trace>
242   Score evaluate_threats(const Position& pos, const EvalInfo& ei);
243
244   template<Color Us, bool Trace>
245   Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei);
246
247   template<Color Us>
248   int evaluate_space(const Position& pos, const EvalInfo& ei);
249
250   Score evaluate_unstoppable_pawns(const Position& pos, Color us, const EvalInfo& ei);
251
252   Value interpolate(const Score& v, Phase ph, ScaleFactor sf);
253   Score apply_weight(Score v, Score w);
254   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
255   double to_cp(Value v);
256 }
257
258
259 namespace Eval {
260
261   /// evaluate() is the main evaluation function. It always computes two
262   /// values, an endgame score and a middle game score, and interpolates
263   /// between them based on the remaining material.
264
265   Value evaluate(const Position& pos) {
266     return do_evaluate<false>(pos);
267   }
268
269
270   /// trace() is like evaluate() but instead of a value returns a string suitable
271   /// to be print on stdout with the detailed descriptions and values of each
272   /// evaluation term. Used mainly for debugging.
273   std::string trace(const Position& pos) {
274     return Tracing::do_trace(pos);
275   }
276
277
278   /// init() computes evaluation weights from the corresponding UCI parameters
279   /// and setup king tables.
280
281   void init() {
282
283     Weights[Mobility]       = weight_option("Mobility (Midgame)", "Mobility (Endgame)", WeightsInternal[Mobility]);
284     Weights[PawnStructure]  = weight_option("Pawn Structure (Midgame)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
285     Weights[PassedPawns]    = weight_option("Passed Pawns (Midgame)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
286     Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
287     Weights[KingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
288     Weights[KingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
289
290     const int MaxSlope = 30;
291     const int Peak = 1280;
292
293     for (int t = 0, i = 1; i < 100; ++i)
294     {
295         t = std::min(Peak, std::min(int(0.4 * i * i), t + MaxSlope));
296
297         KingDanger[1][i] = apply_weight(make_score(t, 0), Weights[KingDangerUs]);
298         KingDanger[0][i] = apply_weight(make_score(t, 0), Weights[KingDangerThem]);
299     }
300   }
301
302 } // namespace Eval
303
304
305 namespace {
306
307 template<bool Trace>
308 Value do_evaluate(const Position& pos) {
309
310   assert(!pos.checkers());
311
312   EvalInfo ei;
313   Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
314   Thread* th = pos.this_thread();
315
316   // Initialize score by reading the incrementally updated scores included
317   // in the position object (material + piece square tables) and adding
318   // Tempo bonus. Score is computed from the point of view of white.
319   score = pos.psq_score() + (pos.side_to_move() == WHITE ? Tempo : -Tempo);
320
321   // Probe the material hash table
322   ei.mi = Material::probe(pos, th->materialTable, th->endgames);
323   score += ei.mi->material_value();
324
325   // If we have a specialized evaluation function for the current material
326   // configuration, call it and return.
327   if (ei.mi->specialized_eval_exists())
328       return ei.mi->evaluate(pos);
329
330   // Probe the pawn hash table
331   ei.pi = Pawns::probe(pos, th->pawnsTable);
332   score += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
333
334   // Initialize attack and king safety bitboards
335   init_eval_info<WHITE>(pos, ei);
336   init_eval_info<BLACK>(pos, ei);
337
338   // Evaluate pieces and mobility
339   score +=  evaluate_pieces_of_color<WHITE, Trace>(pos, ei, mobility)
340           - evaluate_pieces_of_color<BLACK, Trace>(pos, ei, mobility);
341
342   score += apply_weight(mobility[WHITE] - mobility[BLACK], Weights[Mobility]);
343
344   // Evaluate kings after all other pieces because we need complete attack
345   // information when computing the king safety evaluation.
346   score +=  evaluate_king<WHITE, Trace>(pos, ei)
347           - evaluate_king<BLACK, Trace>(pos, ei);
348
349   // Evaluate tactical threats, we need full attack information including king
350   score +=  evaluate_threats<WHITE, Trace>(pos, ei)
351           - evaluate_threats<BLACK, Trace>(pos, ei);
352
353   // Evaluate passed pawns, we need full attack information including king
354   score +=  evaluate_passed_pawns<WHITE, Trace>(pos, ei)
355           - evaluate_passed_pawns<BLACK, Trace>(pos, ei);
356
357   // If one side has only a king, score for potential unstoppable pawns
358   if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
359       score +=  evaluate_unstoppable_pawns(pos, WHITE, ei)
360               - evaluate_unstoppable_pawns(pos, BLACK, ei);
361
362   // Evaluate space for both sides, only in middle-game.
363   if (ei.mi->space_weight())
364   {
365       int s = evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei);
366       score += apply_weight(s * ei.mi->space_weight(), Weights[Space]);
367   }
368
369   // Scale winning side if position is more drawish that what it appears
370   ScaleFactor sf = eg_value(score) > VALUE_DRAW ? ei.mi->scale_factor(pos, WHITE)
371                                                 : ei.mi->scale_factor(pos, BLACK);
372
373   // If we don't already have an unusual scale factor, check for opposite
374   // colored bishop endgames, and use a lower scale for those.
375   if (   ei.mi->game_phase() < PHASE_MIDGAME
376       && pos.opposite_bishops()
377       && sf == SCALE_FACTOR_NORMAL)
378   {
379       // Only the two bishops ?
380       if (   pos.non_pawn_material(WHITE) == BishopValueMg
381           && pos.non_pawn_material(BLACK) == BishopValueMg)
382       {
383           // Check for KBP vs KB with only a single pawn that is almost
384           // certainly a draw or at least two pawns.
385           bool one_pawn = (pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK) == 1);
386           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
387       }
388       else
389           // Endgame with opposite-colored bishops, but also other pieces. Still
390           // a bit drawish, but not as drawish as with only the two bishops.
391            sf = ScaleFactor(50);
392   }
393
394   Value v = interpolate(score, ei.mi->game_phase(), sf);
395
396   // In case of tracing add all single evaluation contributions for both white and black
397   if (Trace)
398   {
399       Tracing::add(PST, pos.psq_score());
400       Tracing::add(IMBALANCE, ei.mi->material_value());
401       Tracing::add(PAWN, ei.pi->pawns_value());
402       Score w = ei.mi->space_weight() * evaluate_space<WHITE>(pos, ei);
403       Score b = ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei);
404       Tracing::add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
405       Tracing::add(TOTAL, score);
406       Tracing::stream << "\nScaling: " << std::noshowpos
407                       << std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
408                       << std::setw(6) << 100.0 * (1.0 - ei.mi->game_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
417   // init_eval_info() initializes king bitboards for given color adding
418   // pawn attacks. To be done at the beginning of the evaluation.
419
420   template<Color Us>
421   void init_eval_info(const Position& pos, EvalInfo& ei) {
422
423     const Color  Them = (Us == WHITE ? BLACK : WHITE);
424     const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
425
426     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
427     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
428
429     // Init king safety tables only if we are going to use them
430     if (pos.count<QUEEN>(Us) && pos.non_pawn_material(Us) > QueenValueMg + PawnValueMg)
431     {
432         ei.kingRing[Them] = b | shift_bb<Down>(b);
433         b &= ei.attackedBy[Us][PAWN];
434         ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) / 2 : 0;
435         ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
436     }
437     else
438         ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
439   }
440
441
442   // evaluate_outposts() evaluates bishop and knight outposts squares
443
444   template<PieceType Piece, Color Us>
445   Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
446
447     const Color Them = (Us == WHITE ? BLACK : WHITE);
448
449     assert (Piece == BISHOP || Piece == KNIGHT);
450
451     // Initial bonus based on square
452     Value bonus = Outpost[Piece == BISHOP][relative_square(Us, s)];
453
454     // Increase bonus if supported by pawn, especially if the opponent has
455     // no minor piece which can exchange the outpost piece.
456     if (bonus && (ei.attackedBy[Us][PAWN] & s))
457     {
458         if (   !pos.pieces(Them, KNIGHT)
459             && !(squares_of_color(s) & pos.pieces(Them, BISHOP)))
460             bonus += bonus + bonus / 2;
461         else
462             bonus += bonus / 2;
463     }
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;
476     Score score = SCORE_ZERO;
477
478     const Color Them = (Us == WHITE ? BLACK : WHITE);
479     const Square* pl = pos.list<Piece>(Us);
480
481     ei.attackedBy[Us][Piece] = 0;
482
483     while ((s = *pl++) != SQ_NONE)
484     {
485         // Find attacked squares, including x-ray attacks for bishops and rooks
486         b = Piece == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
487           : Piece ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
488                             : pos.attacks_from<Piece>(s);
489
490         ei.attackedBy[Us][Piece] |= b;
491
492         if (b & ei.kingRing[Them])
493         {
494             ei.kingAttackersCount[Us]++;
495             ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
496             Bitboard bb = b & ei.attackedBy[Them][KING];
497             if (bb)
498                 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
499         }
500
501         int mob = Piece != QUEEN ? popcount<Max15>(b & mobilityArea)
502                                  : popcount<Full >(b & mobilityArea);
503
504         mobility[Us] += MobilityBonus[Piece][mob];
505
506         // Decrease score if we are attacked by an enemy pawn. Remaining part
507         // of threat evaluation must be done later when we have full attack info.
508         if (ei.attackedBy[Them][PAWN] & s)
509             score -= ThreatenedByPawn[Piece];
510
511         // Otherwise give a bonus if we are a bishop and can pin a piece or can
512         // give a discovered check through an x-ray attack.
513         else if (    Piece == BISHOP
514                  && (PseudoAttacks[Piece][pos.king_square(Them)] & s)
515                  && !more_than_one(BetweenBB[s][pos.king_square(Them)] & pos.pieces()))
516                  score += BishopPin;
517
518         // Penalty for bishop with same coloured pawns
519         if (Piece == BISHOP)
520             score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
521
522         // Penalty for knight when there are few enemy pawns
523         if (Piece == KNIGHT)
524             score -= KnightPawns * std::max(5 - pos.count<PAWN>(Them), 0);
525
526         if (Piece == BISHOP || Piece == KNIGHT)
527         {
528             // Bishop and knight outposts squares
529             if (!(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
530                 score += evaluate_outposts<Piece, Us>(pos, ei, s);
531
532             // Bishop or knight behind a pawn
533             if (    relative_rank(Us, s) < RANK_5
534                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
535                 score += MinorBehindPawn;
536         }
537
538         if (  (Piece == ROOK || Piece == QUEEN)
539             && relative_rank(Us, s) >= RANK_5)
540         {
541             // Major piece on 7th rank and enemy king trapped on 8th
542             if (   relative_rank(Us, s) == RANK_7
543                 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
544                 score += Piece == ROOK ? RookOn7th : QueenOn7th;
545
546             // Major piece attacking enemy pawns on the same rank/file
547             Bitboard pawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
548             if (pawns)
549                 score += popcount<Max15>(pawns) * (Piece == ROOK ? RookOnPawn : QueenOnPawn);
550         }
551
552         // Special extra evaluation for rooks
553         if (Piece == ROOK)
554         {
555             // Give a bonus for a rook on a open or semi-open file
556             if (ei.pi->semiopen(Us, file_of(s)))
557                 score += ei.pi->semiopen(Them, file_of(s)) ? RookOpenFile : RookSemiopenFile;
558
559             if (mob > 3 || ei.pi->semiopen(Us, file_of(s)))
560                 continue;
561
562             Square ksq = pos.king_square(Us);
563
564             // Penalize rooks which are trapped inside a king. Penalize more if
565             // king has lost right to castle.
566             if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
567                 && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
568                 && !ei.pi->semiopen_on_side(Us, file_of(ksq), file_of(ksq) < FILE_E))
569                 score -= (TrappedRook - make_score(mob * 8, 0)) * (pos.can_castle(Us) ? 1 : 2);
570         }
571
572         // An important Chess960 pattern: A cornered bishop blocked by a friendly
573         // pawn diagonally in front of it is a very serious problem, especially
574         // when that pawn is also blocked.
575         if (   Piece == BISHOP
576             && pos.is_chess960()
577             && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
578         {
579             const enum Piece P = make_piece(Us, PAWN);
580             Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
581             if (pos.piece_on(s + d) == P)
582                 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
583                         : pos.piece_on(s + d + d) == P     ? TrappedBishopA1H1 * 2
584                                                            : TrappedBishopA1H1;
585         }
586     }
587
588     if (Trace)
589         Tracing::scores[Us][Piece] = score;
590
591     return score;
592   }
593
594
595   // evaluate_pieces_of_color() assigns bonuses and penalties to all the
596   // pieces of a given color.
597
598   template<Color Us, bool Trace>
599   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score* mobility) {
600
601     const Color Them = (Us == WHITE ? BLACK : WHITE);
602
603     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
604     const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us, PAWN, KING));
605
606     Score score =  evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea)
607                  + evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea)
608                  + evaluate_pieces<ROOK,   Us, Trace>(pos, ei, mobility, mobilityArea)
609                  + evaluate_pieces<QUEEN,  Us, Trace>(pos, ei, mobility, mobilityArea);
610
611     // Sum up all attacked squares (updated in evaluate_pieces)
612     ei.attackedBy[Us][ALL_PIECES] =  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
613                                    | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
614                                    | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
615     if (Trace)
616         Tracing::scores[Us][MOBILITY] = apply_weight(mobility[Us], Weights[Mobility]);
617
618     return score;
619   }
620
621
622   // evaluate_king() assigns bonuses and penalties to a king of a given color
623
624   template<Color Us, bool Trace>
625   Score evaluate_king(const Position& pos, const EvalInfo& ei) {
626
627     const Color Them = (Us == WHITE ? BLACK : WHITE);
628
629     Bitboard undefended, b, b1, b2, safe;
630     int attackUnits;
631     const Square ksq = pos.king_square(Us);
632
633     // King shelter and enemy pawns storm
634     Score score = ei.pi->king_safety<Us>(pos, ksq);
635
636     // Main king safety evaluation
637     if (   ei.kingAttackersCount[Them] >= 2
638         && ei.kingAdjacentZoneAttacksCount[Them])
639     {
640         // Find the attacked squares around the king which has no defenders
641         // apart from the king itself
642         undefended =  ei.attackedBy[Them][ALL_PIECES]
643                     & ei.attackedBy[Us][KING]
644                     & ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
645                         | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
646                         | ei.attackedBy[Us][QUEEN]);
647
648         // Initialize the 'attackUnits' variable, which is used later on as an
649         // index to the KingDanger[] array. The initial value is based on the
650         // number and types of the enemy's attacking pieces, the number of
651         // attacked and undefended squares around our king, the square of the
652         // king, and the quality of the pawn shelter.
653         attackUnits =  std::min(20, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
654                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
655                      + KingExposed[relative_square(Us, ksq)]
656                      - mg_value(score) / 32;
657
658         // Analyse enemy's safe queen contact checks. First find undefended
659         // squares around the king attacked by enemy queen...
660         b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
661         if (b)
662         {
663             // ...then remove squares not supported by another enemy piece
664             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
665                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
666             if (b)
667                 attackUnits +=  QueenContactCheck
668                               * popcount<Max15>(b)
669                               * (Them == pos.side_to_move() ? 2 : 1);
670         }
671
672         // Analyse enemy's safe rook contact checks. First find undefended
673         // squares around the king attacked by enemy rooks...
674         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
675
676         // Consider only squares where the enemy rook gives check
677         b &= PseudoAttacks[ROOK][ksq];
678
679         if (b)
680         {
681             // ...then remove squares not supported by another enemy piece
682             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
683                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
684             if (b)
685                 attackUnits +=  RookContactCheck
686                               * popcount<Max15>(b)
687                               * (Them == pos.side_to_move() ? 2 : 1);
688         }
689
690         // Analyse enemy's safe distance checks for sliders and knights
691         safe = ~(pos.pieces(Them) | ei.attackedBy[Us][ALL_PIECES]);
692
693         b1 = pos.attacks_from<ROOK>(ksq) & safe;
694         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
695
696         // Enemy queen safe checks
697         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
698         if (b)
699             attackUnits += QueenCheck * popcount<Max15>(b);
700
701         // Enemy rooks safe checks
702         b = b1 & ei.attackedBy[Them][ROOK];
703         if (b)
704             attackUnits += RookCheck * popcount<Max15>(b);
705
706         // Enemy bishops safe checks
707         b = b2 & ei.attackedBy[Them][BISHOP];
708         if (b)
709             attackUnits += BishopCheck * popcount<Max15>(b);
710
711         // Enemy knights safe checks
712         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
713         if (b)
714             attackUnits += KnightCheck * popcount<Max15>(b);
715
716         // To index KingDanger[] attackUnits must be in [0, 99] range
717         attackUnits = std::min(99, std::max(0, attackUnits));
718
719         // Finally, extract the king danger score from the KingDanger[]
720         // array and subtract the score from evaluation.
721         score -= KingDanger[Us == Search::RootColor][attackUnits];
722     }
723
724     if (Trace)
725         Tracing::scores[Us][KING] = score;
726
727     return score;
728   }
729
730
731   // evaluate_threats() assigns bonuses according to the type of attacking piece
732   // and the type of attacked one.
733
734   template<Color Us, bool Trace>
735   Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
736
737     const Color Them = (Us == WHITE ? BLACK : WHITE);
738
739     Bitboard b, undefendedMinors, weakEnemies;
740     Score score = SCORE_ZERO;
741
742     // Undefended minors get penalized even if not under attack
743     undefendedMinors =  pos.pieces(Them, BISHOP, KNIGHT)
744                       & ~ei.attackedBy[Them][ALL_PIECES];
745
746     if (undefendedMinors)
747         score += UndefendedMinor;
748
749     // Enemy pieces not defended by a pawn and under our attack
750     weakEnemies =  pos.pieces(Them)
751                  & ~ei.attackedBy[Them][PAWN]
752                  & ei.attackedBy[Us][ALL_PIECES];
753
754     // Add bonus according to type of attacked enemy piece and to the
755     // type of attacking piece, from knights to queens. Kings are not
756     // considered because are already handled in king evaluation.
757     if (weakEnemies)
758         for (PieceType pt1 = KNIGHT; pt1 < KING; ++pt1)
759         {
760             b = ei.attackedBy[Us][pt1] & weakEnemies;
761             if (b)
762                 for (PieceType pt2 = PAWN; pt2 < KING; ++pt2)
763                     if (b & pos.pieces(pt2))
764                         score += Threat[pt1][pt2];
765         }
766
767     if (Trace)
768         Tracing::scores[Us][THREAT] = score;
769
770     return score;
771   }
772
773
774   // evaluate_passed_pawns() evaluates the passed pawns of the given color
775
776   template<Color Us, bool Trace>
777   Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
778
779     const Color Them = (Us == WHITE ? BLACK : WHITE);
780
781     Bitboard b, squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
782     Score score = SCORE_ZERO;
783
784     b = ei.pi->passed_pawns(Us);
785
786     while (b)
787     {
788         Square s = pop_lsb(&b);
789
790         assert(pos.pawn_passed(Us, s));
791
792         int r = int(relative_rank(Us, s) - RANK_2);
793         int rr = r * (r - 1);
794
795         // Base bonus based on rank
796         Value mbonus = Value(17 * rr);
797         Value ebonus = Value(7 * (rr + r + 1));
798
799         if (rr)
800         {
801             Square blockSq = s + pawn_push(Us);
802
803             // Adjust bonus based on kings proximity
804             ebonus +=  Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr)
805                      - Value(square_distance(pos.king_square(Us  ), blockSq) * 2 * rr);
806
807             // If blockSq is not the queening square then consider also a second push
808             if (relative_rank(Us, blockSq) != RANK_8)
809                 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
810
811             // If the pawn is free to advance, increase bonus
812             if (pos.empty(blockSq))
813             {
814                 squaresToQueen = forward_bb(Us, s);
815
816                 // If there is an enemy rook or queen attacking the pawn from behind,
817                 // add all X-ray attacks by the rook or queen. Otherwise consider only
818                 // the squares in the pawn's path attacked or occupied by the enemy.
819                 if (    unlikely(forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN))
820                     && (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
821                     unsafeSquares = squaresToQueen;
822                 else
823                     unsafeSquares = squaresToQueen & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
824
825                 if (    unlikely(forward_bb(Them, s) & pos.pieces(Us, ROOK, QUEEN))
826                     && (forward_bb(Them, s) & pos.pieces(Us, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
827                     defendedSquares = squaresToQueen;
828                 else
829                     defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
830
831                 // If there aren't enemy attacks huge bonus, a bit smaller if at
832                 // least block square is not attacked, otherwise smallest bonus.
833                 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 3;
834
835                 // Big bonus if the path to queen is fully defended, a bit less
836                 // if at least block square is defended.
837                 if (defendedSquares == squaresToQueen)
838                     k += 6;
839
840                 else if (defendedSquares & blockSq)
841                     k += (unsafeSquares & defendedSquares) == unsafeSquares ? 4 : 2;
842
843                 mbonus += Value(k * rr), ebonus += Value(k * rr);
844             }
845         } // rr != 0
846
847         // Increase the bonus if the passed pawn is supported by a friendly pawn
848         // on the same rank and a bit smaller if it's on the previous rank.
849         supportingPawns = pos.pieces(Us, PAWN) & adjacent_files_bb(file_of(s));
850         if (supportingPawns & rank_bb(s))
851             ebonus += Value(r * 20);
852
853         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
854             ebonus += Value(r * 12);
855
856         // Rook pawns are a special case: They are sometimes worse, and
857         // sometimes better than other passed pawns. It is difficult to find
858         // good rules for determining whether they are good or bad. For now,
859         // we try the following: Increase the value for rook pawns if the
860         // other side has no pieces apart from a knight, and decrease the
861         // value if the other side has a rook or queen.
862         if (file_of(s) == FILE_A || file_of(s) == FILE_H)
863         {
864             if (pos.non_pawn_material(Them) <= KnightValueMg)
865                 ebonus += ebonus / 4;
866
867             else if (pos.pieces(Them, ROOK, QUEEN))
868                 ebonus -= ebonus / 4;
869         }
870
871         if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
872             ebonus += ebonus / 4;
873
874         score += make_score(mbonus, ebonus);
875
876     }
877
878     if (Trace)
879         Tracing::scores[Us][PASSED] = apply_weight(score, Weights[PassedPawns]);
880
881     // Add the scores to the middle game and endgame eval
882     return apply_weight(score, Weights[PassedPawns]);
883   }
884
885
886   // evaluate_unstoppable_pawns() scores the most advanced among the passed and
887   // candidate pawns. In case opponent has no pieces but pawns, this is somewhat
888   // related to the possibility pawns are unstoppable.
889
890   Score evaluate_unstoppable_pawns(const Position& pos, Color us, const EvalInfo& ei) {
891
892     Bitboard b = ei.pi->passed_pawns(us) | ei.pi->candidate_pawns(us);
893
894     if (!b || pos.non_pawn_material(~us))
895         return SCORE_ZERO;
896
897     return Unstoppable * int(relative_rank(us, frontmost_sq(us, b)));
898   }
899
900
901   // evaluate_space() computes the space evaluation for a given side. The
902   // space evaluation is a simple bonus based on the number of safe squares
903   // available for minor pieces on the central four files on ranks 2--4. Safe
904   // squares one, two or three squares behind a friendly pawn are counted
905   // twice. Finally, the space bonus is scaled by a weight taken from the
906   // material hash table. The aim is to improve play on game opening.
907   template<Color Us>
908   int evaluate_space(const Position& pos, const EvalInfo& ei) {
909
910     const Color Them = (Us == WHITE ? BLACK : WHITE);
911
912     // Find the safe squares for our pieces inside the area defined by
913     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
914     // pawn, or if it is undefended and attacked by an enemy piece.
915     Bitboard safe =   SpaceMask[Us]
916                    & ~pos.pieces(Us, PAWN)
917                    & ~ei.attackedBy[Them][PAWN]
918                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
919
920     // Find all squares which are at most three squares behind some friendly pawn
921     Bitboard behind = pos.pieces(Us, PAWN);
922     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
923     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
924
925     // Since SpaceMask[Us] is fully on our half of the board
926     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
927
928     // Count safe + (behind & safe) with a single popcount
929     return popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
930   }
931
932
933   // interpolate() interpolates between a middle game and an endgame score,
934   // based on game phase. It also scales the return value by a ScaleFactor array.
935
936   Value interpolate(const Score& v, Phase ph, ScaleFactor sf) {
937
938     assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
939     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
940     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
941
942     int e = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
943     int r = (mg_value(v) * int(ph) + e * int(PHASE_MIDGAME - ph)) / PHASE_MIDGAME;
944     return Value((r / GrainSize) * GrainSize); // Sign independent
945   }
946
947   // apply_weight() weights score v by score w trying to prevent overflow
948   Score apply_weight(Score v, Score w) {
949     return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
950                       (int(eg_value(v)) * eg_value(w)) / 0x100);
951   }
952
953   // weight_option() computes the value of an evaluation weight, by combining
954   // two UCI-configurable weights (midgame and endgame) with an internal weight.
955
956   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
957
958     // Scale option value from 100 to 256
959     int mg = Options[mgOpt] * 256 / 100;
960     int eg = Options[egOpt] * 256 / 100;
961
962     return apply_weight(make_score(mg, eg), internalWeight);
963   }
964
965
966   // Tracing functions definitions
967
968   double to_cp(Value v) { return double(v) / double(PawnValueMg); }
969
970   void Tracing::add(int idx, Score wScore, Score bScore) {
971
972     scores[WHITE][idx] = wScore;
973     scores[BLACK][idx] = bScore;
974   }
975
976   void Tracing::row(const char* name, int idx) {
977
978     Score wScore = scores[WHITE][idx];
979     Score bScore = scores[BLACK][idx];
980
981     switch (idx) {
982     case PST: case IMBALANCE: case PAWN: case TOTAL:
983         stream << std::setw(20) << name << " |   ---   --- |   ---   --- | "
984                << std::setw(6)  << to_cp(mg_value(wScore)) << " "
985                << std::setw(6)  << to_cp(eg_value(wScore)) << " \n";
986         break;
987     default:
988         stream << std::setw(20) << name << " | " << std::noshowpos
989                << std::setw(5)  << to_cp(mg_value(wScore)) << " "
990                << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
991                << std::setw(5)  << to_cp(mg_value(bScore)) << " "
992                << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
993                << std::showpos
994                << std::setw(6)  << to_cp(mg_value(wScore - bScore)) << " "
995                << std::setw(6)  << to_cp(eg_value(wScore - bScore)) << " \n";
996     }
997   }
998
999   std::string Tracing::do_trace(const Position& pos) {
1000
1001     stream.str("");
1002     stream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
1003     std::memset(scores, 0, 2 * (TOTAL + 1) * sizeof(Score));
1004
1005     do_evaluate<true>(pos);
1006
1007     std::string totals = stream.str();
1008     stream.str("");
1009
1010     stream << std::setw(21) << "Eval term " << "|    White    |    Black    |     Total     \n"
1011                     <<             "                     |   MG    EG  |   MG    EG  |   MG     EG   \n"
1012                     <<             "---------------------+-------------+-------------+---------------\n";
1013
1014     row("Material, PST, Tempo", PST);
1015     row("Material imbalance", IMBALANCE);
1016     row("Pawns", PAWN);
1017     row("Knights", KNIGHT);
1018     row("Bishops", BISHOP);
1019     row("Rooks", ROOK);
1020     row("Queens", QUEEN);
1021     row("Mobility", MOBILITY);
1022     row("King safety", KING);
1023     row("Threats", THREAT);
1024     row("Passed pawns", PASSED);
1025     row("Space", SPACE);
1026
1027     stream <<             "---------------------+-------------+-------------+---------------\n";
1028     row("Total", TOTAL);
1029     stream << totals;
1030
1031     return stream.str();
1032   }
1033 }