2 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3 Copyright (C) 2004-2020 The Stockfish developers (see AUTHORS file)
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.
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.
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/>.
22 #include <cstring> // For std::memset
38 std::string eval_file_loaded="None";
42 useNNUE = Options["Use NNUE"];
43 std::string eval_file = std::string(Options["EvalFile"]);
44 if (useNNUE && eval_file_loaded != eval_file)
45 if (Eval::NNUE::load_eval_file(eval_file))
46 eval_file_loaded = eval_file;
51 std::string eval_file = std::string(Options["EvalFile"]);
52 if (useNNUE && eval_file_loaded != eval_file)
54 UCI::OptionsMap defaults;
57 std::cerr << "NNUE evaluation used, but the network file " << eval_file << " was not loaded successfully. "
58 << "These network evaluation parameters must be available, and compatible with this version of the code. "
59 << "The UCI option EvalFile might need to specify the full path, including the directory/folder name, to the file. "
60 << "The default net can be downloaded from: https://tests.stockfishchess.org/api/nn/"+std::string(defaults["EvalFile"]) << std::endl;
61 std::exit(EXIT_FAILURE);
64 if (Cluster::is_root())
67 sync_cout << "info string NNUE evaluation using " << eval_file << " enabled." << sync_endl;
69 sync_cout << "info string classical evaluation enabled." << sync_endl;
76 enum Tracing { NO_TRACE, TRACE };
78 enum Term { // The first 8 entries are reserved for PieceType
79 MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, WINNABLE, TOTAL, TERM_NB
82 Score scores[TERM_NB][COLOR_NB];
84 double to_cp(Value v) { return double(v) / PawnValueEg; }
86 void add(int idx, Color c, Score s) {
90 void add(int idx, Score w, Score b = SCORE_ZERO) {
91 scores[idx][WHITE] = w;
92 scores[idx][BLACK] = b;
95 std::ostream& operator<<(std::ostream& os, Score s) {
96 os << std::setw(5) << to_cp(mg_value(s)) << " "
97 << std::setw(5) << to_cp(eg_value(s));
101 std::ostream& operator<<(std::ostream& os, Term t) {
103 if (t == MATERIAL || t == IMBALANCE || t == WINNABLE || t == TOTAL)
104 os << " ---- ----" << " | " << " ---- ----";
106 os << scores[t][WHITE] << " | " << scores[t][BLACK];
108 os << " | " << scores[t][WHITE] - scores[t][BLACK] << "\n";
113 using namespace Trace;
117 // Threshold for lazy and space evaluation
118 constexpr Value LazyThreshold1 = Value(1400);
119 constexpr Value LazyThreshold2 = Value(1300);
120 constexpr Value SpaceThreshold = Value(12222);
121 constexpr Value NNUEThreshold1 = Value(550);
122 constexpr Value NNUEThreshold2 = Value(150);
124 // KingAttackWeights[PieceType] contains king attack weights by piece type
125 constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 81, 52, 44, 10 };
127 // SafeCheck[PieceType][single/multiple] contains safe check bonus by piece type,
128 // higher if multiple safe checks are possible for that piece type.
129 constexpr int SafeCheck[][2] = {
130 {}, {}, {792, 1283}, {645, 967}, {1084, 1897}, {772, 1119}
133 #define S(mg, eg) make_score(mg, eg)
135 // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
136 // indexed by piece type and number of attacked squares in the mobility area.
137 constexpr Score MobilityBonus[][32] = {
138 { S(-62,-81), S(-53,-56), S(-12,-31), S( -4,-16), S( 3, 5), S( 13, 11), // Knight
139 S( 22, 17), S( 28, 20), S( 33, 25) },
140 { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishop
141 S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
142 S( 91, 88), S( 98, 97) },
143 { S(-60,-78), S(-20,-17), S( 2, 23), S( 3, 39), S( 3, 70), S( 11, 99), // Rook
144 S( 22,103), S( 31,121), S( 40,134), S( 40,139), S( 41,158), S( 48,164),
145 S( 57,168), S( 57,169), S( 62,172) },
146 { S(-30,-48), S(-12,-30), S( -8, -7), S( -9, 19), S( 20, 40), S( 23, 55), // Queen
147 S( 23, 59), S( 35, 75), S( 38, 78), S( 53, 96), S( 64, 96), S( 65,100),
148 S( 65,121), S( 66,127), S( 67,131), S( 67,133), S( 72,136), S( 72,141),
149 S( 77,147), S( 79,150), S( 93,151), S(108,168), S(108,168), S(108,171),
150 S(110,182), S(114,182), S(114,192), S(116,219) }
153 // KingProtector[knight/bishop] contains penalty for each distance unit to own king
154 constexpr Score KingProtector[] = { S(8, 9), S(6, 9) };
156 // Outpost[knight/bishop] contains bonuses for each knight or bishop occupying a
157 // pawn protected square on rank 4 to 6 which is also safe from a pawn attack.
158 constexpr Score Outpost[] = { S(56, 36), S(30, 23) };
160 // PassedRank[Rank] contains a bonus according to the rank of a passed pawn
161 constexpr Score PassedRank[RANK_NB] = {
162 S(0, 0), S(10, 28), S(17, 33), S(15, 41), S(62, 72), S(168, 177), S(276, 260)
165 // RookOnFile[semiopen/open] contains bonuses for each rook when there is
166 // no (friendly) pawn on the rook file.
167 constexpr Score RookOnFile[] = { S(19, 7), S(48, 29) };
169 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
170 // which piece type attacks which one. Attacks on lesser pieces which are
171 // pawn-defended are not considered.
172 constexpr Score ThreatByMinor[PIECE_TYPE_NB] = {
173 S(0, 0), S(5, 32), S(57, 41), S(77, 56), S(88, 119), S(79, 161)
176 constexpr Score ThreatByRook[PIECE_TYPE_NB] = {
177 S(0, 0), S(3, 46), S(37, 68), S(42, 60), S(0, 38), S(58, 41)
180 // Assorted bonuses and penalties
181 constexpr Score BadOutpost = S( -7, 36);
182 constexpr Score BishopOnKingRing = S( 24, 0);
183 constexpr Score BishopPawns = S( 3, 7);
184 constexpr Score BishopXRayPawns = S( 4, 5);
185 constexpr Score CorneredBishop = S( 50, 50);
186 constexpr Score FlankAttacks = S( 8, 0);
187 constexpr Score Hanging = S( 69, 36);
188 constexpr Score KnightOnQueen = S( 16, 11);
189 constexpr Score LongDiagonalBishop = S( 45, 0);
190 constexpr Score MinorBehindPawn = S( 18, 3);
191 constexpr Score PassedFile = S( 11, 8);
192 constexpr Score PawnlessFlank = S( 17, 95);
193 constexpr Score ReachableOutpost = S( 31, 22);
194 constexpr Score RestrictedPiece = S( 7, 7);
195 constexpr Score RookOnKingRing = S( 16, 0);
196 constexpr Score RookOnQueenFile = S( 6, 11);
197 constexpr Score SliderOnQueen = S( 60, 18);
198 constexpr Score ThreatByKing = S( 24, 89);
199 constexpr Score ThreatByPawnPush = S( 48, 39);
200 constexpr Score ThreatBySafePawn = S(173, 94);
201 constexpr Score TrappedRook = S( 55, 13);
202 constexpr Score WeakQueenProtection = S( 14, 0);
203 constexpr Score WeakQueen = S( 56, 15);
208 // Evaluation class computes and stores attacks tables and other working data
213 Evaluation() = delete;
214 explicit Evaluation(const Position& p) : pos(p) {}
215 Evaluation& operator=(const Evaluation&) = delete;
219 template<Color Us> void initialize();
220 template<Color Us, PieceType Pt> Score pieces();
221 template<Color Us> Score king() const;
222 template<Color Us> Score threats() const;
223 template<Color Us> Score passed() const;
224 template<Color Us> Score space() const;
225 Value winnable(Score score) const;
230 Bitboard mobilityArea[COLOR_NB];
231 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
233 // attackedBy[color][piece type] is a bitboard representing all squares
234 // attacked by a given color and piece type. Special "piece types" which
235 // is also calculated is ALL_PIECES.
236 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
238 // attackedBy2[color] are the squares attacked by at least 2 units of a given
239 // color, including x-rays. But diagonal x-rays through pawns are not computed.
240 Bitboard attackedBy2[COLOR_NB];
242 // kingRing[color] are the squares adjacent to the king plus some other
243 // very near squares, depending on king position.
244 Bitboard kingRing[COLOR_NB];
246 // kingAttackersCount[color] is the number of pieces of the given color
247 // which attack a square in the kingRing of the enemy king.
248 int kingAttackersCount[COLOR_NB];
250 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
251 // the given color which attack a square in the kingRing of the enemy king.
252 // The weights of the individual piece types are given by the elements in
253 // the KingAttackWeights array.
254 int kingAttackersWeight[COLOR_NB];
256 // kingAttacksCount[color] is the number of attacks by the given color to
257 // squares directly adjacent to the enemy king. Pieces which attack more
258 // than one square are counted multiple times. For instance, if there is
259 // a white knight on g5 and black's king is on g8, this white knight adds 2
260 // to kingAttacksCount[WHITE].
261 int kingAttacksCount[COLOR_NB];
265 // Evaluation::initialize() computes king and pawn attacks, and the king ring
266 // bitboard for a given color. This is done at the beginning of the evaluation.
268 template<Tracing T> template<Color Us>
269 void Evaluation<T>::initialize() {
271 constexpr Color Them = ~Us;
272 constexpr Direction Up = pawn_push(Us);
273 constexpr Direction Down = -Up;
274 constexpr Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB : Rank7BB | Rank6BB);
276 const Square ksq = pos.square<KING>(Us);
278 Bitboard dblAttackByPawn = pawn_double_attacks_bb<Us>(pos.pieces(Us, PAWN));
280 // Find our pawns that are blocked or on the first two ranks
281 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
283 // Squares occupied by those pawns, by our king or queen, by blockers to attacks on our king
284 // or controlled by enemy pawns are excluded from the mobility area.
285 mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | pe->pawn_attacks(Them));
287 // Initialize attackedBy[] for king and pawns
288 attackedBy[Us][KING] = attacks_bb<KING>(ksq);
289 attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
290 attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN];
291 attackedBy2[Us] = dblAttackByPawn | (attackedBy[Us][KING] & attackedBy[Us][PAWN]);
293 // Init our king safety tables
294 Square s = make_square(Utility::clamp(file_of(ksq), FILE_B, FILE_G),
295 Utility::clamp(rank_of(ksq), RANK_2, RANK_7));
296 kingRing[Us] = attacks_bb<KING>(s) | s;
298 kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
299 kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
301 // Remove from kingRing[] the squares defended by two pawns
302 kingRing[Us] &= ~dblAttackByPawn;
306 // Evaluation::pieces() scores pieces of a given color and type
308 template<Tracing T> template<Color Us, PieceType Pt>
309 Score Evaluation<T>::pieces() {
311 constexpr Color Them = ~Us;
312 constexpr Direction Down = -pawn_push(Us);
313 constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
314 : Rank5BB | Rank4BB | Rank3BB);
315 const Square* pl = pos.squares<Pt>(Us);
318 Score score = SCORE_ZERO;
320 attackedBy[Us][Pt] = 0;
322 for (Square s = *pl; s != SQ_NONE; s = *++pl)
324 // Find attacked squares, including x-ray attacks for bishops and rooks
325 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
326 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
327 : attacks_bb<Pt>(s, pos.pieces());
329 if (pos.blockers_for_king(Us) & s)
330 b &= line_bb(pos.square<KING>(Us), s);
332 attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
333 attackedBy[Us][Pt] |= b;
334 attackedBy[Us][ALL_PIECES] |= b;
336 if (b & kingRing[Them])
338 kingAttackersCount[Us]++;
339 kingAttackersWeight[Us] += KingAttackWeights[Pt];
340 kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
343 else if (Pt == ROOK && (file_bb(s) & kingRing[Them]))
344 score += RookOnKingRing;
346 else if (Pt == BISHOP && (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & kingRing[Them]))
347 score += BishopOnKingRing;
349 int mob = popcount(b & mobilityArea[Us]);
351 mobility[Us] += MobilityBonus[Pt - 2][mob];
353 if (Pt == BISHOP || Pt == KNIGHT)
355 // Bonus if the piece is on an outpost square or can reach one
356 // Reduced bonus for knights (BadOutpost) if few relevant targets
357 bb = OutpostRanks & (attackedBy[Us][PAWN] | shift<Down>(pos.pieces(PAWN)))
358 & ~pe->pawn_attacks_span(Them);
359 Bitboard targets = pos.pieces(Them) & ~pos.pieces(PAWN);
362 && bb & s & ~CenterFiles // on a side outpost
363 && !(b & targets) // no relevant attacks
364 && (!more_than_one(targets & (s & QueenSide ? QueenSide : KingSide))))
367 score += Outpost[Pt == BISHOP];
368 else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us))
369 score += ReachableOutpost;
371 // Bonus for a knight or bishop shielded by pawn
372 if (shift<Down>(pos.pieces(PAWN)) & s)
373 score += MinorBehindPawn;
375 // Penalty if the piece is far from the king
376 score -= KingProtector[Pt == BISHOP] * distance(pos.square<KING>(Us), s);
380 // Penalty according to the number of our pawns on the same color square as the
381 // bishop, bigger when the center files are blocked with pawns and smaller
382 // when the bishop is outside the pawn chain.
383 Bitboard blocked = pos.pieces(Us, PAWN) & shift<Down>(pos.pieces());
385 score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s)
386 * (!(attackedBy[Us][PAWN] & s) + popcount(blocked & CenterFiles));
388 // Penalty for all enemy pawns x-rayed
389 score -= BishopXRayPawns * popcount(attacks_bb<BISHOP>(s) & pos.pieces(Them, PAWN));
391 // Bonus for bishop on a long diagonal which can "see" both center squares
392 if (more_than_one(attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & Center))
393 score += LongDiagonalBishop;
395 // An important Chess960 pattern: a cornered bishop blocked by a friendly
396 // pawn diagonally in front of it is a very serious problem, especially
397 // when that pawn is also blocked.
398 if ( pos.is_chess960()
399 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
401 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
402 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
403 score -= !pos.empty(s + d + pawn_push(Us)) ? CorneredBishop * 4
404 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
412 // Bonus for rook on the same file as a queen
413 if (file_bb(s) & pos.pieces(QUEEN))
414 score += RookOnQueenFile;
416 // Bonus for rook on an open or semi-open file
417 if (pos.is_on_semiopen_file(Us, s))
418 score += RookOnFile[pos.is_on_semiopen_file(Them, s)];
420 // Penalty when trapped by the king, even more if the king cannot castle
423 File kf = file_of(pos.square<KING>(Us));
424 if ((kf < FILE_E) == (file_of(s) < kf))
425 score -= TrappedRook * (1 + !pos.castling_rights(Us));
431 // Penalty if any relative pin or discovered attack against the queen
432 Bitboard queenPinners;
433 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
438 Trace::add(Pt, Us, score);
444 // Evaluation::king() assigns bonuses and penalties to a king of a given color
446 template<Tracing T> template<Color Us>
447 Score Evaluation<T>::king() const {
449 constexpr Color Them = ~Us;
450 constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
451 : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
453 Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0;
454 Bitboard rookChecks, queenChecks, bishopChecks, knightChecks;
456 const Square ksq = pos.square<KING>(Us);
458 // Init the score with king shelter and enemy pawns storm
459 Score score = pe->king_safety<Us>(pos);
461 // Attacked squares defended at most once by our queen or king
462 weak = attackedBy[Them][ALL_PIECES]
464 & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
466 // Analyse the safe enemy's checks which are possible on next move
467 safe = ~pos.pieces(Them);
468 safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
470 b1 = attacks_bb<ROOK >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
471 b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
473 // Enemy rooks checks
474 rookChecks = b1 & attackedBy[Them][ROOK] & safe;
476 kingDanger += SafeCheck[ROOK][more_than_one(rookChecks)];
478 unsafeChecks |= b1 & attackedBy[Them][ROOK];
480 // Enemy queen safe checks: count them only if the checks are from squares from
481 // which opponent cannot give a rook check, because rook checks are more valuable.
482 queenChecks = (b1 | b2) & attackedBy[Them][QUEEN] & safe
483 & ~(attackedBy[Us][QUEEN] | rookChecks);
485 kingDanger += SafeCheck[QUEEN][more_than_one(queenChecks)];
487 // Enemy bishops checks: count them only if they are from squares from which
488 // opponent cannot give a queen check, because queen checks are more valuable.
489 bishopChecks = b2 & attackedBy[Them][BISHOP] & safe
492 kingDanger += SafeCheck[BISHOP][more_than_one(bishopChecks)];
495 unsafeChecks |= b2 & attackedBy[Them][BISHOP];
497 // Enemy knights checks
498 knightChecks = attacks_bb<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
499 if (knightChecks & safe)
500 kingDanger += SafeCheck[KNIGHT][more_than_one(knightChecks & safe)];
502 unsafeChecks |= knightChecks;
504 // Find the squares that opponent attacks in our king flank, the squares
505 // which they attack twice in that flank, and the squares that we defend.
506 b1 = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
507 b2 = b1 & attackedBy2[Them];
508 b3 = attackedBy[Us][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
510 int kingFlankAttack = popcount(b1) + popcount(b2);
511 int kingFlankDefense = popcount(b3);
513 kingDanger += kingAttackersCount[Them] * kingAttackersWeight[Them]
514 + 185 * popcount(kingRing[Us] & weak)
515 + 148 * popcount(unsafeChecks)
516 + 98 * popcount(pos.blockers_for_king(Us))
517 + 69 * kingAttacksCount[Them]
518 + 3 * kingFlankAttack * kingFlankAttack / 8
519 + mg_value(mobility[Them] - mobility[Us])
520 - 873 * !pos.count<QUEEN>(Them)
521 - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
522 - 6 * mg_value(score) / 8
523 - 4 * kingFlankDefense
526 // Transform the kingDanger units into a Score, and subtract it from the evaluation
527 if (kingDanger > 100)
528 score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
530 // Penalty when our king is on a pawnless flank
531 if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
532 score -= PawnlessFlank;
534 // Penalty if king flank is under attack, potentially moving toward the king
535 score -= FlankAttacks * kingFlankAttack;
538 Trace::add(KING, Us, score);
544 // Evaluation::threats() assigns bonuses according to the types of the
545 // attacking and the attacked pieces.
547 template<Tracing T> template<Color Us>
548 Score Evaluation<T>::threats() const {
550 constexpr Color Them = ~Us;
551 constexpr Direction Up = pawn_push(Us);
552 constexpr Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
554 Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
555 Score score = SCORE_ZERO;
558 nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN);
560 // Squares strongly protected by the enemy, either because they defend the
561 // square with a pawn, or because they defend the square twice and we don't.
562 stronglyProtected = attackedBy[Them][PAWN]
563 | (attackedBy2[Them] & ~attackedBy2[Us]);
565 // Non-pawn enemies, strongly protected
566 defended = nonPawnEnemies & stronglyProtected;
568 // Enemies not strongly protected and under our attack
569 weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
571 // Bonus according to the kind of attacking pieces
574 b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
576 score += ThreatByMinor[type_of(pos.piece_on(pop_lsb(&b)))];
578 b = weak & attackedBy[Us][ROOK];
580 score += ThreatByRook[type_of(pos.piece_on(pop_lsb(&b)))];
582 if (weak & attackedBy[Us][KING])
583 score += ThreatByKing;
585 b = ~attackedBy[Them][ALL_PIECES]
586 | (nonPawnEnemies & attackedBy2[Us]);
587 score += Hanging * popcount(weak & b);
589 // Additional bonus if weak piece is only protected by a queen
590 score += WeakQueenProtection * popcount(weak & attackedBy[Them][QUEEN]);
593 // Bonus for restricting their piece moves
594 b = attackedBy[Them][ALL_PIECES]
596 & attackedBy[Us][ALL_PIECES];
597 score += RestrictedPiece * popcount(b);
599 // Protected or unattacked squares
600 safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
602 // Bonus for attacking enemy pieces with our relatively safe pawns
603 b = pos.pieces(Us, PAWN) & safe;
604 b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
605 score += ThreatBySafePawn * popcount(b);
607 // Find squares where our pawns can push on the next move
608 b = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
609 b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
611 // Keep only the squares which are relatively safe
612 b &= ~attackedBy[Them][PAWN] & safe;
614 // Bonus for safe pawn threats on the next move
615 b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
616 score += ThreatByPawnPush * popcount(b);
618 // Bonus for threats on the next moves against enemy queen
619 if (pos.count<QUEEN>(Them) == 1)
621 bool queenImbalance = pos.count<QUEEN>() == 1;
623 Square s = pos.square<QUEEN>(Them);
624 safe = mobilityArea[Us]
625 & ~pos.pieces(Us, PAWN)
626 & ~stronglyProtected;
628 b = attackedBy[Us][KNIGHT] & attacks_bb<KNIGHT>(s);
630 score += KnightOnQueen * popcount(b & safe) * (1 + queenImbalance);
632 b = (attackedBy[Us][BISHOP] & attacks_bb<BISHOP>(s, pos.pieces()))
633 | (attackedBy[Us][ROOK ] & attacks_bb<ROOK >(s, pos.pieces()));
635 score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]) * (1 + queenImbalance);
639 Trace::add(THREAT, Us, score);
644 // Evaluation::passed() evaluates the passed pawns and candidate passed
645 // pawns of the given color.
647 template<Tracing T> template<Color Us>
648 Score Evaluation<T>::passed() const {
650 constexpr Color Them = ~Us;
651 constexpr Direction Up = pawn_push(Us);
652 constexpr Direction Down = -Up;
654 auto king_proximity = [&](Color c, Square s) {
655 return std::min(distance(pos.square<KING>(c), s), 5);
658 Bitboard b, bb, squaresToQueen, unsafeSquares, blockedPassers, helpers;
659 Score score = SCORE_ZERO;
661 b = pe->passed_pawns(Us);
663 blockedPassers = b & shift<Down>(pos.pieces(Them, PAWN));
666 helpers = shift<Up>(pos.pieces(Us, PAWN))
668 & (~attackedBy2[Them] | attackedBy[Us][ALL_PIECES]);
670 // Remove blocked candidate passers that don't have help to pass
672 | shift<WEST>(helpers)
673 | shift<EAST>(helpers);
678 Square s = pop_lsb(&b);
680 assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
682 int r = relative_rank(Us, s);
684 Score bonus = PassedRank[r];
689 Square blockSq = s + Up;
691 // Adjust bonus based on the king's proximity
692 bonus += make_score(0, ( (king_proximity(Them, blockSq) * 19) / 4
693 - king_proximity(Us, blockSq) * 2) * w);
695 // If blockSq is not the queening square then consider also a second push
697 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
699 // If the pawn is free to advance, then increase the bonus
700 if (pos.empty(blockSq))
702 squaresToQueen = forward_file_bb(Us, s);
703 unsafeSquares = passed_pawn_span(Us, s);
705 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
707 if (!(pos.pieces(Them) & bb))
708 unsafeSquares &= attackedBy[Them][ALL_PIECES];
710 // If there are no enemy attacks on passed pawn span, assign a big bonus.
711 // Otherwise assign a smaller bonus if the path to queen is not attacked
712 // and even smaller bonus if it is attacked but block square is not.
713 int k = !unsafeSquares ? 35 :
714 !(unsafeSquares & squaresToQueen) ? 20 :
715 !(unsafeSquares & blockSq) ? 9 :
718 // Assign a larger bonus if the block square is defended
719 if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
722 bonus += make_score(k * w, k * w);
726 score += bonus - PassedFile * edge_distance(file_of(s));
730 Trace::add(PASSED, Us, score);
736 // Evaluation::space() computes a space evaluation for a given side, aiming to improve game
737 // play in the opening. It is based on the number of safe squares on the 4 central files
738 // on ranks 2 to 4. Completely safe squares behind a friendly pawn are counted twice.
739 // Finally, the space bonus is multiplied by a weight which decreases according to occupancy.
741 template<Tracing T> template<Color Us>
742 Score Evaluation<T>::space() const {
744 // Early exit if, for example, both queens or 6 minor pieces have been exchanged
745 if (pos.non_pawn_material() < SpaceThreshold)
748 constexpr Color Them = ~Us;
749 constexpr Direction Down = -pawn_push(Us);
750 constexpr Bitboard SpaceMask =
751 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
752 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
754 // Find the available squares for our pieces inside the area defined by SpaceMask
755 Bitboard safe = SpaceMask
756 & ~pos.pieces(Us, PAWN)
757 & ~attackedBy[Them][PAWN];
759 // Find all squares which are at most three squares behind some friendly pawn
760 Bitboard behind = pos.pieces(Us, PAWN);
761 behind |= shift<Down>(behind);
762 behind |= shift<Down+Down>(behind);
764 int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
765 int weight = pos.count<ALL_PIECES>(Us) - 3 + std::min(pe->blocked_count(), 9);
766 Score score = make_score(bonus * weight * weight / 16, 0);
769 Trace::add(SPACE, Us, score);
775 // Evaluation::winnable() adjusts the midgame and endgame score components, based on
776 // the known attacking/defending status of the players. The final value is derived
777 // by interpolation from the midgame and endgame values.
780 Value Evaluation<T>::winnable(Score score) const {
782 int outflanking = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
783 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
785 bool pawnsOnBothFlanks = (pos.pieces(PAWN) & QueenSide)
786 && (pos.pieces(PAWN) & KingSide);
788 bool almostUnwinnable = outflanking < 0
789 && !pawnsOnBothFlanks;
791 bool infiltration = rank_of(pos.square<KING>(WHITE)) > RANK_4
792 || rank_of(pos.square<KING>(BLACK)) < RANK_5;
794 // Compute the initiative bonus for the attacking side
795 int complexity = 9 * pe->passed_count()
796 + 12 * pos.count<PAWN>()
798 + 21 * pawnsOnBothFlanks
800 + 51 * !pos.non_pawn_material()
801 - 43 * almostUnwinnable
804 Value mg = mg_value(score);
805 Value eg = eg_value(score);
807 // Now apply the bonus: note that we find the attacking side by extracting the
808 // sign of the midgame or endgame values, and that we carefully cap the bonus
809 // so that the midgame and endgame scores do not change sign after the bonus.
810 int u = ((mg > 0) - (mg < 0)) * Utility::clamp(complexity + 50, -abs(mg), 0);
811 int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
816 // Compute the scale factor for the winning side
817 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
818 int sf = me->scale_factor(pos, strongSide);
820 // If scale factor is not already specific, scale down via general heuristics
821 if (sf == SCALE_FACTOR_NORMAL)
823 if (pos.opposite_bishops())
825 if ( pos.non_pawn_material(WHITE) == BishopValueMg
826 && pos.non_pawn_material(BLACK) == BishopValueMg)
827 sf = 18 + 4 * popcount(pe->passed_pawns(strongSide));
829 sf = 22 + 3 * pos.count<ALL_PIECES>(strongSide);
831 else if ( pos.non_pawn_material(WHITE) == RookValueMg
832 && pos.non_pawn_material(BLACK) == RookValueMg
833 && pos.count<PAWN>(strongSide) - pos.count<PAWN>(~strongSide) <= 1
834 && bool(KingSide & pos.pieces(strongSide, PAWN)) != bool(QueenSide & pos.pieces(strongSide, PAWN))
835 && (attacks_bb<KING>(pos.square<KING>(~strongSide)) & pos.pieces(~strongSide, PAWN)))
837 else if (pos.count<QUEEN>() == 1)
838 sf = 37 + 3 * (pos.count<QUEEN>(WHITE) == 1 ? pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK)
839 : pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE));
841 sf = std::min(sf, 36 + 7 * pos.count<PAWN>(strongSide));
844 // Interpolate between the middlegame and (scaled by 'sf') endgame score
845 v = mg * int(me->game_phase())
846 + eg * int(PHASE_MIDGAME - me->game_phase()) * ScaleFactor(sf) / SCALE_FACTOR_NORMAL;
851 Trace::add(WINNABLE, make_score(u, eg * ScaleFactor(sf) / SCALE_FACTOR_NORMAL - eg_value(score)));
852 Trace::add(TOTAL, make_score(mg, eg * ScaleFactor(sf) / SCALE_FACTOR_NORMAL));
859 // Evaluation::value() is the main function of the class. It computes the various
860 // parts of the evaluation and returns the value of the position from the point
861 // of view of the side to move.
864 Value Evaluation<T>::value() {
866 assert(!pos.checkers());
868 // Probe the material hash table
869 me = Material::probe(pos);
871 // If we have a specialized evaluation function for the current material
872 // configuration, call it and return.
873 if (me->specialized_eval_exists())
874 return me->evaluate(pos);
876 // Initialize score by reading the incrementally updated scores included in
877 // the position object (material + piece square tables) and the material
878 // imbalance. Score is computed internally from the white point of view.
879 Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
881 // Probe the pawn hash table
882 pe = Pawns::probe(pos);
883 score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
885 // Early exit if score is high
886 auto lazy_skip = [&](Value lazyThreshold) {
887 return abs(mg_value(score) + eg_value(score)) / 2 > lazyThreshold + pos.non_pawn_material() / 64;
890 if (lazy_skip(LazyThreshold1))
893 // Main evaluation begins here
897 // Pieces evaluated first (also populates attackedBy, attackedBy2).
898 // Note that the order of evaluation of the terms is left unspecified.
899 score += pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
900 + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
901 + pieces<WHITE, ROOK >() - pieces<BLACK, ROOK >()
902 + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
904 score += mobility[WHITE] - mobility[BLACK];
906 // More complex interactions that require fully populated attack bitboards
907 score += king< WHITE>() - king< BLACK>()
908 + passed< WHITE>() - passed< BLACK>();
910 if (lazy_skip(LazyThreshold2))
913 score += threats<WHITE>() - threats<BLACK>()
914 + space< WHITE>() - space< BLACK>();
917 // Derive single value from mg and eg parts of score
918 Value v = winnable(score);
920 // In case of tracing add all remaining individual evaluation terms
923 Trace::add(MATERIAL, pos.psq_score());
924 Trace::add(IMBALANCE, me->imbalance());
925 Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
926 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
932 // Side to move point of view
933 v = (pos.side_to_move() == WHITE ? v : -v) + Tempo;
941 /// evaluate() is the evaluator for the outer world. It returns a static
942 /// evaluation of the position from the point of view of the side to move.
944 Value Eval::evaluate(const Position& pos) {
946 bool classical = !Eval::useNNUE
947 || abs(eg_value(pos.psq_score())) * 16 > NNUEThreshold1 * (16 + pos.rule50_count());
948 Value v = classical ? Evaluation<NO_TRACE>(pos).value()
949 : NNUE::evaluate(pos) * 5 / 4 + Tempo;
951 if (classical && Eval::useNNUE && abs(v) * 16 < NNUEThreshold2 * (16 + pos.rule50_count()))
952 v = NNUE::evaluate(pos) * 5 / 4 + Tempo;
954 // Damp down the evaluation linearly when shuffling
955 v = v * (100 - pos.rule50_count()) / 100;
957 // Guarantee evalution outside of TB range
958 v = Utility::clamp(v, VALUE_TB_LOSS_IN_MAX_PLY + 1, VALUE_TB_WIN_IN_MAX_PLY - 1);
963 /// trace() is like evaluate(), but instead of returning a value, it returns
964 /// a string (suitable for outputting to stdout) that contains the detailed
965 /// descriptions and values of each evaluation term. Useful for debugging.
966 /// Trace scores are from white's point of view
968 std::string Eval::trace(const Position& pos) {
971 return "Final evaluation: none (in check)";
973 std::stringstream ss;
974 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2);
980 v = NNUE::evaluate(pos);
984 std::memset(scores, 0, sizeof(scores));
986 pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
988 v = Evaluation<TRACE>(pos).value();
990 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
991 << " Term | White | Black | Total \n"
992 << " | MG EG | MG EG | MG EG \n"
993 << " ------------+-------------+-------------+------------\n"
994 << " Material | " << Term(MATERIAL)
995 << " Imbalance | " << Term(IMBALANCE)
996 << " Pawns | " << Term(PAWN)
997 << " Knights | " << Term(KNIGHT)
998 << " Bishops | " << Term(BISHOP)
999 << " Rooks | " << Term(ROOK)
1000 << " Queens | " << Term(QUEEN)
1001 << " Mobility | " << Term(MOBILITY)
1002 << " King safety | " << Term(KING)
1003 << " Threats | " << Term(THREAT)
1004 << " Passed | " << Term(PASSED)
1005 << " Space | " << Term(SPACE)
1006 << " Winnable | " << Term(WINNABLE)
1007 << " ------------+-------------+-------------+------------\n"
1008 << " Total | " << Term(TOTAL);
1011 v = pos.side_to_move() == WHITE ? v : -v;
1013 ss << "\nFinal evaluation: " << to_cp(v) << " (white side)\n";