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