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