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