2 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3 Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4 Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5 Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
7 Stockfish is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Stockfish is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include <cstring> // For std::memset
35 enum Tracing { NO_TRACE, TRACE };
37 enum Term { // The first 8 entries are reserved for PieceType
38 MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, INITIATIVE, TOTAL, TERM_NB
41 Score scores[TERM_NB][COLOR_NB];
43 double to_cp(Value v) { return double(v) / PawnValueEg; }
45 void add(int idx, Color c, Score s) {
49 void add(int idx, Score w, Score b = SCORE_ZERO) {
50 scores[idx][WHITE] = w;
51 scores[idx][BLACK] = b;
54 std::ostream& operator<<(std::ostream& os, Score s) {
55 os << std::setw(5) << to_cp(mg_value(s)) << " "
56 << std::setw(5) << to_cp(eg_value(s));
60 std::ostream& operator<<(std::ostream& os, Term t) {
62 if (t == MATERIAL || t == IMBALANCE || t == INITIATIVE || t == TOTAL)
63 os << " ---- ----" << " | " << " ---- ----";
65 os << scores[t][WHITE] << " | " << scores[t][BLACK];
67 os << " | " << scores[t][WHITE] - scores[t][BLACK] << "\n";
72 using namespace Trace;
76 // Threshold for lazy and space evaluation
77 constexpr Value LazyThreshold = Value(1400);
78 constexpr Value SpaceThreshold = Value(12222);
80 // KingAttackWeights[PieceType] contains king attack weights by piece type
81 constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 77, 55, 44, 10 };
83 // Penalties for enemy's safe checks
84 constexpr int QueenSafeCheck = 780;
85 constexpr int RookSafeCheck = 1080;
86 constexpr int BishopSafeCheck = 635;
87 constexpr int KnightSafeCheck = 790;
89 #define S(mg, eg) make_score(mg, eg)
91 // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
92 // indexed by piece type and number of attacked squares in the mobility area.
93 constexpr Score MobilityBonus[][32] = {
94 { S(-62,-81), S(-53,-56), S(-12,-30), S( -4,-14), S( 3, 8), S( 13, 15), // Knights
95 S( 22, 23), S( 28, 27), S( 33, 33) },
96 { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
97 S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
98 S( 91, 88), S( 98, 97) },
99 { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
100 S( 9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
101 S( 46,166), S( 48,169), S( 58,171) },
102 { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens
103 S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
104 S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
105 S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
106 S(106,184), S(109,191), S(113,206), S(116,212) }
109 // RookOnFile[semiopen/open] contains bonuses for each rook when there is
110 // no (friendly) pawn on the rook file.
111 constexpr Score RookOnFile[] = { S(18, 7), S(44, 20) };
113 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
114 // which piece type attacks which one. Attacks on lesser pieces which are
115 // pawn-defended are not considered.
116 constexpr Score ThreatByMinor[PIECE_TYPE_NB] = {
117 S(0, 0), S(0, 31), S(39, 42), S(57, 44), S(68, 112), S(62, 120)
120 constexpr Score ThreatByRook[PIECE_TYPE_NB] = {
121 S(0, 0), S(0, 24), S(38, 71), S(38, 61), S(0, 38), S(51, 38)
124 // PassedRank[Rank] contains a bonus according to the rank of a passed pawn
125 constexpr Score PassedRank[RANK_NB] = {
126 S(0, 0), S(10, 28), S(17, 33), S(15, 41), S(62, 72), S(168, 177), S(276, 260)
129 // Assorted bonuses and penalties
130 constexpr Score BishopPawns = S( 3, 7);
131 constexpr Score CorneredBishop = S( 50, 50);
132 constexpr Score FlankAttacks = S( 8, 0);
133 constexpr Score Hanging = S( 69, 36);
134 constexpr Score KingProtector = S( 7, 8);
135 constexpr Score KnightOnQueen = S( 16, 12);
136 constexpr Score LongDiagonalBishop = S( 45, 0);
137 constexpr Score MinorBehindPawn = S( 18, 3);
138 constexpr Score Outpost = S( 18, 6);
139 constexpr Score PassedFile = S( 11, 8);
140 constexpr Score PawnlessFlank = S( 17, 95);
141 constexpr Score RestrictedPiece = S( 7, 7);
142 constexpr Score RookOnPawn = S( 10, 32);
143 constexpr Score RookOnQueenFile = S( 11, 4);
144 constexpr Score SliderOnQueen = S( 59, 18);
145 constexpr Score ThreatByKing = S( 24, 89);
146 constexpr Score ThreatByPawnPush = S( 48, 39);
147 constexpr Score ThreatByRank = S( 13, 0);
148 constexpr Score ThreatBySafePawn = S(173, 94);
149 constexpr Score TrappedRook = S( 47, 4);
150 constexpr Score WeakQueen = S( 49, 15);
154 // Evaluation class computes and stores attacks tables and other working data
159 Evaluation() = delete;
160 explicit Evaluation(const Position& p) : pos(p) {}
161 Evaluation& operator=(const Evaluation&) = delete;
165 template<Color Us> void initialize();
166 template<Color Us, PieceType Pt> Score pieces();
167 template<Color Us> Score king() const;
168 template<Color Us> Score threats() const;
169 template<Color Us> Score passed() const;
170 template<Color Us> Score space() const;
171 ScaleFactor scale_factor(Value eg) const;
172 Score initiative(Score score) const;
177 Bitboard mobilityArea[COLOR_NB];
178 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
180 // attackedBy[color][piece type] is a bitboard representing all squares
181 // attacked by a given color and piece type. Special "piece types" which
182 // is also calculated is ALL_PIECES.
183 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
185 // attackedBy2[color] are the squares attacked by at least 2 units of a given
186 // color, including x-rays. But diagonal x-rays through pawns are not computed.
187 Bitboard attackedBy2[COLOR_NB];
189 // kingRing[color] are the squares adjacent to the king plus some other
190 // very near squares, depending on king position.
191 Bitboard kingRing[COLOR_NB];
193 // kingAttackersCount[color] is the number of pieces of the given color
194 // which attack a square in the kingRing of the enemy king.
195 int kingAttackersCount[COLOR_NB];
197 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
198 // the given color which attack a square in the kingRing of the enemy king.
199 // The weights of the individual piece types are given by the elements in
200 // the KingAttackWeights array.
201 int kingAttackersWeight[COLOR_NB];
203 // kingAttacksCount[color] is the number of attacks by the given color to
204 // squares directly adjacent to the enemy king. Pieces which attack more
205 // than one square are counted multiple times. For instance, if there is
206 // a white knight on g5 and black's king is on g8, this white knight adds 2
207 // to kingAttacksCount[WHITE].
208 int kingAttacksCount[COLOR_NB];
212 // Evaluation::initialize() computes king and pawn attacks, and the king ring
213 // bitboard for a given color. This is done at the beginning of the evaluation.
214 template<Tracing T> template<Color Us>
215 void Evaluation<T>::initialize() {
217 constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
218 constexpr Direction Up = (Us == WHITE ? NORTH : SOUTH);
219 constexpr Direction Down = (Us == WHITE ? SOUTH : NORTH);
220 constexpr Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB : Rank7BB | Rank6BB);
222 const Square ksq = pos.square<KING>(Us);
224 Bitboard dblAttackByPawn = pawn_double_attacks_bb<Us>(pos.pieces(Us, PAWN));
226 // Find our pawns that are blocked or on the first two ranks
227 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
229 // Squares occupied by those pawns, by our king or queen or controlled by
230 // enemy pawns are excluded from the mobility area.
231 mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pe->pawn_attacks(Them));
233 // Initialize attackedBy[] for king and pawns
234 attackedBy[Us][KING] = pos.attacks_from<KING>(ksq);
235 attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
236 attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN];
237 attackedBy2[Us] = dblAttackByPawn | (attackedBy[Us][KING] & attackedBy[Us][PAWN]);
239 // Init our king safety tables
240 kingRing[Us] = attackedBy[Us][KING];
241 if (relative_rank(Us, ksq) == RANK_1)
242 kingRing[Us] |= shift<Up>(kingRing[Us]);
244 if (file_of(ksq) == FILE_H)
245 kingRing[Us] |= shift<WEST>(kingRing[Us]);
247 else if (file_of(ksq) == FILE_A)
248 kingRing[Us] |= shift<EAST>(kingRing[Us]);
250 kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
251 kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
253 // Remove from kingRing[] the squares defended by two pawns
254 kingRing[Us] &= ~dblAttackByPawn;
258 // Evaluation::pieces() scores pieces of a given color and type
259 template<Tracing T> template<Color Us, PieceType Pt>
260 Score Evaluation<T>::pieces() {
262 constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
263 constexpr Direction Down = (Us == WHITE ? SOUTH : NORTH);
264 constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
265 : Rank5BB | Rank4BB | Rank3BB);
266 const Square* pl = pos.squares<Pt>(Us);
269 Score score = SCORE_ZERO;
271 attackedBy[Us][Pt] = 0;
273 for (Square s = *pl; s != SQ_NONE; s = *++pl)
275 // Find attacked squares, including x-ray attacks for bishops and rooks
276 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
277 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
278 : pos.attacks_from<Pt>(s);
280 if (pos.blockers_for_king(Us) & s)
281 b &= LineBB[pos.square<KING>(Us)][s];
283 attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
284 attackedBy[Us][Pt] |= b;
285 attackedBy[Us][ALL_PIECES] |= b;
287 if (b & kingRing[Them])
289 kingAttackersCount[Us]++;
290 kingAttackersWeight[Us] += KingAttackWeights[Pt];
291 kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
294 int mob = popcount(b & mobilityArea[Us]);
296 mobility[Us] += MobilityBonus[Pt - 2][mob];
298 if (Pt == BISHOP || Pt == KNIGHT)
300 // Bonus if piece is on an outpost square or can reach one
301 bb = OutpostRanks & attackedBy[Us][PAWN] & ~pe->pawn_attacks_span(Them);
303 score += Outpost * (Pt == KNIGHT ? 4 : 2);
305 else if (bb & b & ~pos.pieces(Us))
306 score += Outpost * (Pt == KNIGHT ? 2 : 1);
308 // Knight and Bishop bonus for being right behind a pawn
309 if (shift<Down>(pos.pieces(PAWN)) & s)
310 score += MinorBehindPawn;
312 // Penalty if the piece is far from the king
313 score -= KingProtector * distance(s, pos.square<KING>(Us));
317 // Penalty according to number of pawns on the same color square as the
318 // bishop, bigger when the center files are blocked with pawns.
319 Bitboard blocked = pos.pieces(Us, PAWN) & shift<Down>(pos.pieces());
321 score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s)
322 * (1 + popcount(blocked & CenterFiles));
324 // Bonus for bishop on a long diagonal which can "see" both center squares
325 if (more_than_one(attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & Center))
326 score += LongDiagonalBishop;
329 // An important Chess960 pattern: A cornered bishop blocked by a friendly
330 // pawn diagonally in front of it is a very serious problem, especially
331 // when that pawn is also blocked.
334 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
336 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
337 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
338 score -= !pos.empty(s + d + pawn_push(Us)) ? CorneredBishop * 4
339 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
346 // Bonus for aligning rook with enemy pawns on the same rank/file
347 if (relative_rank(Us, s) >= RANK_5)
348 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
350 // Bonus for rook on the same file as a queen
351 if (file_bb(s) & pos.pieces(QUEEN))
352 score += RookOnQueenFile;
354 // Bonus for rook on an open or semi-open file
355 if (pos.is_on_semiopen_file(Us, s))
356 score += RookOnFile[pos.is_on_semiopen_file(Them, s)];
358 // Penalty when trapped by the king, even more if the king cannot castle
361 File kf = file_of(pos.square<KING>(Us));
362 if ((kf < FILE_E) == (file_of(s) < kf))
363 score -= TrappedRook * (1 + !pos.castling_rights(Us));
369 // Penalty if any relative pin or discovered attack against the queen
370 Bitboard queenPinners;
371 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
376 Trace::add(Pt, Us, score);
382 // Evaluation::king() assigns bonuses and penalties to a king of a given color
383 template<Tracing T> template<Color Us>
384 Score Evaluation<T>::king() const {
386 constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
387 constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
388 : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
390 Bitboard weak, b1, b2, safe, unsafeChecks = 0;
391 Bitboard rookChecks, queenChecks, bishopChecks, knightChecks;
393 const Square ksq = pos.square<KING>(Us);
395 // Init the score with king shelter and enemy pawns storm
396 Score score = pe->king_safety<Us>(pos);
398 // Attacked squares defended at most once by our queen or king
399 weak = attackedBy[Them][ALL_PIECES]
401 & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
403 // Analyse the safe enemy's checks which are possible on next move
404 safe = ~pos.pieces(Them);
405 safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
407 b1 = attacks_bb<ROOK >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
408 b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
410 // Enemy rooks checks
411 rookChecks = b1 & safe & attackedBy[Them][ROOK];
414 kingDanger += RookSafeCheck;
416 unsafeChecks |= b1 & attackedBy[Them][ROOK];
418 // Enemy queen safe checks: we count them only if they are from squares from
419 // which we can't give a rook check, because rook checks are more valuable.
420 queenChecks = (b1 | b2)
421 & attackedBy[Them][QUEEN]
423 & ~attackedBy[Us][QUEEN]
427 kingDanger += QueenSafeCheck;
429 // Enemy bishops checks: we count them only if they are from squares from
430 // which we can't give a queen check, because queen checks are more valuable.
432 & attackedBy[Them][BISHOP]
437 kingDanger += BishopSafeCheck;
439 unsafeChecks |= b2 & attackedBy[Them][BISHOP];
441 // Enemy knights checks
442 knightChecks = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
444 if (knightChecks & safe)
445 kingDanger += KnightSafeCheck;
447 unsafeChecks |= knightChecks;
449 // Find the squares that opponent attacks in our king flank, and the squares
450 // which are attacked twice in that flank.
451 b1 = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
452 b2 = b1 & attackedBy2[Them];
454 int kingFlankAttacks = popcount(b1) + popcount(b2);
456 kingDanger += kingAttackersCount[Them] * kingAttackersWeight[Them]
457 + 69 * kingAttacksCount[Them]
458 + 185 * popcount(kingRing[Us] & weak)
459 - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
460 - 35 * bool(attackedBy[Us][BISHOP] & attackedBy[Us][KING])
461 + 148 * popcount(unsafeChecks)
462 + 98 * popcount(pos.blockers_for_king(Us))
463 - 873 * !pos.count<QUEEN>(Them)
464 - 6 * mg_value(score) / 8
465 + mg_value(mobility[Them] - mobility[Us])
466 + 5 * kingFlankAttacks * kingFlankAttacks / 16
469 // Transform the kingDanger units into a Score, and subtract it from the evaluation
470 if (kingDanger > 100)
471 score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
473 // Penalty when our king is on a pawnless flank
474 if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
475 score -= PawnlessFlank;
477 // Penalty if king flank is under attack, potentially moving toward the king
478 score -= FlankAttacks * kingFlankAttacks;
481 Trace::add(KING, Us, score);
487 // Evaluation::threats() assigns bonuses according to the types of the
488 // attacking and the attacked pieces.
489 template<Tracing T> template<Color Us>
490 Score Evaluation<T>::threats() const {
492 constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
493 constexpr Direction Up = (Us == WHITE ? NORTH : SOUTH);
494 constexpr Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
496 Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
497 Score score = SCORE_ZERO;
500 nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN);
502 // Squares strongly protected by the enemy, either because they defend the
503 // square with a pawn, or because they defend the square twice and we don't.
504 stronglyProtected = attackedBy[Them][PAWN]
505 | (attackedBy2[Them] & ~attackedBy2[Us]);
507 // Non-pawn enemies, strongly protected
508 defended = nonPawnEnemies & stronglyProtected;
510 // Enemies not strongly protected and under our attack
511 weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
513 // Bonus according to the kind of attacking pieces
516 b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
519 Square s = pop_lsb(&b);
520 score += ThreatByMinor[type_of(pos.piece_on(s))];
521 if (type_of(pos.piece_on(s)) != PAWN)
522 score += ThreatByRank * (int)relative_rank(Them, s);
525 b = weak & attackedBy[Us][ROOK];
528 Square s = pop_lsb(&b);
529 score += ThreatByRook[type_of(pos.piece_on(s))];
530 if (type_of(pos.piece_on(s)) != PAWN)
531 score += ThreatByRank * (int)relative_rank(Them, s);
534 if (weak & attackedBy[Us][KING])
535 score += ThreatByKing;
537 b = ~attackedBy[Them][ALL_PIECES]
538 | (nonPawnEnemies & attackedBy2[Us]);
539 score += Hanging * popcount(weak & b);
542 // Bonus for restricting their piece moves
543 b = attackedBy[Them][ALL_PIECES]
545 & attackedBy[Us][ALL_PIECES];
547 score += RestrictedPiece * popcount(b);
549 // Protected or unattacked squares
550 safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
552 // Bonus for attacking enemy pieces with our relatively safe pawns
553 b = pos.pieces(Us, PAWN) & safe;
554 b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
555 score += ThreatBySafePawn * popcount(b);
557 // Find squares where our pawns can push on the next move
558 b = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
559 b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
561 // Keep only the squares which are relatively safe
562 b &= ~attackedBy[Them][PAWN] & safe;
564 // Bonus for safe pawn threats on the next move
565 b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
566 score += ThreatByPawnPush * popcount(b);
568 // Bonus for threats on the next moves against enemy queen
569 if (pos.count<QUEEN>(Them) == 1)
571 Square s = pos.square<QUEEN>(Them);
572 safe = mobilityArea[Us] & ~stronglyProtected;
574 b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
576 score += KnightOnQueen * popcount(b & safe);
578 b = (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
579 | (attackedBy[Us][ROOK ] & pos.attacks_from<ROOK >(s));
581 score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]);
585 Trace::add(THREAT, Us, score);
590 // Evaluation::passed() evaluates the passed pawns and candidate passed
591 // pawns of the given color.
593 template<Tracing T> template<Color Us>
594 Score Evaluation<T>::passed() const {
596 constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
597 constexpr Direction Up = (Us == WHITE ? NORTH : SOUTH);
599 auto king_proximity = [&](Color c, Square s) {
600 return std::min(distance(pos.square<KING>(c), s), 5);
603 Bitboard b, bb, squaresToQueen, unsafeSquares;
604 Score score = SCORE_ZERO;
606 b = pe->passed_pawns(Us);
610 Square s = pop_lsb(&b);
612 assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
614 int r = relative_rank(Us, s);
617 Score bonus = PassedRank[r];
622 Square blockSq = s + Up;
624 // Adjust bonus based on the king's proximity
625 bonus += make_score(0, ( king_proximity(Them, blockSq) * 5
626 - king_proximity(Us, blockSq) * 2) * w);
628 // If blockSq is not the queening square then consider also a second push
630 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
632 // If the pawn is free to advance, then increase the bonus
633 if (pos.empty(blockSq))
635 squaresToQueen = forward_file_bb(Us, s);
636 unsafeSquares = passed_pawn_span(Us, s);
638 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
640 if (!(pos.pieces(Them) & bb))
641 unsafeSquares &= attackedBy[Them][ALL_PIECES];
643 // If there are no enemy attacks on passed pawn span, assign a big bonus.
644 // Otherwise assign a smaller bonus if the path to queen is not attacked
645 // and even smaller bonus if it is attacked but block square is not.
646 int k = !unsafeSquares ? 35 :
647 !(unsafeSquares & squaresToQueen) ? 20 :
648 !(unsafeSquares & blockSq) ? 9 :
651 // Assign a larger bonus if the block square is defended
652 if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
655 bonus += make_score(k * w, k * w);
659 // Scale down bonus for candidate passers which need more than one
660 // pawn push to become passed, or have a pawn in front of them.
661 if ( !pos.pawn_passed(Us, s + Up)
662 || (pos.pieces(PAWN) & (s + Up)))
665 score += bonus - PassedFile * map_to_queenside(f);
669 Trace::add(PASSED, Us, score);
675 // Evaluation::space() computes the space evaluation for a given side. The
676 // space evaluation is a simple bonus based on the number of safe squares
677 // available for minor pieces on the central four files on ranks 2--4. Safe
678 // squares one, two or three squares behind a friendly pawn are counted
679 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
680 // improve play on game opening.
682 template<Tracing T> template<Color Us>
683 Score Evaluation<T>::space() const {
685 if (pos.non_pawn_material() < SpaceThreshold)
688 constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
689 constexpr Direction Down = (Us == WHITE ? SOUTH : NORTH);
690 constexpr Bitboard SpaceMask =
691 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
692 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
694 // Find the available squares for our pieces inside the area defined by SpaceMask
695 Bitboard safe = SpaceMask
696 & ~pos.pieces(Us, PAWN)
697 & ~attackedBy[Them][PAWN];
699 // Find all squares which are at most three squares behind some friendly pawn
700 Bitboard behind = pos.pieces(Us, PAWN);
701 behind |= shift<Down>(behind);
702 behind |= shift<Down+Down>(behind);
704 int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
705 int weight = pos.count<ALL_PIECES>(Us) - 1;
706 Score score = make_score(bonus * weight * weight / 16, 0);
709 Trace::add(SPACE, Us, score);
715 // Evaluation::initiative() computes the initiative correction value
716 // for the position. It is a second order bonus/malus based on the
717 // known attacking/defending status of the players.
720 Score Evaluation<T>::initiative(Score score) const {
722 Value mg = mg_value(score);
723 Value eg = eg_value(score);
725 int outflanking = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
726 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
728 bool pawnsOnBothFlanks = (pos.pieces(PAWN) & QueenSide)
729 && (pos.pieces(PAWN) & KingSide);
731 bool almostUnwinnable = !pe->passed_count()
733 && !pawnsOnBothFlanks;
735 // Compute the initiative bonus for the attacking side
736 int complexity = 9 * pe->passed_count()
737 + 11 * pos.count<PAWN>()
739 + 18 * pawnsOnBothFlanks
740 + 49 * !pos.non_pawn_material()
741 - 36 * almostUnwinnable
744 // Now apply the bonus: note that we find the attacking side by extracting the
745 // sign of the midgame or endgame values, and that we carefully cap the bonus
746 // so that the midgame and endgame scores do not change sign after the bonus.
747 int u = ((mg > 0) - (mg < 0)) * std::max(std::min(complexity + 50, 0), -abs(mg));
748 int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
751 Trace::add(INITIATIVE, make_score(u, v));
753 return make_score(u, v);
757 // Evaluation::scale_factor() computes the scale factor for the winning side
760 ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
762 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
763 int sf = me->scale_factor(pos, strongSide);
765 // If scale is not already specific, scale down the endgame via general heuristics
766 if (sf == SCALE_FACTOR_NORMAL)
768 if ( pos.opposite_bishops()
769 && pos.non_pawn_material() == 2 * BishopValueMg)
770 sf = 16 + 4 * pe->passed_count();
772 sf = std::min(sf, 36 + (pos.opposite_bishops() ? 2 : 7) * pos.count<PAWN>(strongSide));
774 sf = std::max(0, sf - (pos.rule50_count() - 12) / 4 );
777 return ScaleFactor(sf);
781 // Evaluation::value() is the main function of the class. It computes the various
782 // parts of the evaluation and returns the value of the position from the point
783 // of view of the side to move.
786 Value Evaluation<T>::value() {
788 assert(!pos.checkers());
790 // Probe the material hash table
791 me = Material::probe(pos);
793 // If we have a specialized evaluation function for the current material
794 // configuration, call it and return.
795 if (me->specialized_eval_exists())
796 return me->evaluate(pos);
798 // Initialize score by reading the incrementally updated scores included in
799 // the position object (material + piece square tables) and the material
800 // imbalance. Score is computed internally from the white point of view.
801 Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
803 // Probe the pawn hash table
804 pe = Pawns::probe(pos);
805 score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
807 // Early exit if score is high
808 Value v = (mg_value(score) + eg_value(score)) / 2;
809 if (abs(v) > LazyThreshold + pos.non_pawn_material() / 64)
810 return pos.side_to_move() == WHITE ? v : -v;
812 // Main evaluation begins here
817 // Pieces should be evaluated first (populate attack tables)
818 score += pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
819 + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
820 + pieces<WHITE, ROOK >() - pieces<BLACK, ROOK >()
821 + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
823 score += mobility[WHITE] - mobility[BLACK];
825 score += king< WHITE>() - king< BLACK>()
826 + threats<WHITE>() - threats<BLACK>()
827 + passed< WHITE>() - passed< BLACK>()
828 + space< WHITE>() - space< BLACK>();
830 score += initiative(score);
832 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
833 ScaleFactor sf = scale_factor(eg_value(score));
834 v = mg_value(score) * int(me->game_phase())
835 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
839 // In case of tracing add all remaining individual evaluation terms
842 Trace::add(MATERIAL, pos.psq_score());
843 Trace::add(IMBALANCE, me->imbalance());
844 Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
845 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
846 Trace::add(TOTAL, score);
849 return (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view
856 /// evaluate() is the evaluator for the outer world. It returns a static
857 /// evaluation of the position from the point of view of the side to move.
859 Value Eval::evaluate(const Position& pos) {
860 return Evaluation<NO_TRACE>(pos).value();
864 /// trace() is like evaluate(), but instead of returning a value, it returns
865 /// a string (suitable for outputting to stdout) that contains the detailed
866 /// descriptions and values of each evaluation term. Useful for debugging.
868 std::string Eval::trace(const Position& pos) {
870 std::memset(scores, 0, sizeof(scores));
872 pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
874 Value v = Evaluation<TRACE>(pos).value();
876 v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
878 std::stringstream ss;
879 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
880 << " Term | White | Black | Total \n"
881 << " | MG EG | MG EG | MG EG \n"
882 << " ------------+-------------+-------------+------------\n"
883 << " Material | " << Term(MATERIAL)
884 << " Imbalance | " << Term(IMBALANCE)
885 << " Pawns | " << Term(PAWN)
886 << " Knights | " << Term(KNIGHT)
887 << " Bishops | " << Term(BISHOP)
888 << " Rooks | " << Term(ROOK)
889 << " Queens | " << Term(QUEEN)
890 << " Mobility | " << Term(MOBILITY)
891 << " King safety | " << Term(KING)
892 << " Threats | " << Term(THREAT)
893 << " Passed | " << Term(PASSED)
894 << " Space | " << Term(SPACE)
895 << " Initiative | " << Term(INITIATIVE)
896 << " ------------+-------------+-------------+------------\n"
897 << " Total | " << Term(TOTAL);
899 ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";