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