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