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