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