6cd33bd503de049c65da7984259f754fce94721f
[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-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5   Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
6
7   Stockfish is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11
12   Stockfish is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include <algorithm>
22 #include <cassert>
23 #include <cstring>   // For std::memset
24 #include <iomanip>
25 #include <sstream>
26
27 #include "bitboard.h"
28 #include "evaluate.h"
29 #include "material.h"
30 #include "pawns.h"
31
32 namespace {
33
34   namespace Trace {
35
36     enum Term { // The first 8 entries are for PieceType
37       MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
38     };
39
40     double scores[TERM_NB][COLOR_NB][PHASE_NB];
41
42     double to_cp(Value v) { return double(v) / PawnValueEg; }
43
44     void add(int idx, Color c, Score s) {
45       scores[idx][c][MG] = to_cp(mg_value(s));
46       scores[idx][c][EG] = to_cp(eg_value(s));
47     }
48
49     void add(int idx, Score w, Score b = SCORE_ZERO) {
50       add(idx, WHITE, w); add(idx, BLACK, b);
51     }
52
53     std::ostream& operator<<(std::ostream& os, Term t) {
54
55       if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL)
56           os << "  ---   --- |   ---   --- | ";
57       else
58           os << std::setw(5) << scores[t][WHITE][MG] << " "
59              << std::setw(5) << scores[t][WHITE][EG] << " | "
60              << std::setw(5) << scores[t][BLACK][MG] << " "
61              << std::setw(5) << scores[t][BLACK][EG] << " | ";
62
63       os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
64          << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
65
66       return os;
67     }
68   }
69
70   using namespace Trace;
71
72   // Struct EvalInfo contains various information computed and collected
73   // by the evaluation functions.
74   struct EvalInfo {
75
76     Material::Entry* me;
77     Pawns::Entry* pe;
78     Bitboard mobilityArea[COLOR_NB];
79
80     // attackedBy[color][piece type] is a bitboard representing all squares
81     // attacked by a given color and piece type (can be also ALL_PIECES).
82     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
83
84     // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
85     // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
86     // pawn or squares attacked by 2 pawns are not explicitly added.
87     Bitboard attackedBy2[COLOR_NB];
88
89     // kingRing[color] is the zone around the king which is considered
90     // by the king safety evaluation. This consists of the squares directly
91     // adjacent to the king, and the three (or two, for a king on an edge file)
92     // squares two ranks in front of the king. For instance, if black's king
93     // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
94     // f7, g7, h7, f6, g6 and h6.
95     Bitboard kingRing[COLOR_NB];
96
97     // kingAttackersCount[color] is the number of pieces of the given color
98     // which attack a square in the kingRing of the enemy king.
99     int kingAttackersCount[COLOR_NB];
100
101     // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
102     // given color which attack a square in the kingRing of the enemy king. The
103     // weights of the individual piece types are given by the elements in the
104     // KingAttackWeights array.
105     int kingAttackersWeight[COLOR_NB];
106
107     // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
108     // color to squares directly adjacent to the enemy king. Pieces which attack
109     // more than one square are counted multiple times. For instance, if there is
110     // a white knight on g5 and black's king is on g8, this white knight adds 2
111     // to kingAdjacentZoneAttacksCount[WHITE].
112     int kingAdjacentZoneAttacksCount[COLOR_NB];
113   };
114
115   #define V(v) Value(v)
116   #define S(mg, eg) make_score(mg, eg)
117
118   // MobilityBonus[PieceType][attacked] contains bonuses for middle and end game,
119   // indexed by piece type and number of attacked squares in the mobility area.
120   const Score MobilityBonus[][32] = {
121     {}, {},
122     { S(-75,-76), S(-56,-54), S( -9,-26), S( -2,-10), S(  6,  5), S( 15, 11), // Knights
123       S( 22, 26), S( 30, 28), S( 36, 29) },
124     { S(-48,-58), S(-21,-19), S( 16, -2), S( 26, 12), S( 37, 22), S( 51, 42), // Bishops
125       S( 54, 54), S( 63, 58), S( 65, 63), S( 71, 70), S( 79, 74), S( 81, 86),
126       S( 92, 90), S( 97, 94) },
127     { S(-56,-78), S(-25,-18), S(-11, 26), S( -5, 55), S( -4, 70), S( -1, 81), // Rooks
128       S(  8,109), S( 14,120), S( 21,128), S( 23,143), S( 31,154), S( 32,160),
129       S( 43,165), S( 49,168), S( 59,169) },
130     { S(-40,-35), S(-25,-12), S(  2,  7), S(  4, 19), S( 14, 37), S( 24, 55), // Queens
131       S( 25, 62), S( 40, 76), S( 43, 79), S( 47, 87), S( 54, 94), S( 56,102),
132       S( 60,111), S( 70,116), S( 72,118), S( 73,122), S( 75,128), S( 77,130),
133       S( 85,133), S( 94,136), S( 99,140), S(108,157), S(112,158), S(113,161),
134       S(118,174), S(119,177), S(123,191), S(128,199) }
135   };
136
137   // Outpost[knight/bishop][supported by pawn] contains bonuses for minor
138   // pieces if they can reach an outpost square, bigger if that square is
139   // supported by a pawn. If the minor piece occupies an outpost square
140   // then score is doubled.
141   const Score Outpost[][2] = {
142     { S(22, 6), S(33, 9) }, // Knight
143     { S( 9, 2), S(14, 4) }  // Bishop
144   };
145
146   // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
147   // friendly pawn on the rook file.
148   const Score RookOnFile[2] = { S(20, 7), S(45, 20) };
149
150   // ThreatBySafePawn[PieceType] contains bonuses according to which piece
151   // type is attacked by a pawn which is protected or is not attacked.
152   const Score ThreatBySafePawn[PIECE_TYPE_NB] = {
153     S(0, 0), S(0, 0), S(176, 139), S(131, 127), S(217, 218), S(203, 215)
154   };
155
156   // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
157   // which piece type attacks which one. Attacks on lesser pieces which are
158   // pawn-defended are not considered.
159   const Score ThreatByMinor[PIECE_TYPE_NB] = {
160     S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
161   };
162
163   const Score ThreatByRook[PIECE_TYPE_NB] = {
164     S(0, 0), S(0, 25), S(40, 62), S(40, 59), S( 0, 34), S(35, 48)
165   };
166
167   // ThreatByKing[on one/on many] contains bonuses for king attacks on
168   // pawns or pieces which are not pawn-defended.
169   const Score ThreatByKing[2] = { S(3, 62), S(9, 138) };
170
171   // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
172   // We don't use a Score because we process the two components independently.
173   const Value Passed[][RANK_NB] = {
174     { V(5), V( 5), V(31), V(73), V(166), V(252) },
175     { V(7), V(14), V(38), V(73), V(166), V(252) }
176   };
177
178   // PassedFile[File] contains a bonus according to the file of a passed pawn
179   const Score PassedFile[FILE_NB] = {
180     S(  9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
181     S(-20,-12), S( 1, -8), S( 2, 10), S(  9, 10)
182   };
183
184   // Assorted bonuses and penalties used by evaluation
185   const Score MinorBehindPawn     = S(16,  0);
186   const Score BishopPawns         = S( 8, 12);
187   const Score RookOnPawn          = S( 8, 24);
188   const Score TrappedRook         = S(92,  0);
189   const Score WeakQueen           = S(50, 10);
190   const Score OtherCheck          = S(10, 10);
191   const Score CloseEnemies        = S( 7,  0);
192   const Score PawnlessFlank       = S(20, 80);
193   const Score ThreatByHangingPawn = S(71, 61);
194   const Score ThreatByRank        = S(16,  3);
195   const Score Hanging             = S(48, 27);
196   const Score ThreatByPawnPush    = S(38, 22);
197   const Score HinderPassedPawn    = S( 7,  0);
198
199   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
200   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
201   // happen in Chess960 games.
202   const Score TrappedBishopA1H1 = S(50, 50);
203
204   #undef S
205   #undef V
206
207   // KingAttackWeights[PieceType] contains king attack weights by piece type
208   const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
209
210   // Penalties for enemy's safe checks
211   const int QueenCheck        = 745;
212   const int RookCheck         = 688;
213   const int BishopCheck       = 588;
214   const int KnightCheck       = 924;
215
216   // Threshold for lazy evaluation
217   const Value LazyThreshold = Value(1500);
218
219   // eval_init() initializes king and attack bitboards for a given color
220   // adding pawn attacks. To be done at the beginning of the evaluation.
221
222   template<Color Us>
223   void eval_init(const Position& pos, EvalInfo& ei) {
224
225     const Color  Them = (Us == WHITE ? BLACK : WHITE);
226     const Square Up   = (Us == WHITE ? NORTH : SOUTH);
227     const Square Down = (Us == WHITE ? SOUTH : NORTH);
228     const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
229
230     // Find our pawns on the first two ranks, and those which are blocked
231     Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
232
233     // Squares occupied by those pawns, by our king, or controlled by enemy pawns
234     // are excluded from the mobility area.
235     ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them));
236
237     // Initialise the attack bitboards with the king and pawn information
238     b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
239     ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us);
240
241     ei.attackedBy2[Us]            = b & ei.attackedBy[Us][PAWN];
242     ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN];
243
244     // Init our king safety tables only if we are going to use them
245     if (pos.non_pawn_material(Them) >= QueenValueMg)
246     {
247         ei.kingRing[Us] = b | shift<Up>(b);
248         ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them));
249         ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0;
250     }
251     else
252         ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0;
253   }
254
255
256   // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
257   // color and type.
258
259   template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT>
260   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
261
262     const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
263     const Color Them = (Us == WHITE ? BLACK : WHITE);
264     const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
265                                                : Rank5BB | Rank4BB | Rank3BB);
266     const Square* pl = pos.squares<Pt>(Us);
267
268     Bitboard b, bb;
269     Square s;
270     Score score = SCORE_ZERO;
271
272     ei.attackedBy[Us][Pt] = 0;
273
274     while ((s = *pl++) != SQ_NONE)
275     {
276         // Find attacked squares, including x-ray attacks for bishops and rooks
277         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
278           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
279                          : pos.attacks_from<Pt>(s);
280
281         if (pos.pinned_pieces(Us) & s)
282             b &= LineBB[pos.square<KING>(Us)][s];
283
284         ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
285         ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
286
287         if (b & ei.kingRing[Them])
288         {
289             ei.kingAttackersCount[Us]++;
290             ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
291             ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]);
292         }
293
294         int mob = popcount(b & ei.mobilityArea[Us]);
295
296         mobility[Us] += MobilityBonus[Pt][mob];
297
298         if (Pt == BISHOP || Pt == KNIGHT)
299         {
300             // Bonus for outpost squares
301             bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them);
302             if (bb & s)
303                 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2;
304             else
305             {
306                 bb &= b & ~pos.pieces(Us);
307                 if (bb)
308                    score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)];
309             }
310
311             // Bonus when behind a pawn
312             if (    relative_rank(Us, s) < RANK_5
313                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
314                 score += MinorBehindPawn;
315
316             // Penalty for pawns on the same color square as the bishop
317             if (Pt == BISHOP)
318                 score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s);
319
320             // An important Chess960 pattern: A cornered bishop blocked by a friendly
321             // pawn diagonally in front of it is a very serious problem, especially
322             // when that pawn is also blocked.
323             if (   Pt == BISHOP
324                 && pos.is_chess960()
325                 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
326             {
327                 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
328                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
329                     score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
330                             : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
331                                                                               : TrappedBishopA1H1;
332             }
333         }
334
335         if (Pt == ROOK)
336         {
337             // Bonus for aligning with enemy pawns on the same rank/file
338             if (relative_rank(Us, s) >= RANK_5)
339                 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
340
341             // Bonus when on an open or semi-open file
342             if (ei.pe->semiopen_file(Us, file_of(s)))
343                 score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))];
344
345             // Penalty when trapped by the king, even more if the king cannot castle
346             else if (mob <= 3)
347             {
348                 Square ksq = pos.square<KING>(Us);
349
350                 if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
351                     && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
352                     score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
353             }
354         }
355
356         if (Pt == QUEEN)
357         {
358             // Penalty if any relative pin or discovered attack against the queen
359             Bitboard pinners;
360             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
361                 score -= WeakQueen;
362         }
363     }
364
365     if (DoTrace)
366         Trace::add(Pt, Us, score);
367
368     // Recursively call evaluate_pieces() of next piece type until KING is excluded
369     return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
370   }
371
372   template<>
373   Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
374   template<>
375   Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
376
377
378   // evaluate_king() assigns bonuses and penalties to a king of a given color
379
380   const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
381
382   const Bitboard KingFlank[FILE_NB] = {
383     CenterFiles >> 2, CenterFiles >> 2, CenterFiles >> 2, CenterFiles, CenterFiles,
384     CenterFiles << 2, CenterFiles << 2, CenterFiles << 2
385   };
386
387   template<Color Us, bool DoTrace>
388   Score evaluate_king(const Position& pos, const EvalInfo& ei) {
389
390     const Color Them    = (Us == WHITE ? BLACK : WHITE);
391     const Square Up     = (Us == WHITE ? NORTH : SOUTH);
392     const Bitboard Camp = (Us == WHITE ? ~Bitboard(0) ^ Rank6BB ^ Rank7BB ^ Rank8BB
393                                        : ~Bitboard(0) ^ Rank1BB ^ Rank2BB ^ Rank3BB);
394
395     const Square ksq = pos.square<KING>(Us);
396     Bitboard undefended, b, b1, b2, safe, other;
397     int kingDanger;
398
399     // King shelter and enemy pawns storm
400     Score score = ei.pe->king_safety<Us>(pos, ksq);
401
402     // Main king safety evaluation
403     if (ei.kingAttackersCount[Them])
404     {
405         // Find the attacked squares which are defended only by our king...
406         undefended =   ei.attackedBy[Them][ALL_PIECES]
407                     &  ei.attackedBy[Us][KING]
408                     & ~ei.attackedBy2[Us];
409
410         // ... and those which are not defended at all in the larger king ring
411         b =  ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
412            & ei.kingRing[Us] & ~pos.pieces(Them);
413
414         // Initialize the 'kingDanger' variable, which will be transformed
415         // later into a king danger score. The initial value is based on the
416         // number and types of the enemy's attacking pieces, the number of
417         // attacked and undefended squares around our king and the quality of
418         // the pawn shelter (current 'score' value).
419         kingDanger =  std::min(807, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
420                     + 101 * ei.kingAdjacentZoneAttacksCount[Them]
421                     + 235 * popcount(undefended)
422                     + 134 * (popcount(b) + !!pos.pinned_pieces(Us))
423                     - 717 * !pos.count<QUEEN>(Them)
424                     -   7 * mg_value(score) / 5 - 5;
425
426         // Analyse the safe enemy's checks which are possible on next move
427         safe  = ~pos.pieces(Them);
428         safe &= ~ei.attackedBy[Us][ALL_PIECES] | (undefended & ei.attackedBy2[Them]);
429
430         b1 = pos.attacks_from<ROOK  >(ksq);
431         b2 = pos.attacks_from<BISHOP>(ksq);
432
433         // Enemy queen safe checks
434         if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
435             kingDanger += QueenCheck;
436
437         // For minors and rooks, also consider the square safe if attacked twice,
438         // and only defended by our queen.
439         safe |=  ei.attackedBy2[Them]
440                & ~(ei.attackedBy2[Us] | pos.pieces(Them))
441                & ei.attackedBy[Us][QUEEN];
442
443         // Some other potential checks are also analysed, even from squares
444         // currently occupied by the opponent own pieces, as long as the square
445         // is not attacked by our pawns, and is not occupied by a blocked pawn.
446         other = ~(   ei.attackedBy[Us][PAWN]
447                   | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
448
449         // Enemy rooks safe and other checks
450         if (b1 & ei.attackedBy[Them][ROOK] & safe)
451             kingDanger += RookCheck;
452
453         else if (b1 & ei.attackedBy[Them][ROOK] & other)
454             score -= OtherCheck;
455
456         // Enemy bishops safe and other checks
457         if (b2 & ei.attackedBy[Them][BISHOP] & safe)
458             kingDanger += BishopCheck;
459
460         else if (b2 & ei.attackedBy[Them][BISHOP] & other)
461             score -= OtherCheck;
462
463         // Enemy knights safe and other checks
464         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT];
465         if (b & safe)
466             kingDanger += KnightCheck;
467
468         else if (b & other)
469             score -= OtherCheck;
470
471         // Transform the kingDanger units into a Score, and substract it from the evaluation
472         if (kingDanger > 0)
473             score -= make_score(std::min(kingDanger * kingDanger / 4096,  2 * int(BishopValueMg)), 0);
474     }
475
476     // King tropism: firstly, find squares that opponent attacks in our king flank
477     File kf = file_of(ksq);
478     b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
479
480     assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
481     assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
482
483     // Secondly, add the squares which are attacked twice in that flank and
484     // which are not defended by our pawns.
485     b =  (Us == WHITE ? b << 4 : b >> 4)
486        | (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]);
487
488     score -= CloseEnemies * popcount(b);
489
490     // Penalty when our king is on a pawnless flank
491     if (!(pos.pieces(PAWN) & KingFlank[kf]))
492         score -= PawnlessFlank;
493
494     if (DoTrace)
495         Trace::add(KING, Us, score);
496
497     return score;
498   }
499
500
501   // evaluate_threats() assigns bonuses according to the types of the attacking
502   // and the attacked pieces.
503
504   template<Color Us, bool DoTrace>
505   Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
506
507     const Color Them        = (Us == WHITE ? BLACK      : WHITE);
508     const Square Up         = (Us == WHITE ? NORTH      : SOUTH);
509     const Square Left       = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
510     const Square Right      = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
511     const Bitboard TRank2BB = (Us == WHITE ? Rank2BB    : Rank7BB);
512     const Bitboard TRank7BB = (Us == WHITE ? Rank7BB    : Rank2BB);
513
514     Bitboard b, weak, defended, safeThreats;
515     Score score = SCORE_ZERO;
516
517     // Non-pawn enemies attacked by a pawn
518     weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
519
520     if (weak)
521     {
522         b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
523                                     | ei.attackedBy[Us][ALL_PIECES]);
524
525         safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
526
527         if (weak ^ safeThreats)
528             score += ThreatByHangingPawn;
529
530         while (safeThreats)
531             score += ThreatBySafePawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];
532     }
533
534     // Non-pawn enemies defended by a pawn
535     defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
536
537     // Enemies not defended by a pawn and under our attack
538     weak =   pos.pieces(Them)
539           & ~ei.attackedBy[Them][PAWN]
540           &  ei.attackedBy[Us][ALL_PIECES];
541
542     // Add a bonus according to the kind of attacking pieces
543     if (defended | weak)
544     {
545         b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
546         while (b)
547         {
548             Square s = pop_lsb(&b);
549             score += ThreatByMinor[type_of(pos.piece_on(s))];
550             if (type_of(pos.piece_on(s)) != PAWN)
551                 score += ThreatByRank * (int)relative_rank(Them, s);
552         }
553
554         b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
555         while (b)
556         {
557             Square s = pop_lsb(&b);
558             score += ThreatByRook[type_of(pos.piece_on(s))];
559             if (type_of(pos.piece_on(s)) != PAWN)
560                 score += ThreatByRank * (int)relative_rank(Them, s);
561         }
562
563         score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
564
565         b = weak & ei.attackedBy[Us][KING];
566         if (b)
567             score += ThreatByKing[more_than_one(b)];
568     }
569
570     // Bonus if some pawns can safely push and attack an enemy piece
571     b = pos.pieces(Us, PAWN) & ~TRank7BB;
572     b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
573
574     b &=  ~pos.pieces()
575         & ~ei.attackedBy[Them][PAWN]
576         & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
577
578     b =  (shift<Left>(b) | shift<Right>(b))
579        &  pos.pieces(Them)
580        & ~ei.attackedBy[Us][PAWN];
581
582     score += ThreatByPawnPush * popcount(b);
583
584     if (DoTrace)
585         Trace::add(THREAT, Us, score);
586
587     return score;
588   }
589
590
591   // evaluate_passer_pawns() evaluates the passed pawns and candidate passed
592   // pawns of the given color.
593
594   template<Color Us, bool DoTrace>
595   Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) {
596
597     const Color Them = (Us == WHITE ? BLACK : WHITE);
598
599     Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
600     Score score = SCORE_ZERO;
601
602     b = ei.pe->passed_pawns(Us);
603
604     while (b)
605     {
606         Square s = pop_lsb(&b);
607
608         assert(!(pos.pieces(PAWN) & forward_bb(Us, s)));
609
610         bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
611         score -= HinderPassedPawn * popcount(bb);
612
613         int r = relative_rank(Us, s) - RANK_2;
614         int rr = r * (r - 1);
615
616         Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
617
618         if (rr)
619         {
620             Square blockSq = s + pawn_push(Us);
621
622             // Adjust bonus based on the king's proximity
623             ebonus +=  distance(pos.square<KING>(Them), blockSq) * 5 * rr
624                      - distance(pos.square<KING>(Us  ), blockSq) * 2 * rr;
625
626             // If blockSq is not the queening square then consider also a second push
627             if (relative_rank(Us, blockSq) != RANK_8)
628                 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
629
630             // If the pawn is free to advance, then increase the bonus
631             if (pos.empty(blockSq))
632             {
633                 // If there is a rook or queen attacking/defending the pawn from behind,
634                 // consider all the squaresToQueen. Otherwise consider only the squares
635                 // in the pawn's path attacked or occupied by the enemy.
636                 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
637
638                 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
639
640                 if (!(pos.pieces(Us) & bb))
641                     defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
642
643                 if (!(pos.pieces(Them) & bb))
644                     unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
645
646                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
647                 // assign a smaller bonus if the block square isn't attacked.
648                 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
649
650                 // If the path to the queen is fully defended, assign a big bonus.
651                 // Otherwise assign a smaller bonus if the block square is defended.
652                 if (defendedSquares == squaresToQueen)
653                     k += 6;
654
655                 else if (defendedSquares & blockSq)
656                     k += 4;
657
658                 mbonus += k * rr, ebonus += k * rr;
659             }
660             else if (pos.pieces(Us) & blockSq)
661                 mbonus += rr + r * 2, ebonus += rr + r * 2;
662         } // rr != 0
663
664         // Scale down bonus for candidate passers which need more than one pawn
665         // push to become passed.
666         if (!pos.pawn_passed(Us, s + pawn_push(Us)))
667             mbonus /= 2, ebonus /= 2;
668
669         score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
670     }
671
672     if (DoTrace)
673         Trace::add(PASSED, Us, score);
674
675     // Add the scores to the middlegame and endgame eval
676     return score;
677   }
678
679
680   // evaluate_space() computes the space evaluation for a given side. The
681   // space evaluation is a simple bonus based on the number of safe squares
682   // available for minor pieces on the central four files on ranks 2--4. Safe
683   // squares one, two or three squares behind a friendly pawn are counted
684   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
685   // improve play on game opening.
686   template<Color Us>
687   Score evaluate_space(const Position& pos, const EvalInfo& ei) {
688
689     const Color Them = (Us == WHITE ? BLACK : WHITE);
690     const Bitboard SpaceMask =
691       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
692                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
693
694     // Find the safe squares for our pieces inside the area defined by
695     // SpaceMask. A square is unsafe if it is attacked by an enemy
696     // pawn, or if it is undefended and attacked by an enemy piece.
697     Bitboard safe =   SpaceMask
698                    & ~pos.pieces(Us, PAWN)
699                    & ~ei.attackedBy[Them][PAWN]
700                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
701
702     // Find all squares which are at most three squares behind some friendly pawn
703     Bitboard behind = pos.pieces(Us, PAWN);
704     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
705     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
706
707     // Since SpaceMask[Us] is fully on our half of the board...
708     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
709
710     // ...count safe + (behind & safe) with a single popcount.
711     int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
712     bonus = std::min(16, bonus);
713     int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
714
715     return make_score(bonus * weight * weight / 18, 0);
716   }
717
718
719   // evaluate_initiative() computes the initiative correction value for the
720   // position, i.e., second order bonus/malus based on the known attacking/defending
721   // status of the players.
722   Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
723
724     int kingDistance =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
725                       - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
726     int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
727
728     // Compute the initiative bonus for the attacking side
729     int initiative = 8 * (asymmetry + kingDistance - 15) + 12 * pawns;
730
731     // Now apply the bonus: note that we find the attacking side by extracting
732     // the sign of the endgame value, and that we carefully cap the bonus so
733     // that the endgame score will never be divided by more than two.
734     int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg / 2));
735
736     return make_score(0, value);
737   }
738
739
740   // evaluate_scale_factor() computes the scale factor for the winning side
741   ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
742
743     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
744     ScaleFactor sf = ei.me->scale_factor(pos, strongSide);
745
746     // If we don't already have an unusual scale factor, check for certain
747     // types of endgames, and use a lower scale for those.
748     if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
749     {
750         if (pos.opposite_bishops())
751         {
752             // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
753             // is almost a draw, in case of KBP vs KB, it is even more a draw.
754             if (   pos.non_pawn_material(WHITE) == BishopValueMg
755                 && pos.non_pawn_material(BLACK) == BishopValueMg)
756                 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
757
758             // Endgame with opposite-colored bishops, but also other pieces. Still
759             // a bit drawish, but not as drawish as with only the two bishops.
760             return ScaleFactor(46);
761         }
762         // Endings where weaker side can place his king in front of the opponent's
763         // pawns are drawish.
764         else if (    abs(eg) <= BishopValueEg
765                  &&  pos.count<PAWN>(strongSide) <= 2
766                  && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
767             return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
768     }
769
770     return sf;
771   }
772
773 } // namespace
774
775
776 /// evaluate() is the main evaluation function. It returns a static evaluation
777 /// of the position from the point of view of the side to move.
778
779 template<bool DoTrace>
780 Value Eval::evaluate(const Position& pos) {
781
782   assert(!pos.checkers());
783
784   Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
785   Value v;
786   EvalInfo ei;
787
788   // Probe the material hash table
789   ei.me = Material::probe(pos);
790
791   // If we have a specialized evaluation function for the current material
792   // configuration, call it and return.
793   if (ei.me->specialized_eval_exists())
794       return ei.me->evaluate(pos);
795
796   // Initialize score by reading the incrementally updated scores included in
797   // the position object (material + piece square tables) and the material
798   // imbalance. Score is computed internally from the white point of view.
799   Score score = pos.psq_score() + ei.me->imbalance();
800
801   // Probe the pawn hash table
802   ei.pe = Pawns::probe(pos);
803   score += ei.pe->pawns_score();
804
805   // Early exit if score is high
806   v = (mg_value(score) + eg_value(score)) / 2;
807   if (abs(v) > LazyThreshold)
808      return pos.side_to_move() == WHITE ? v : -v;
809
810   // Initialize attack and king safety bitboards
811   eval_init<WHITE>(pos, ei);
812   eval_init<BLACK>(pos, ei);
813
814   // Evaluate all pieces but king and pawns
815   score += evaluate_pieces<DoTrace>(pos, ei, mobility);
816   score += mobility[WHITE] - mobility[BLACK];
817
818   // Evaluate kings after all other pieces because we need full attack
819   // information when computing the king safety evaluation.
820   score +=  evaluate_king<WHITE, DoTrace>(pos, ei)
821           - evaluate_king<BLACK, DoTrace>(pos, ei);
822
823   // Evaluate tactical threats, we need full attack information including king
824   score +=  evaluate_threats<WHITE, DoTrace>(pos, ei)
825           - evaluate_threats<BLACK, DoTrace>(pos, ei);
826
827   // Evaluate passed pawns, we need full attack information including king
828   score +=  evaluate_passer_pawns<WHITE, DoTrace>(pos, ei)
829           - evaluate_passer_pawns<BLACK, DoTrace>(pos, ei);
830
831   // Evaluate space for both sides, only during opening
832   if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
833       score +=  evaluate_space<WHITE>(pos, ei)
834               - evaluate_space<BLACK>(pos, ei);
835
836   // Evaluate position potential for the winning side
837   score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
838
839   // Evaluate scale factor for the winning side
840   ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
841
842   // Interpolate between a middlegame and a (scaled by 'sf') endgame score
843   v =  mg_value(score) * int(ei.me->game_phase())
844      + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
845
846   v /= int(PHASE_MIDGAME);
847
848   // In case of tracing add all remaining individual evaluation terms
849   if (DoTrace)
850   {
851       Trace::add(MATERIAL, pos.psq_score());
852       Trace::add(IMBALANCE, ei.me->imbalance());
853       Trace::add(PAWN, ei.pe->pawns_score());
854       Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
855       if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
856           Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
857                           , evaluate_space<BLACK>(pos, ei));
858       Trace::add(TOTAL, score);
859   }
860
861   return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
862 }
863
864 // Explicit template instantiations
865 template Value Eval::evaluate<true >(const Position&);
866 template Value Eval::evaluate<false>(const Position&);
867
868
869 /// trace() is like evaluate(), but instead of returning a value, it returns
870 /// a string (suitable for outputting to stdout) that contains the detailed
871 /// descriptions and values of each evaluation term. Useful for debugging.
872
873 std::string Eval::trace(const Position& pos) {
874
875   std::memset(scores, 0, sizeof(scores));
876
877   Value v = evaluate<true>(pos);
878   v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
879
880   std::stringstream ss;
881   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
882      << "      Eval term |    White    |    Black    |    Total    \n"
883      << "                |   MG    EG  |   MG    EG  |   MG    EG  \n"
884      << "----------------+-------------+-------------+-------------\n"
885      << "       Material | " << Term(MATERIAL)
886      << "      Imbalance | " << Term(IMBALANCE)
887      << "          Pawns | " << Term(PAWN)
888      << "        Knights | " << Term(KNIGHT)
889      << "         Bishop | " << Term(BISHOP)
890      << "          Rooks | " << Term(ROOK)
891      << "         Queens | " << Term(QUEEN)
892      << "       Mobility | " << Term(MOBILITY)
893      << "    King safety | " << Term(KING)
894      << "        Threats | " << Term(THREAT)
895      << "   Passed pawns | " << Term(PASSED)
896      << "          Space | " << Term(SPACE)
897      << "----------------+-------------+-------------+-------------\n"
898      << "          Total | " << Term(TOTAL);
899
900   ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
901
902   return ss.str();
903 }