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