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