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-2017 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
34 const Bitboard Center = (FileDBB | FileEBB) & (Rank4BB | Rank5BB);
35 const Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
36 const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
37 const Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
39 const Bitboard KingFlank[FILE_NB] = {
40 QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide
45 enum Tracing {NO_TRACE, TRACE};
47 enum Term { // The first 8 entries are for PieceType
48 MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, INITIATIVE, TOTAL, TERM_NB
51 double scores[TERM_NB][COLOR_NB][PHASE_NB];
53 double to_cp(Value v) { return double(v) / PawnValueEg; }
55 void add(int idx, Color c, Score s) {
56 scores[idx][c][MG] = to_cp(mg_value(s));
57 scores[idx][c][EG] = to_cp(eg_value(s));
60 void add(int idx, Score w, Score b = SCORE_ZERO) {
61 add(idx, WHITE, w); add(idx, BLACK, b);
64 std::ostream& operator<<(std::ostream& os, Term t) {
66 if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == INITIATIVE || t == TOTAL)
67 os << " --- --- | --- --- | ";
69 os << std::setw(5) << scores[t][WHITE][MG] << " "
70 << std::setw(5) << scores[t][WHITE][EG] << " | "
71 << std::setw(5) << scores[t][BLACK][MG] << " "
72 << std::setw(5) << scores[t][BLACK][EG] << " | ";
74 os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
75 << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
81 using namespace Trace;
83 // Evaluation class contains various information computed and collected
84 // by the evaluation functions.
85 template<Tracing T = NO_TRACE>
89 Evaluation() = delete;
90 Evaluation(const Position& p) : pos(p) {}
91 Evaluation& operator=(const Evaluation&) = delete;
96 // Evaluation helpers (used when calling value())
97 template<Color Us> void initialize();
98 template<Color Us> Score evaluate_king();
99 template<Color Us> Score evaluate_threats();
100 template<Color Us> Score evaluate_passed_pawns();
101 template<Color Us> Score evaluate_space();
102 template<Color Us, PieceType Pt> Score evaluate_pieces();
103 ScaleFactor evaluate_scale_factor(Value eg);
104 Score evaluate_initiative(Value eg);
110 Bitboard mobilityArea[COLOR_NB];
111 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
113 // attackedBy[color][piece type] is a bitboard representing all squares
114 // attacked by a given color and piece type (can be also ALL_PIECES).
115 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
117 // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
118 // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
119 // pawn or squares attacked by 2 pawns are not explicitly added.
120 Bitboard attackedBy2[COLOR_NB];
122 // kingRing[color] is the zone around the king which is considered
123 // by the king safety evaluation. This consists of the squares directly
124 // adjacent to the king, and (only for a king on its first rank) the
125 // squares two ranks in front of the king. For instance, if black's king
126 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
127 // f7, g7, h7, f6, g6 and h6.
128 Bitboard kingRing[COLOR_NB];
130 // kingAttackersCount[color] is the number of pieces of the given color
131 // which attack a square in the kingRing of the enemy king.
132 int kingAttackersCount[COLOR_NB];
134 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
135 // given color which attack a square in the kingRing of the enemy king. The
136 // weights of the individual piece types are given by the elements in the
137 // KingAttackWeights array.
138 int kingAttackersWeight[COLOR_NB];
140 // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
141 // color to squares directly adjacent to the enemy king. Pieces which attack
142 // more than one square are counted multiple times. For instance, if there is
143 // a white knight on g5 and black's king is on g8, this white knight adds 2
144 // to kingAdjacentZoneAttacksCount[WHITE].
145 int kingAdjacentZoneAttacksCount[COLOR_NB];
148 #define V(v) Value(v)
149 #define S(mg, eg) make_score(mg, eg)
151 // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
152 // indexed by piece type and number of attacked squares in the mobility area.
153 const Score MobilityBonus[][32] = {
154 { S(-75,-76), S(-57,-54), S( -9,-28), S( -2,-10), S( 6, 5), S( 14, 12), // Knights
155 S( 22, 26), S( 29, 29), S( 36, 29) },
156 { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
157 S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
158 S( 91, 88), S( 98, 97) },
159 { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
160 S( 9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
161 S( 46,166), S( 48,169), S( 58,171) },
162 { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens
163 S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
164 S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
165 S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
166 S(106,184), S(109,191), S(113,206), S(116,212) }
169 // Outpost[knight/bishop][supported by pawn] contains bonuses for minor
170 // pieces if they can reach an outpost square, bigger if that square is
171 // supported by a pawn. If the minor piece occupies an outpost square
172 // then score is doubled.
173 const Score Outpost[][2] = {
174 { S(22, 6), S(36,12) }, // Knight
175 { S( 9, 2), S(15, 5) } // Bishop
178 // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
179 // friendly pawn on the rook file.
180 const Score RookOnFile[] = { S(20, 7), S(45, 20) };
182 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
183 // which piece type attacks which one. Attacks on lesser pieces which are
184 // pawn-defended are not considered.
185 const Score ThreatByMinor[PIECE_TYPE_NB] = {
186 S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
189 const Score ThreatByRook[PIECE_TYPE_NB] = {
190 S(0, 0), S(0, 25), S(40, 62), S(40, 59), S(0, 34), S(35, 48)
193 // ThreatByKing[on one/on many] contains bonuses for king attacks on
194 // pawns or pieces which are not pawn-defended.
195 const Score ThreatByKing[] = { S(3, 62), S(9, 138) };
197 // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
198 // We don't use a Score because we process the two components independently.
199 const Value Passed[][RANK_NB] = {
200 { V(5), V( 5), V(31), V(73), V(166), V(252) },
201 { V(7), V(14), V(38), V(73), V(166), V(252) }
204 // PassedFile[File] contains a bonus according to the file of a passed pawn
205 const Score PassedFile[FILE_NB] = {
206 S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
207 S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
210 // KingProtector[PieceType-2] contains a bonus according to distance from king
211 const Score KingProtector[] = { S(-3, -5), S(-4, -3), S(-3, 0), S(-1, 1) };
213 // Assorted bonuses and penalties used by evaluation
214 const Score MinorBehindPawn = S( 16, 0);
215 const Score BishopPawns = S( 8, 12);
216 const Score LongRangedBishop = S( 22, 0);
217 const Score RookOnPawn = S( 8, 24);
218 const Score TrappedRook = S( 92, 0);
219 const Score WeakQueen = S( 50, 10);
220 const Score OtherCheck = S( 10, 10);
221 const Score CloseEnemies = S( 7, 0);
222 const Score PawnlessFlank = S( 20, 80);
223 const Score ThreatByHangingPawn = S( 71, 61);
224 const Score ThreatBySafePawn = S(192,175);
225 const Score ThreatByRank = S( 16, 3);
226 const Score Hanging = S( 48, 27);
227 const Score WeakUnopposedPawn = S( 5, 25);
228 const Score ThreatByPawnPush = S( 38, 22);
229 const Score HinderPassedPawn = S( 7, 0);
230 const Score TrappedBishopA1H1 = S( 50, 50);
235 // KingAttackWeights[PieceType] contains king attack weights by piece type
236 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
238 // Penalties for enemy's safe checks
239 const int QueenCheck = 780;
240 const int RookCheck = 880;
241 const int BishopCheck = 435;
242 const int KnightCheck = 790;
244 // Threshold for lazy and space evaluation
245 const Value LazyThreshold = Value(1500);
246 const Value SpaceThreshold = Value(12222);
249 // initialize() computes king and pawn attacks, and the king ring bitboard
250 // for a given color. This is done at the beginning of the evaluation.
252 template<Tracing T> template<Color Us>
253 void Evaluation<T>::initialize() {
255 const Color Them = (Us == WHITE ? BLACK : WHITE);
256 const Square Up = (Us == WHITE ? NORTH : SOUTH);
257 const Square Down = (Us == WHITE ? SOUTH : NORTH);
258 const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
260 // Find our pawns on the first two ranks, and those which are blocked
261 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
263 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
264 // are excluded from the mobility area.
265 mobilityArea[Us] = ~(b | pos.square<KING>(Us) | pe->pawn_attacks(Them));
267 // Initialise the attack bitboards with the king and pawn information
268 b = attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
269 attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
271 attackedBy2[Us] = b & attackedBy[Us][PAWN];
272 attackedBy[Us][ALL_PIECES] = b | attackedBy[Us][PAWN];
274 // Init our king safety tables only if we are going to use them
275 if (pos.non_pawn_material(Them) >= RookValueMg + KnightValueMg)
278 if (relative_rank(Us, pos.square<KING>(Us)) == RANK_1)
279 kingRing[Us] |= shift<Up>(b);
281 kingAttackersCount[Them] = popcount(b & pe->pawn_attacks(Them));
282 kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
285 kingRing[Us] = kingAttackersCount[Them] = 0;
289 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
292 template<Tracing T> template<Color Us, PieceType Pt>
293 Score Evaluation<T>::evaluate_pieces() {
295 const Color Them = (Us == WHITE ? BLACK : WHITE);
296 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
297 : Rank5BB | Rank4BB | Rank3BB);
298 const Square* pl = pos.squares<Pt>(Us);
302 Score score = SCORE_ZERO;
304 attackedBy[Us][Pt] = 0;
306 while ((s = *pl++) != SQ_NONE)
308 // Find attacked squares, including x-ray attacks for bishops and rooks
309 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
310 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
311 : pos.attacks_from<Pt>(s);
313 if (pos.pinned_pieces(Us) & s)
314 b &= LineBB[pos.square<KING>(Us)][s];
316 attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
317 attackedBy[Us][ALL_PIECES] |= attackedBy[Us][Pt] |= b;
319 if (b & kingRing[Them])
321 kingAttackersCount[Us]++;
322 kingAttackersWeight[Us] += KingAttackWeights[Pt];
323 kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
326 int mob = popcount(b & mobilityArea[Us]);
328 mobility[Us] += MobilityBonus[Pt - 2][mob];
330 // Bonus for this piece as a king protector
331 score += KingProtector[Pt - 2] * distance(s, pos.square<KING>(Us));
333 if (Pt == BISHOP || Pt == KNIGHT)
335 // Bonus for outpost squares
336 bb = OutpostRanks & ~pe->pawn_attacks_span(Them);
338 score += Outpost[Pt == BISHOP][!!(attackedBy[Us][PAWN] & s)] * 2;
341 bb &= b & ~pos.pieces(Us);
343 score += Outpost[Pt == BISHOP][!!(attackedBy[Us][PAWN] & bb)];
346 // Bonus when behind a pawn
347 if ( relative_rank(Us, s) < RANK_5
348 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
349 score += MinorBehindPawn;
353 // Penalty for pawns on the same color square as the bishop
354 score -= BishopPawns * pe->pawns_on_same_color_squares(Us, s);
356 // Bonus for bishop on a long diagonal which can "see" both center squares
357 if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))
358 score += LongRangedBishop;
361 // An important Chess960 pattern: A cornered bishop blocked by a friendly
362 // pawn diagonally in front of it is a very serious problem, especially
363 // when that pawn is also blocked.
366 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
368 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
369 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
370 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
371 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
378 // Bonus for aligning with enemy pawns on the same rank/file
379 if (relative_rank(Us, s) >= RANK_5)
380 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
382 // Bonus when on an open or semi-open file
383 if (pe->semiopen_file(Us, file_of(s)))
384 score += RookOnFile[!!pe->semiopen_file(Them, file_of(s))];
386 // Penalty when trapped by the king, even more if the king cannot castle
389 Square ksq = pos.square<KING>(Us);
391 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
392 && !pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
393 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
399 // Penalty if any relative pin or discovered attack against the queen
401 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
407 Trace::add(Pt, Us, score);
413 // evaluate_king() assigns bonuses and penalties to a king of a given color
415 template<Tracing T> template<Color Us>
416 Score Evaluation<T>::evaluate_king() {
418 const Color Them = (Us == WHITE ? BLACK : WHITE);
419 const Square Up = (Us == WHITE ? NORTH : SOUTH);
420 const Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
421 : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
423 const Square ksq = pos.square<KING>(Us);
424 Bitboard weak, b, b1, b2, safe, other;
427 // King shelter and enemy pawns storm
428 Score score = pe->king_safety<Us>(pos, ksq);
430 // Main king safety evaluation
431 if (kingAttackersCount[Them] > (1 - pos.count<QUEEN>(Them)))
433 // Attacked squares defended at most once by our queen or king
434 weak = attackedBy[Them][ALL_PIECES]
436 & (attackedBy[Us][KING] | attackedBy[Us][QUEEN] | ~attackedBy[Us][ALL_PIECES]);
438 // Initialize the 'kingDanger' variable, which will be transformed
439 // later into a king danger score. The initial value is based on the
440 // number and types of the enemy's attacking pieces, the number of
441 // attacked and weak squares around our king, the absence of queen and
442 // the quality of the pawn shelter (current 'score' value).
443 kingDanger = kingAttackersCount[Them] * kingAttackersWeight[Them]
444 + 102 * kingAdjacentZoneAttacksCount[Them]
445 + 191 * popcount(kingRing[Us] & weak)
446 + 143 * !!pos.pinned_pieces(Us)
447 - 848 * !pos.count<QUEEN>(Them)
448 - 9 * mg_value(score) / 8
451 // Analyse the safe enemy's checks which are possible on next move
452 safe = ~pos.pieces(Them);
453 safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
455 b1 = pos.attacks_from< ROOK>(ksq);
456 b2 = pos.attacks_from<BISHOP>(ksq);
458 // Enemy queen safe checks
459 if ((b1 | b2) & attackedBy[Them][QUEEN] & safe & ~attackedBy[Us][QUEEN])
460 kingDanger += QueenCheck;
462 // Some other potential checks are also analysed, even from squares
463 // currently occupied by the opponent own pieces, as long as the square
464 // is not attacked by our pawns, and is not occupied by a blocked pawn.
465 other = ~( attackedBy[Us][PAWN]
466 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
468 // Enemy rooks safe and other checks
469 if (b1 & attackedBy[Them][ROOK] & safe)
470 kingDanger += RookCheck;
472 else if (b1 & attackedBy[Them][ROOK] & other)
475 // Enemy bishops safe and other checks
476 if (b2 & attackedBy[Them][BISHOP] & safe)
477 kingDanger += BishopCheck;
479 else if (b2 & attackedBy[Them][BISHOP] & other)
482 // Enemy knights safe and other checks
483 b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
485 kingDanger += KnightCheck;
490 // Transform the kingDanger units into a Score, and substract it from the evaluation
492 score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
495 // King tropism: firstly, find squares that opponent attacks in our king flank
496 File kf = file_of(ksq);
497 b = attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
499 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
500 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
502 // Secondly, add the squares which are attacked twice in that flank and
503 // which are not defended by our pawns.
504 b = (Us == WHITE ? b << 4 : b >> 4)
505 | (b & attackedBy2[Them] & ~attackedBy[Us][PAWN]);
507 score -= CloseEnemies * popcount(b);
509 // Penalty when our king is on a pawnless flank
510 if (!(pos.pieces(PAWN) & KingFlank[kf]))
511 score -= PawnlessFlank;
514 Trace::add(KING, Us, score);
520 // evaluate_threats() assigns bonuses according to the types of the attacking
521 // and the attacked pieces.
523 template<Tracing T> template<Color Us>
524 Score Evaluation<T>::evaluate_threats() {
526 const Color Them = (Us == WHITE ? BLACK : WHITE);
527 const Square Up = (Us == WHITE ? NORTH : SOUTH);
528 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
529 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
530 const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
532 Bitboard b, weak, defended, stronglyProtected, safeThreats;
533 Score score = SCORE_ZERO;
535 // Non-pawn enemies attacked by a pawn
536 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & attackedBy[Us][PAWN];
540 b = pos.pieces(Us, PAWN) & ( ~attackedBy[Them][ALL_PIECES]
541 | attackedBy[Us][ALL_PIECES]);
543 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
545 score += ThreatBySafePawn * popcount(safeThreats);
547 if (weak ^ safeThreats)
548 score += ThreatByHangingPawn;
551 // Squares strongly protected by the opponent, either because they attack the
552 // square with a pawn, or because they attack the square twice and we don't.
553 stronglyProtected = attackedBy[Them][PAWN]
554 | (attackedBy2[Them] & ~attackedBy2[Us]);
556 // Non-pawn enemies, strongly protected
557 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
560 // Enemies not strongly protected and under our attack
561 weak = pos.pieces(Them)
563 & attackedBy[Us][ALL_PIECES];
565 // Add a bonus according to the kind of attacking pieces
568 b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
571 Square s = pop_lsb(&b);
572 score += ThreatByMinor[type_of(pos.piece_on(s))];
573 if (type_of(pos.piece_on(s)) != PAWN)
574 score += ThreatByRank * (int)relative_rank(Them, s);
577 b = (pos.pieces(Them, QUEEN) | weak) & attackedBy[Us][ROOK];
580 Square s = pop_lsb(&b);
581 score += ThreatByRook[type_of(pos.piece_on(s))];
582 if (type_of(pos.piece_on(s)) != PAWN)
583 score += ThreatByRank * (int)relative_rank(Them, s);
586 score += Hanging * popcount(weak & ~attackedBy[Them][ALL_PIECES]);
588 b = weak & attackedBy[Us][KING];
590 score += ThreatByKing[more_than_one(b)];
593 // Bonus for opponent unopposed weak pawns
594 if (pos.pieces(Us, ROOK, QUEEN))
595 score += WeakUnopposedPawn * pe->weak_unopposed(Them);
597 // Find squares where our pawns can push on the next move
598 b = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
599 b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
601 // Keep only the squares which are not completely unsafe
602 b &= ~attackedBy[Them][PAWN]
603 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
605 // Add a bonus for each new pawn threats from those squares
606 b = (shift<Left>(b) | shift<Right>(b))
608 & ~attackedBy[Us][PAWN];
610 score += ThreatByPawnPush * popcount(b);
613 Trace::add(THREAT, Us, score);
619 // evaluate_passed_pawns() evaluates the passed pawns and candidate passed
620 // pawns of the given color.
622 template<Tracing T> template<Color Us>
623 Score Evaluation<T>::evaluate_passed_pawns() {
625 const Color Them = (Us == WHITE ? BLACK : WHITE);
626 const Square Up = (Us == WHITE ? NORTH : SOUTH);
628 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
629 Score score = SCORE_ZERO;
631 b = pe->passed_pawns(Us);
635 Square s = pop_lsb(&b);
637 assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
639 bb = forward_file_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
640 score -= HinderPassedPawn * popcount(bb);
642 int r = relative_rank(Us, s) - RANK_2;
643 int rr = r * (r - 1);
645 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
649 Square blockSq = s + Up;
651 // Adjust bonus based on the king's proximity
652 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
653 - distance(pos.square<KING>( Us), blockSq) * 2 * rr;
655 // If blockSq is not the queening square then consider also a second push
656 if (relative_rank(Us, blockSq) != RANK_8)
657 ebonus -= distance(pos.square<KING>(Us), blockSq + Up) * rr;
659 // If the pawn is free to advance, then increase the bonus
660 if (pos.empty(blockSq))
662 // If there is a rook or queen attacking/defending the pawn from behind,
663 // consider all the squaresToQueen. Otherwise consider only the squares
664 // in the pawn's path attacked or occupied by the enemy.
665 defendedSquares = unsafeSquares = squaresToQueen = forward_file_bb(Us, s);
667 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
669 if (!(pos.pieces(Us) & bb))
670 defendedSquares &= attackedBy[Us][ALL_PIECES];
672 if (!(pos.pieces(Them) & bb))
673 unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
675 // If there aren't any enemy attacks, assign a big bonus. Otherwise
676 // assign a smaller bonus if the block square isn't attacked.
677 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
679 // If the path to the queen is fully defended, assign a big bonus.
680 // Otherwise assign a smaller bonus if the block square is defended.
681 if (defendedSquares == squaresToQueen)
684 else if (defendedSquares & blockSq)
687 mbonus += k * rr, ebonus += k * rr;
689 else if (pos.pieces(Us) & blockSq)
690 mbonus += rr + r * 2, ebonus += rr + r * 2;
693 // Scale down bonus for candidate passers which need more than one
694 // pawn push to become passed or have a pawn in front of them.
695 if (!pos.pawn_passed(Us, s + Up) || (pos.pieces(PAWN) & forward_file_bb(Us, s)))
696 mbonus /= 2, ebonus /= 2;
698 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
702 Trace::add(PASSED, Us, score);
708 // evaluate_space() computes the space evaluation for a given side. The
709 // space evaluation is a simple bonus based on the number of safe squares
710 // available for minor pieces on the central four files on ranks 2--4. Safe
711 // squares one, two or three squares behind a friendly pawn are counted
712 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
713 // improve play on game opening.
715 template<Tracing T> template<Color Us>
716 Score Evaluation<T>::evaluate_space() {
718 const Color Them = (Us == WHITE ? BLACK : WHITE);
719 const Bitboard SpaceMask =
720 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
721 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
723 // Find the safe squares for our pieces inside the area defined by
724 // SpaceMask. A square is unsafe if it is attacked by an enemy
725 // pawn, or if it is undefended and attacked by an enemy piece.
726 Bitboard safe = SpaceMask
727 & ~pos.pieces(Us, PAWN)
728 & ~attackedBy[Them][PAWN]
729 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
731 // Find all squares which are at most three squares behind some friendly pawn
732 Bitboard behind = pos.pieces(Us, PAWN);
733 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
734 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
736 // Since SpaceMask[Us] is fully on our half of the board...
737 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
739 // ...count safe + (behind & safe) with a single popcount.
740 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
741 int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
743 return make_score(bonus * weight * weight / 16, 0);
747 // evaluate_initiative() computes the initiative correction value for the
748 // position, i.e., second order bonus/malus based on the known attacking/defending
749 // status of the players.
752 Score Evaluation<T>::evaluate_initiative(Value eg) {
754 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
755 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
756 bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
758 // Compute the initiative bonus for the attacking side
759 int initiative = 8 * (pe->pawn_asymmetry() + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
761 // Now apply the bonus: note that we find the attacking side by extracting
762 // the sign of the endgame value, and that we carefully cap the bonus so
763 // that the endgame score will never change sign after the bonus.
764 int v = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
767 Trace::add(INITIATIVE, make_score(0, v));
769 return make_score(0, v);
773 // evaluate_scale_factor() computes the scale factor for the winning side
776 ScaleFactor Evaluation<T>::evaluate_scale_factor(Value eg) {
778 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
779 ScaleFactor sf = me->scale_factor(pos, strongSide);
781 // If we don't already have an unusual scale factor, check for certain
782 // types of endgames, and use a lower scale for those.
783 if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
785 if (pos.opposite_bishops())
787 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
788 // is almost a draw, in case of KBP vs KB, it is even more a draw.
789 if ( pos.non_pawn_material(WHITE) == BishopValueMg
790 && pos.non_pawn_material(BLACK) == BishopValueMg)
791 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
793 // Endgame with opposite-colored bishops, but also other pieces. Still
794 // a bit drawish, but not as drawish as with only the two bishops.
795 return ScaleFactor(46);
797 // Endings where weaker side can place his king in front of the opponent's
798 // pawns are drawish.
799 else if ( abs(eg) <= BishopValueEg
800 && pos.count<PAWN>(strongSide) <= 2
801 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
802 return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
809 // value() is the main function of the class. It computes the various parts of
810 // the evaluation and returns the value of the position from the point of view
811 // of the side to move.
814 Value Evaluation<T>::value() {
816 assert(!pos.checkers());
818 // Probe the material hash table
819 me = Material::probe(pos);
821 // If we have a specialized evaluation function for the current material
822 // configuration, call it and return.
823 if (me->specialized_eval_exists())
824 return me->evaluate(pos);
826 // Initialize score by reading the incrementally updated scores included in
827 // the position object (material + piece square tables) and the material
828 // imbalance. Score is computed internally from the white point of view.
829 Score score = pos.psq_score() + me->imbalance();
831 // Probe the pawn hash table
832 pe = Pawns::probe(pos);
833 score += pe->pawns_score();
835 // Early exit if score is high
836 Value v = (mg_value(score) + eg_value(score)) / 2;
837 if (abs(v) > LazyThreshold)
838 return pos.side_to_move() == WHITE ? v : -v;
840 // Main evaluation begins here
845 score += evaluate_pieces<WHITE, KNIGHT>() - evaluate_pieces<BLACK, KNIGHT>();
846 score += evaluate_pieces<WHITE, BISHOP>() - evaluate_pieces<BLACK, BISHOP>();
847 score += evaluate_pieces<WHITE, ROOK >() - evaluate_pieces<BLACK, ROOK >();
848 score += evaluate_pieces<WHITE, QUEEN >() - evaluate_pieces<BLACK, QUEEN >();
850 score += mobility[WHITE] - mobility[BLACK];
852 score += evaluate_king<WHITE>()
853 - evaluate_king<BLACK>();
855 score += evaluate_threats<WHITE>()
856 - evaluate_threats<BLACK>();
858 score += evaluate_passed_pawns<WHITE>()
859 - evaluate_passed_pawns<BLACK>();
861 if (pos.non_pawn_material() >= SpaceThreshold)
862 score += evaluate_space<WHITE>()
863 - evaluate_space<BLACK>();
865 score += evaluate_initiative(eg_value(score));
867 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
868 ScaleFactor sf = evaluate_scale_factor(eg_value(score));
869 v = mg_value(score) * int(me->game_phase())
870 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
872 v /= int(PHASE_MIDGAME);
874 // In case of tracing add all remaining individual evaluation terms
877 Trace::add(MATERIAL, pos.psq_score());
878 Trace::add(IMBALANCE, me->imbalance());
879 Trace::add(PAWN, pe->pawns_score());
880 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
881 if (pos.non_pawn_material() >= SpaceThreshold)
882 Trace::add(SPACE, evaluate_space<WHITE>()
883 , evaluate_space<BLACK>());
884 Trace::add(TOTAL, score);
887 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
893 /// evaluate() is the evaluator for the outer world. It returns a static evaluation
894 /// of the position from the point of view of the side to move.
896 Value Eval::evaluate(const Position& pos)
898 return Evaluation<>(pos).value();
901 /// trace() is like evaluate(), but instead of returning a value, it returns
902 /// a string (suitable for outputting to stdout) that contains the detailed
903 /// descriptions and values of each evaluation term. Useful for debugging.
905 std::string Eval::trace(const Position& pos) {
907 std::memset(scores, 0, sizeof(scores));
909 Value v = Evaluation<TRACE>(pos).value();
910 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
912 std::stringstream ss;
913 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
914 << " Eval term | White | Black | Total \n"
915 << " | MG EG | MG EG | MG EG \n"
916 << "----------------+-------------+-------------+-------------\n"
917 << " Material | " << Term(MATERIAL)
918 << " Imbalance | " << Term(IMBALANCE)
919 << " Pawns | " << Term(PAWN)
920 << " Knights | " << Term(KNIGHT)
921 << " Bishops | " << Term(BISHOP)
922 << " Rooks | " << Term(ROOK)
923 << " Queens | " << Term(QUEEN)
924 << " Mobility | " << Term(MOBILITY)
925 << " King safety | " << Term(KING)
926 << " Threats | " << Term(THREAT)
927 << " Passed pawns | " << Term(PASSED)
928 << " Space | " << Term(SPACE)
929 << " Initiative | " << Term(INITIATIVE)
930 << "----------------+-------------+-------------+-------------\n"
931 << " Total | " << Term(TOTAL);
933 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";