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