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