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
36 enum Tracing {NO_TRACE, TRACE};
38 enum Term { // The first 8 entries are for PieceType
39 MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
42 double scores[TERM_NB][COLOR_NB][PHASE_NB];
44 double to_cp(Value v) { return double(v) / PawnValueEg; }
46 void add(int idx, Color c, Score s) {
47 scores[idx][c][MG] = to_cp(mg_value(s));
48 scores[idx][c][EG] = to_cp(eg_value(s));
51 void add(int idx, Score w, Score b = SCORE_ZERO) {
52 add(idx, WHITE, w); add(idx, BLACK, b);
55 std::ostream& operator<<(std::ostream& os, Term t) {
57 if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL)
58 os << " --- --- | --- --- | ";
60 os << std::setw(5) << scores[t][WHITE][MG] << " "
61 << std::setw(5) << scores[t][WHITE][EG] << " | "
62 << std::setw(5) << scores[t][BLACK][MG] << " "
63 << std::setw(5) << scores[t][BLACK][EG] << " | ";
65 os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
66 << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
72 using namespace Trace;
74 // Evaluation class contains various information computed and collected
75 // by the evaluation functions.
76 template<Tracing T = NO_TRACE>
80 Evaluation() = delete;
81 Evaluation(const Position& p) : pos(p) {}
82 Evaluation& operator=(const Evaluation&) = delete;
87 // Evaluation helpers (used when calling value())
88 template<Color Us> void initialize();
89 template<Color Us> Score evaluate_king();
90 template<Color Us> Score evaluate_threats();
91 template<Color Us> Score evaluate_passed_pawns();
92 template<Color Us> Score evaluate_space();
93 template<Color Us, PieceType Pt> Score evaluate_pieces();
94 ScaleFactor evaluate_scale_factor(Value eg);
95 Score evaluate_initiative(Value eg);
101 Bitboard mobilityArea[COLOR_NB];
102 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
104 // attackedBy[color][piece type] is a bitboard representing all squares
105 // attacked by a given color and piece type (can be also ALL_PIECES).
106 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
108 // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
109 // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
110 // pawn or squares attacked by 2 pawns are not explicitly added.
111 Bitboard attackedBy2[COLOR_NB];
113 // kingRing[color] is the zone around the king which is considered
114 // by the king safety evaluation. This consists of the squares directly
115 // adjacent to the king, and (only for a king on its first rank) the
116 // squares two ranks in front of the king. For instance, if black's king
117 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
118 // f7, g7, h7, f6, g6 and h6.
119 Bitboard kingRing[COLOR_NB];
121 // kingAttackersCount[color] is the number of pieces of the given color
122 // which attack a square in the kingRing of the enemy king.
123 int kingAttackersCount[COLOR_NB];
125 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
126 // given color which attack a square in the kingRing of the enemy king. The
127 // weights of the individual piece types are given by the elements in the
128 // KingAttackWeights array.
129 int kingAttackersWeight[COLOR_NB];
131 // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
132 // color to squares directly adjacent to the enemy king. Pieces which attack
133 // more than one square are counted multiple times. For instance, if there is
134 // a white knight on g5 and black's king is on g8, this white knight adds 2
135 // to kingAdjacentZoneAttacksCount[WHITE].
136 int kingAdjacentZoneAttacksCount[COLOR_NB];
139 #define V(v) Value(v)
140 #define S(mg, eg) make_score(mg, eg)
142 // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
143 // indexed by piece type and number of attacked squares in the mobility area.
144 const Score MobilityBonus[][32] = {
145 { S(-75,-76), S(-57,-54), S( -9,-28), S( -2,-10), S( 6, 5), S( 14, 12), // Knights
146 S( 22, 26), S( 29, 29), S( 36, 29) },
147 { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
148 S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
149 S( 91, 88), S( 98, 97) },
150 { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
151 S( 9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
152 S( 46,166), S( 48,169), S( 58,171) },
153 { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens
154 S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
155 S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
156 S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
157 S(106,184), S(109,191), S(113,206), S(116,212) }
160 // Outpost[knight/bishop][supported by pawn] contains bonuses for minor
161 // pieces if they can reach an outpost square, bigger if that square is
162 // supported by a pawn. If the minor piece occupies an outpost square
163 // then score is doubled.
164 const Score Outpost[][2] = {
165 { S(22, 6), S(36,12) }, // Knight
166 { S( 9, 2), S(15, 5) } // Bishop
169 // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
170 // friendly pawn on the rook file.
171 const Score RookOnFile[] = { S(20, 7), S(45, 20) };
173 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
174 // which piece type attacks which one. Attacks on lesser pieces which are
175 // pawn-defended are not considered.
176 const Score ThreatByMinor[PIECE_TYPE_NB] = {
177 S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
180 const Score ThreatByRook[PIECE_TYPE_NB] = {
181 S(0, 0), S(0, 25), S(40, 62), S(40, 59), S(0, 34), S(35, 48)
184 // ThreatByKing[on one/on many] contains bonuses for king attacks on
185 // pawns or pieces which are not pawn-defended.
186 const Score ThreatByKing[] = { S(3, 62), S(9, 138) };
188 // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
189 // We don't use a Score because we process the two components independently.
190 const Value Passed[][RANK_NB] = {
191 { V(5), V( 5), V(31), V(73), V(166), V(252) },
192 { V(7), V(14), V(38), V(73), V(166), V(252) }
195 // PassedFile[File] contains a bonus according to the file of a passed pawn
196 const Score PassedFile[FILE_NB] = {
197 S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
198 S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
201 // KingProtector[PieceType-2] contains a bonus according to distance from king
202 const Score KingProtector[] = { S(-3, -5), S(-4, -3), S(-3, 0), S(-1, 1) };
204 // Assorted bonuses and penalties used by evaluation
205 const Score MinorBehindPawn = S( 16, 0);
206 const Score BishopPawns = S( 8, 12);
207 const Score RookOnPawn = S( 8, 24);
208 const Score TrappedRook = S( 92, 0);
209 const Score WeakQueen = S( 50, 10);
210 const Score OtherCheck = S( 10, 10);
211 const Score CloseEnemies = S( 7, 0);
212 const Score PawnlessFlank = S( 20, 80);
213 const Score ThreatByHangingPawn = S( 71, 61);
214 const Score ThreatBySafePawn = S(182,175);
215 const Score ThreatByRank = S( 16, 3);
216 const Score Hanging = S( 48, 27);
217 const Score WeakUnopposedPawn = S( 5, 25);
218 const Score ThreatByPawnPush = S( 38, 22);
219 const Score HinderPassedPawn = S( 7, 0);
220 const Score TrappedBishopA1H1 = S( 50, 50);
225 // KingAttackWeights[PieceType] contains king attack weights by piece type
226 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
228 // Penalties for enemy's safe checks
229 const int QueenCheck = 780;
230 const int RookCheck = 880;
231 const int BishopCheck = 435;
232 const int KnightCheck = 790;
234 // Threshold for lazy and space evaluation
235 const Value LazyThreshold = Value(1500);
236 const Value SpaceThreshold = Value(12222);
239 // initialize() computes king and pawn attacks, and the king ring bitboard
240 // for a given color. This is done at the beginning of the evaluation.
242 template<Tracing T> template<Color Us>
243 void Evaluation<T>::initialize() {
245 const Color Them = (Us == WHITE ? BLACK : WHITE);
246 const Square Up = (Us == WHITE ? NORTH : SOUTH);
247 const Square Down = (Us == WHITE ? SOUTH : NORTH);
248 const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
250 // Find our pawns on the first two ranks, and those which are blocked
251 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
253 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
254 // are excluded from the mobility area.
255 mobilityArea[Us] = ~(b | pos.square<KING>(Us) | pe->pawn_attacks(Them));
257 // Initialise the attack bitboards with the king and pawn information
258 b = attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
259 attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
261 attackedBy2[Us] = b & attackedBy[Us][PAWN];
262 attackedBy[Us][ALL_PIECES] = b | attackedBy[Us][PAWN];
264 // Init our king safety tables only if we are going to use them
265 if (pos.non_pawn_material(Them) >= RookValueMg + KnightValueMg)
268 if (relative_rank(Us, pos.square<KING>(Us)) == RANK_1)
269 kingRing[Us] |= shift<Up>(b);
271 kingAttackersCount[Them] = popcount(b & pe->pawn_attacks(Them));
272 kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
275 kingRing[Us] = kingAttackersCount[Them] = 0;
279 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
282 template<Tracing T> template<Color Us, PieceType Pt>
283 Score Evaluation<T>::evaluate_pieces() {
285 const Color Them = (Us == WHITE ? BLACK : WHITE);
286 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
287 : Rank5BB | Rank4BB | Rank3BB);
288 const Square* pl = pos.squares<Pt>(Us);
292 Score score = SCORE_ZERO;
294 attackedBy[Us][Pt] = 0;
296 while ((s = *pl++) != SQ_NONE)
298 // Find attacked squares, including x-ray attacks for bishops and rooks
299 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
300 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
301 : pos.attacks_from<Pt>(s);
303 if (pos.pinned_pieces(Us) & s)
304 b &= LineBB[pos.square<KING>(Us)][s];
306 attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
307 attackedBy[Us][ALL_PIECES] |= attackedBy[Us][Pt] |= b;
309 if (b & kingRing[Them])
311 kingAttackersCount[Us]++;
312 kingAttackersWeight[Us] += KingAttackWeights[Pt];
313 kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
316 int mob = popcount(b & mobilityArea[Us]);
318 mobility[Us] += MobilityBonus[Pt - 2][mob];
320 // Bonus for this piece as a king protector
321 score += KingProtector[Pt - 2] * distance(s, pos.square<KING>(Us));
323 if (Pt == BISHOP || Pt == KNIGHT)
325 // Bonus for outpost squares
326 bb = OutpostRanks & ~pe->pawn_attacks_span(Them);
328 score += Outpost[Pt == BISHOP][!!(attackedBy[Us][PAWN] & s)] * 2;
331 bb &= b & ~pos.pieces(Us);
333 score += Outpost[Pt == BISHOP][!!(attackedBy[Us][PAWN] & bb)];
336 // Bonus when behind a pawn
337 if ( relative_rank(Us, s) < RANK_5
338 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
339 score += MinorBehindPawn;
341 // Penalty for pawns on the same color square as the bishop
343 score -= BishopPawns * pe->pawns_on_same_color_squares(Us, s);
345 // An important Chess960 pattern: A cornered bishop blocked by a friendly
346 // pawn diagonally in front of it is a very serious problem, especially
347 // when that pawn is also blocked.
350 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
352 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
353 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
354 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
355 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
362 // Bonus for aligning with enemy pawns on the same rank/file
363 if (relative_rank(Us, s) >= RANK_5)
364 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
366 // Bonus when on an open or semi-open file
367 if (pe->semiopen_file(Us, file_of(s)))
368 score += RookOnFile[!!pe->semiopen_file(Them, file_of(s))];
370 // Penalty when trapped by the king, even more if the king cannot castle
373 Square ksq = pos.square<KING>(Us);
375 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
376 && !pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
377 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
383 // Penalty if any relative pin or discovered attack against the queen
385 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
391 Trace::add(Pt, Us, score);
397 // evaluate_king() assigns bonuses and penalties to a king of a given color
399 const Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
400 const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
401 const Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
403 const Bitboard KingFlank[FILE_NB] = {
404 QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide
407 template<Tracing T> template<Color Us>
408 Score Evaluation<T>::evaluate_king() {
410 const Color Them = (Us == WHITE ? BLACK : WHITE);
411 const Square Up = (Us == WHITE ? NORTH : SOUTH);
412 const Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
413 : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
415 const Square ksq = pos.square<KING>(Us);
416 Bitboard kingOnlyDefended, undefended, b, b1, b2, safe, other;
419 // King shelter and enemy pawns storm
420 Score score = pe->king_safety<Us>(pos, ksq);
422 // Main king safety evaluation
423 if (kingAttackersCount[Them] > (1 - pos.count<QUEEN>(Them)))
425 // Find the attacked squares which are defended only by our king...
426 kingOnlyDefended = attackedBy[Them][ALL_PIECES]
427 & attackedBy[Us][KING]
430 // ... and those which are not defended at all in the larger king ring
431 undefended = attackedBy[Them][ALL_PIECES]
432 & ~attackedBy[Us][ALL_PIECES]
436 // Initialize the 'kingDanger' variable, which will be transformed
437 // later into a king danger score. The initial value is based on the
438 // number and types of the enemy's attacking pieces, the number of
439 // attacked and weak squares around our king, the absence of queen and
440 // the quality of the pawn shelter (current 'score' value).
441 kingDanger = kingAttackersCount[Them] * kingAttackersWeight[Them]
442 + 102 * kingAdjacentZoneAttacksCount[Them]
443 + 191 * popcount(kingOnlyDefended | undefended)
444 + 143 * !!pos.pinned_pieces(Us)
445 - 848 * !pos.count<QUEEN>(Them)
446 - 9 * mg_value(score) / 8
449 // Analyse the safe enemy's checks which are possible on next move
450 safe = ~pos.pieces(Them);
451 safe &= ~attackedBy[Us][ALL_PIECES] | (kingOnlyDefended & attackedBy2[Them]);
453 b1 = pos.attacks_from< ROOK>(ksq);
454 b2 = pos.attacks_from<BISHOP>(ksq);
456 // Enemy queen safe checks
457 if ((b1 | b2) & attackedBy[Them][QUEEN] & safe)
458 kingDanger += QueenCheck;
460 // For minors and rooks, also consider the square safe if attacked twice,
461 // and only defended by our queen.
462 safe |= attackedBy2[Them]
463 & ~(attackedBy2[Us] | pos.pieces(Them))
464 & attackedBy[Us][QUEEN];
466 // Some other potential checks are also analysed, even from squares
467 // currently occupied by the opponent own pieces, as long as the square
468 // is not attacked by our pawns, and is not occupied by a blocked pawn.
469 other = ~( attackedBy[Us][PAWN]
470 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
472 // Enemy rooks safe and other checks
473 if (b1 & attackedBy[Them][ROOK] & safe)
474 kingDanger += RookCheck;
476 else if (b1 & attackedBy[Them][ROOK] & other)
479 // Enemy bishops safe and other checks
480 if (b2 & attackedBy[Them][BISHOP] & safe)
481 kingDanger += BishopCheck;
483 else if (b2 & attackedBy[Them][BISHOP] & other)
486 // Enemy knights safe and other checks
487 b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
489 kingDanger += KnightCheck;
494 // Transform the kingDanger units into a Score, and substract it from the evaluation
496 score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
499 // King tropism: firstly, find squares that opponent attacks in our king flank
500 File kf = file_of(ksq);
501 b = attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
503 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
504 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
506 // Secondly, add the squares which are attacked twice in that flank and
507 // which are not defended by our pawns.
508 b = (Us == WHITE ? b << 4 : b >> 4)
509 | (b & attackedBy2[Them] & ~attackedBy[Us][PAWN]);
511 score -= CloseEnemies * popcount(b);
513 // Penalty when our king is on a pawnless flank
514 if (!(pos.pieces(PAWN) & KingFlank[kf]))
515 score -= PawnlessFlank;
518 Trace::add(KING, Us, score);
524 // evaluate_threats() assigns bonuses according to the types of the attacking
525 // and the attacked pieces.
527 template<Tracing T> template<Color Us>
528 Score Evaluation<T>::evaluate_threats() {
530 const Color Them = (Us == WHITE ? BLACK : WHITE);
531 const Square Up = (Us == WHITE ? NORTH : SOUTH);
532 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
533 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
534 const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
536 Bitboard b, weak, defended, stronglyProtected, safeThreats;
537 Score score = SCORE_ZERO;
539 // Non-pawn enemies attacked by a pawn
540 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & attackedBy[Us][PAWN];
544 b = pos.pieces(Us, PAWN) & ( ~attackedBy[Them][ALL_PIECES]
545 | attackedBy[Us][ALL_PIECES]);
547 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
549 score += ThreatBySafePawn * popcount(safeThreats);
551 if (weak ^ safeThreats)
552 score += ThreatByHangingPawn;
555 // Squares strongly protected by the opponent, either because they attack the
556 // square with a pawn, or because they attack the square twice and we don't.
557 stronglyProtected = attackedBy[Them][PAWN]
558 | (attackedBy2[Them] & ~attackedBy2[Us]);
560 // Non-pawn enemies, strongly protected
561 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
564 // Enemies not strongly protected and under our attack
565 weak = pos.pieces(Them)
567 & attackedBy[Us][ALL_PIECES];
569 // Add a bonus according to the kind of attacking pieces
572 b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
575 Square s = pop_lsb(&b);
576 score += ThreatByMinor[type_of(pos.piece_on(s))];
577 if (type_of(pos.piece_on(s)) != PAWN)
578 score += ThreatByRank * (int)relative_rank(Them, s);
581 b = (pos.pieces(Them, QUEEN) | weak) & attackedBy[Us][ROOK];
584 Square s = pop_lsb(&b);
585 score += ThreatByRook[type_of(pos.piece_on(s))];
586 if (type_of(pos.piece_on(s)) != PAWN)
587 score += ThreatByRank * (int)relative_rank(Them, s);
590 score += Hanging * popcount(weak & ~attackedBy[Them][ALL_PIECES]);
592 b = weak & attackedBy[Us][KING];
594 score += ThreatByKing[more_than_one(b)];
597 // Bonus for opponent unopposed weak pawns
598 if (pos.pieces(Us, ROOK, QUEEN))
599 score += WeakUnopposedPawn * pe->weak_unopposed(Them);
601 // Find squares where our pawns can push on the next move
602 b = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
603 b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
605 // Keep only the squares which are not completely unsafe
606 b &= ~attackedBy[Them][PAWN]
607 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
609 // Add a bonus for each new pawn threats from those squares
610 b = (shift<Left>(b) | shift<Right>(b))
612 & ~attackedBy[Us][PAWN];
614 score += ThreatByPawnPush * popcount(b);
617 Trace::add(THREAT, Us, score);
623 // evaluate_passed_pawns() evaluates the passed pawns and candidate passed
624 // pawns of the given color.
626 template<Tracing T> template<Color Us>
627 Score Evaluation<T>::evaluate_passed_pawns() {
629 const Color Them = (Us == WHITE ? BLACK : WHITE);
630 const Square Up = (Us == WHITE ? NORTH : SOUTH);
632 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
633 Score score = SCORE_ZERO;
635 b = pe->passed_pawns(Us);
639 Square s = pop_lsb(&b);
641 assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
643 bb = forward_file_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
644 score -= HinderPassedPawn * popcount(bb);
646 int r = relative_rank(Us, s) - RANK_2;
647 int rr = r * (r - 1);
649 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
653 Square blockSq = s + Up;
655 // Adjust bonus based on the king's proximity
656 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
657 - distance(pos.square<KING>( Us), blockSq) * 2 * rr;
659 // If blockSq is not the queening square then consider also a second push
660 if (relative_rank(Us, blockSq) != RANK_8)
661 ebonus -= distance(pos.square<KING>(Us), blockSq + Up) * rr;
663 // If the pawn is free to advance, then increase the bonus
664 if (pos.empty(blockSq))
666 // If there is a rook or queen attacking/defending the pawn from behind,
667 // consider all the squaresToQueen. Otherwise consider only the squares
668 // in the pawn's path attacked or occupied by the enemy.
669 defendedSquares = unsafeSquares = squaresToQueen = forward_file_bb(Us, s);
671 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
673 if (!(pos.pieces(Us) & bb))
674 defendedSquares &= attackedBy[Us][ALL_PIECES];
676 if (!(pos.pieces(Them) & bb))
677 unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
679 // If there aren't any enemy attacks, assign a big bonus. Otherwise
680 // assign a smaller bonus if the block square isn't attacked.
681 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
683 // If the path to the queen is fully defended, assign a big bonus.
684 // Otherwise assign a smaller bonus if the block square is defended.
685 if (defendedSquares == squaresToQueen)
688 else if (defendedSquares & blockSq)
691 mbonus += k * rr, ebonus += k * rr;
693 else if (pos.pieces(Us) & blockSq)
694 mbonus += rr + r * 2, ebonus += rr + r * 2;
697 // Scale down bonus for candidate passers which need more than one
698 // pawn push to become passed or have a pawn in front of them.
699 if (!pos.pawn_passed(Us, s + Up) || (pos.pieces(PAWN) & forward_file_bb(Us, s)))
700 mbonus /= 2, ebonus /= 2;
702 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
706 Trace::add(PASSED, Us, score);
712 // evaluate_space() computes the space evaluation for a given side. The
713 // space evaluation is a simple bonus based on the number of safe squares
714 // available for minor pieces on the central four files on ranks 2--4. Safe
715 // squares one, two or three squares behind a friendly pawn are counted
716 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
717 // improve play on game opening.
719 template<Tracing T> template<Color Us>
720 Score Evaluation<T>::evaluate_space() {
722 const Color Them = (Us == WHITE ? BLACK : WHITE);
723 const Bitboard SpaceMask =
724 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
725 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
727 // Find the safe squares for our pieces inside the area defined by
728 // SpaceMask. A square is unsafe if it is attacked by an enemy
729 // pawn, or if it is undefended and attacked by an enemy piece.
730 Bitboard safe = SpaceMask
731 & ~pos.pieces(Us, PAWN)
732 & ~attackedBy[Them][PAWN]
733 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
735 // Find all squares which are at most three squares behind some friendly pawn
736 Bitboard behind = pos.pieces(Us, PAWN);
737 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
738 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
740 // Since SpaceMask[Us] is fully on our half of the board...
741 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
743 // ...count safe + (behind & safe) with a single popcount.
744 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
745 int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
747 return make_score(bonus * weight * weight / 16, 0);
751 // evaluate_initiative() computes the initiative correction value for the
752 // position, i.e., second order bonus/malus based on the known attacking/defending
753 // status of the players.
756 Score Evaluation<T>::evaluate_initiative(Value eg) {
758 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
759 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
760 bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
762 // Compute the initiative bonus for the attacking side
763 int initiative = 8 * (pe->pawn_asymmetry() + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
765 // Now apply the bonus: note that we find the attacking side by extracting
766 // the sign of the endgame value, and that we carefully cap the bonus so
767 // that the endgame score will never change sign after the bonus.
768 int v = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
770 return make_score(0, v);
774 // evaluate_scale_factor() computes the scale factor for the winning side
777 ScaleFactor Evaluation<T>::evaluate_scale_factor(Value eg) {
779 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
780 ScaleFactor sf = me->scale_factor(pos, strongSide);
782 // If we don't already have an unusual scale factor, check for certain
783 // types of endgames, and use a lower scale for those.
784 if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
786 if (pos.opposite_bishops())
788 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
789 // is almost a draw, in case of KBP vs KB, it is even more a draw.
790 if ( pos.non_pawn_material(WHITE) == BishopValueMg
791 && pos.non_pawn_material(BLACK) == BishopValueMg)
792 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
794 // Endgame with opposite-colored bishops, but also other pieces. Still
795 // a bit drawish, but not as drawish as with only the two bishops.
796 return ScaleFactor(46);
798 // Endings where weaker side can place his king in front of the opponent's
799 // pawns are drawish.
800 else if ( abs(eg) <= BishopValueEg
801 && pos.count<PAWN>(strongSide) <= 2
802 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
803 return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
810 // value() is the main function of the class. It computes the various parts of
811 // the evaluation and returns the value of the position from the point of view
812 // of the side to move.
815 Value Evaluation<T>::value() {
817 assert(!pos.checkers());
819 // Probe the material hash table
820 me = Material::probe(pos);
822 // If we have a specialized evaluation function for the current material
823 // configuration, call it and return.
824 if (me->specialized_eval_exists())
825 return me->evaluate(pos);
827 // Initialize score by reading the incrementally updated scores included in
828 // the position object (material + piece square tables) and the material
829 // imbalance. Score is computed internally from the white point of view.
830 Score score = pos.psq_score() + me->imbalance();
832 // Probe the pawn hash table
833 pe = Pawns::probe(pos);
834 score += pe->pawns_score();
836 // Early exit if score is high
837 Value v = (mg_value(score) + eg_value(score)) / 2;
838 if (abs(v) > LazyThreshold)
839 return pos.side_to_move() == WHITE ? v : -v;
841 // Main evaluation begins here
846 score += evaluate_pieces<WHITE, KNIGHT>() - evaluate_pieces<BLACK, KNIGHT>();
847 score += evaluate_pieces<WHITE, BISHOP>() - evaluate_pieces<BLACK, BISHOP>();
848 score += evaluate_pieces<WHITE, ROOK >() - evaluate_pieces<BLACK, ROOK >();
849 score += evaluate_pieces<WHITE, QUEEN >() - evaluate_pieces<BLACK, QUEEN >();
851 score += mobility[WHITE] - mobility[BLACK];
853 score += evaluate_king<WHITE>()
854 - evaluate_king<BLACK>();
856 score += evaluate_threats<WHITE>()
857 - evaluate_threats<BLACK>();
859 score += evaluate_passed_pawns<WHITE>()
860 - evaluate_passed_pawns<BLACK>();
862 if (pos.non_pawn_material() >= SpaceThreshold)
863 score += evaluate_space<WHITE>()
864 - evaluate_space<BLACK>();
866 score += evaluate_initiative(eg_value(score));
868 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
869 ScaleFactor sf = evaluate_scale_factor(eg_value(score));
870 v = mg_value(score) * int(me->game_phase())
871 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
873 v /= int(PHASE_MIDGAME);
875 // In case of tracing add all remaining individual evaluation terms
878 Trace::add(MATERIAL, pos.psq_score());
879 Trace::add(IMBALANCE, me->imbalance());
880 Trace::add(PAWN, pe->pawns_score());
881 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
882 if (pos.non_pawn_material() >= SpaceThreshold)
883 Trace::add(SPACE, evaluate_space<WHITE>()
884 , evaluate_space<BLACK>());
885 Trace::add(TOTAL, score);
888 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
894 /// evaluate() is the evaluator for the outer world. It returns a static evaluation
895 /// of the position from the point of view of the side to move.
897 Value Eval::evaluate(const Position& pos)
899 return Evaluation<>(pos).value();
902 /// trace() is like evaluate(), but instead of returning a value, it returns
903 /// a string (suitable for outputting to stdout) that contains the detailed
904 /// descriptions and values of each evaluation term. Useful for debugging.
906 std::string Eval::trace(const Position& pos) {
908 std::memset(scores, 0, sizeof(scores));
910 Value v = Evaluation<TRACE>(pos).value();
911 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
913 std::stringstream ss;
914 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
915 << " Eval term | White | Black | Total \n"
916 << " | MG EG | MG EG | MG EG \n"
917 << "----------------+-------------+-------------+-------------\n"
918 << " Material | " << Term(MATERIAL)
919 << " Imbalance | " << Term(IMBALANCE)
920 << " Pawns | " << Term(PAWN)
921 << " Knights | " << Term(KNIGHT)
922 << " Bishops | " << Term(BISHOP)
923 << " Rooks | " << Term(ROOK)
924 << " Queens | " << Term(QUEEN)
925 << " Mobility | " << Term(MOBILITY)
926 << " King safety | " << Term(KING)
927 << " Threats | " << Term(THREAT)
928 << " Passed pawns | " << Term(PASSED)
929 << " Space | " << Term(SPACE)
930 << "----------------+-------------+-------------+-------------\n"
931 << " Total | " << Term(TOTAL);
933 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";