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