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