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