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