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