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, 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 == 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 kingOnlyDefended, undefended, 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 // Find the attacked squares which are defended only by our king...
434 kingOnlyDefended = attackedBy[Them][ALL_PIECES]
435 & attackedBy[Us][KING]
438 // ... and those which are not defended at all in the larger king ring
439 undefended = attackedBy[Them][ALL_PIECES]
440 & ~attackedBy[Us][ALL_PIECES]
444 // Initialize the 'kingDanger' variable, which will be transformed
445 // later into a king danger score. The initial value is based on the
446 // number and types of the enemy's attacking pieces, the number of
447 // attacked and weak squares around our king, the absence of queen and
448 // the quality of the pawn shelter (current 'score' value).
449 kingDanger = kingAttackersCount[Them] * kingAttackersWeight[Them]
450 + 102 * kingAdjacentZoneAttacksCount[Them]
451 + 191 * popcount(kingOnlyDefended | undefended)
452 + 143 * !!pos.pinned_pieces(Us)
453 - 848 * !pos.count<QUEEN>(Them)
454 - 9 * mg_value(score) / 8
457 // Analyse the safe enemy's checks which are possible on next move
458 safe = ~pos.pieces(Them);
459 safe &= ~attackedBy[Us][ALL_PIECES] | (kingOnlyDefended & attackedBy2[Them]);
461 b1 = pos.attacks_from< ROOK>(ksq);
462 b2 = pos.attacks_from<BISHOP>(ksq);
464 // Enemy queen safe checks
465 if ((b1 | b2) & attackedBy[Them][QUEEN] & safe)
466 kingDanger += QueenCheck;
468 // For minors and rooks, also consider the square safe if attacked twice,
469 // and only defended by our queen.
470 safe |= attackedBy2[Them]
471 & ~(attackedBy2[Us] | pos.pieces(Them))
472 & attackedBy[Us][QUEEN];
474 // Some other potential checks are also analysed, even from squares
475 // currently occupied by the opponent own pieces, as long as the square
476 // is not attacked by our pawns, and is not occupied by a blocked pawn.
477 other = ~( attackedBy[Us][PAWN]
478 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
480 // Enemy rooks safe and other checks
481 if (b1 & attackedBy[Them][ROOK] & safe)
482 kingDanger += RookCheck;
484 else if (b1 & attackedBy[Them][ROOK] & other)
487 // Enemy bishops safe and other checks
488 if (b2 & attackedBy[Them][BISHOP] & safe)
489 kingDanger += BishopCheck;
491 else if (b2 & attackedBy[Them][BISHOP] & other)
494 // Enemy knights safe and other checks
495 b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
497 kingDanger += KnightCheck;
502 // Transform the kingDanger units into a Score, and substract it from the evaluation
504 score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
507 // King tropism: firstly, find squares that opponent attacks in our king flank
508 File kf = file_of(ksq);
509 b = attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
511 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
512 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
514 // Secondly, add the squares which are attacked twice in that flank and
515 // which are not defended by our pawns.
516 b = (Us == WHITE ? b << 4 : b >> 4)
517 | (b & attackedBy2[Them] & ~attackedBy[Us][PAWN]);
519 score -= CloseEnemies * popcount(b);
521 // Penalty when our king is on a pawnless flank
522 if (!(pos.pieces(PAWN) & KingFlank[kf]))
523 score -= PawnlessFlank;
526 Trace::add(KING, Us, score);
532 // evaluate_threats() assigns bonuses according to the types of the attacking
533 // and the attacked pieces.
535 template<Tracing T> template<Color Us>
536 Score Evaluation<T>::evaluate_threats() {
538 const Color Them = (Us == WHITE ? BLACK : WHITE);
539 const Square Up = (Us == WHITE ? NORTH : SOUTH);
540 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
541 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
542 const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
544 Bitboard b, weak, defended, stronglyProtected, safeThreats;
545 Score score = SCORE_ZERO;
547 // Non-pawn enemies attacked by a pawn
548 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & attackedBy[Us][PAWN];
552 b = pos.pieces(Us, PAWN) & ( ~attackedBy[Them][ALL_PIECES]
553 | attackedBy[Us][ALL_PIECES]);
555 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
557 score += ThreatBySafePawn * popcount(safeThreats);
559 if (weak ^ safeThreats)
560 score += ThreatByHangingPawn;
563 // Squares strongly protected by the opponent, either because they attack the
564 // square with a pawn, or because they attack the square twice and we don't.
565 stronglyProtected = attackedBy[Them][PAWN]
566 | (attackedBy2[Them] & ~attackedBy2[Us]);
568 // Non-pawn enemies, strongly protected
569 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
572 // Enemies not strongly protected and under our attack
573 weak = pos.pieces(Them)
575 & attackedBy[Us][ALL_PIECES];
577 // Add a bonus according to the kind of attacking pieces
580 b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
583 Square s = pop_lsb(&b);
584 score += ThreatByMinor[type_of(pos.piece_on(s))];
585 if (type_of(pos.piece_on(s)) != PAWN)
586 score += ThreatByRank * (int)relative_rank(Them, s);
589 b = (pos.pieces(Them, QUEEN) | weak) & attackedBy[Us][ROOK];
592 Square s = pop_lsb(&b);
593 score += ThreatByRook[type_of(pos.piece_on(s))];
594 if (type_of(pos.piece_on(s)) != PAWN)
595 score += ThreatByRank * (int)relative_rank(Them, s);
598 score += Hanging * popcount(weak & ~attackedBy[Them][ALL_PIECES]);
600 b = weak & attackedBy[Us][KING];
602 score += ThreatByKing[more_than_one(b)];
605 // Bonus for opponent unopposed weak pawns
606 if (pos.pieces(Us, ROOK, QUEEN))
607 score += WeakUnopposedPawn * pe->weak_unopposed(Them);
609 // Find squares where our pawns can push on the next move
610 b = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
611 b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
613 // Keep only the squares which are not completely unsafe
614 b &= ~attackedBy[Them][PAWN]
615 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
617 // Add a bonus for each new pawn threats from those squares
618 b = (shift<Left>(b) | shift<Right>(b))
620 & ~attackedBy[Us][PAWN];
622 score += ThreatByPawnPush * popcount(b);
625 Trace::add(THREAT, Us, score);
631 // evaluate_passed_pawns() evaluates the passed pawns and candidate passed
632 // pawns of the given color.
634 template<Tracing T> template<Color Us>
635 Score Evaluation<T>::evaluate_passed_pawns() {
637 const Color Them = (Us == WHITE ? BLACK : WHITE);
638 const Square Up = (Us == WHITE ? NORTH : SOUTH);
640 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
641 Score score = SCORE_ZERO;
643 b = pe->passed_pawns(Us);
647 Square s = pop_lsb(&b);
649 assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
651 bb = forward_file_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
652 score -= HinderPassedPawn * popcount(bb);
654 int r = relative_rank(Us, s) - RANK_2;
655 int rr = r * (r - 1);
657 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
661 Square blockSq = s + Up;
663 // Adjust bonus based on the king's proximity
664 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
665 - distance(pos.square<KING>( Us), blockSq) * 2 * rr;
667 // If blockSq is not the queening square then consider also a second push
668 if (relative_rank(Us, blockSq) != RANK_8)
669 ebonus -= distance(pos.square<KING>(Us), blockSq + Up) * rr;
671 // If the pawn is free to advance, then increase the bonus
672 if (pos.empty(blockSq))
674 // If there is a rook or queen attacking/defending the pawn from behind,
675 // consider all the squaresToQueen. Otherwise consider only the squares
676 // in the pawn's path attacked or occupied by the enemy.
677 defendedSquares = unsafeSquares = squaresToQueen = forward_file_bb(Us, s);
679 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
681 if (!(pos.pieces(Us) & bb))
682 defendedSquares &= attackedBy[Us][ALL_PIECES];
684 if (!(pos.pieces(Them) & bb))
685 unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
687 // If there aren't any enemy attacks, assign a big bonus. Otherwise
688 // assign a smaller bonus if the block square isn't attacked.
689 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
691 // If the path to the queen is fully defended, assign a big bonus.
692 // Otherwise assign a smaller bonus if the block square is defended.
693 if (defendedSquares == squaresToQueen)
696 else if (defendedSquares & blockSq)
699 mbonus += k * rr, ebonus += k * rr;
701 else if (pos.pieces(Us) & blockSq)
702 mbonus += rr + r * 2, ebonus += rr + r * 2;
705 // Scale down bonus for candidate passers which need more than one
706 // pawn push to become passed or have a pawn in front of them.
707 if (!pos.pawn_passed(Us, s + Up) || (pos.pieces(PAWN) & forward_file_bb(Us, s)))
708 mbonus /= 2, ebonus /= 2;
710 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
714 Trace::add(PASSED, Us, score);
720 // evaluate_space() computes the space evaluation for a given side. The
721 // space evaluation is a simple bonus based on the number of safe squares
722 // available for minor pieces on the central four files on ranks 2--4. Safe
723 // squares one, two or three squares behind a friendly pawn are counted
724 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
725 // improve play on game opening.
727 template<Tracing T> template<Color Us>
728 Score Evaluation<T>::evaluate_space() {
730 const Color Them = (Us == WHITE ? BLACK : WHITE);
731 const Bitboard SpaceMask =
732 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
733 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
735 // Find the safe squares for our pieces inside the area defined by
736 // SpaceMask. A square is unsafe if it is attacked by an enemy
737 // pawn, or if it is undefended and attacked by an enemy piece.
738 Bitboard safe = SpaceMask
739 & ~pos.pieces(Us, PAWN)
740 & ~attackedBy[Them][PAWN]
741 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
743 // Find all squares which are at most three squares behind some friendly pawn
744 Bitboard behind = pos.pieces(Us, PAWN);
745 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
746 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
748 // Since SpaceMask[Us] is fully on our half of the board...
749 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
751 // ...count safe + (behind & safe) with a single popcount.
752 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
753 int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
755 return make_score(bonus * weight * weight / 16, 0);
759 // evaluate_initiative() computes the initiative correction value for the
760 // position, i.e., second order bonus/malus based on the known attacking/defending
761 // status of the players.
764 Score Evaluation<T>::evaluate_initiative(Value eg) {
766 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
767 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
768 bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
770 // Compute the initiative bonus for the attacking side
771 int initiative = 8 * (pe->pawn_asymmetry() + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
773 // Now apply the bonus: note that we find the attacking side by extracting
774 // the sign of the endgame value, and that we carefully cap the bonus so
775 // that the endgame score will never change sign after the bonus.
776 int v = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
778 return make_score(0, v);
782 // evaluate_scale_factor() computes the scale factor for the winning side
785 ScaleFactor Evaluation<T>::evaluate_scale_factor(Value eg) {
787 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
788 ScaleFactor sf = me->scale_factor(pos, strongSide);
790 // If we don't already have an unusual scale factor, check for certain
791 // types of endgames, and use a lower scale for those.
792 if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
794 if (pos.opposite_bishops())
796 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
797 // is almost a draw, in case of KBP vs KB, it is even more a draw.
798 if ( pos.non_pawn_material(WHITE) == BishopValueMg
799 && pos.non_pawn_material(BLACK) == BishopValueMg)
800 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
802 // Endgame with opposite-colored bishops, but also other pieces. Still
803 // a bit drawish, but not as drawish as with only the two bishops.
804 return ScaleFactor(46);
806 // Endings where weaker side can place his king in front of the opponent's
807 // pawns are drawish.
808 else if ( abs(eg) <= BishopValueEg
809 && pos.count<PAWN>(strongSide) <= 2
810 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
811 return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
818 // value() is the main function of the class. It computes the various parts of
819 // the evaluation and returns the value of the position from the point of view
820 // of the side to move.
823 Value Evaluation<T>::value() {
825 assert(!pos.checkers());
827 // Probe the material hash table
828 me = Material::probe(pos);
830 // If we have a specialized evaluation function for the current material
831 // configuration, call it and return.
832 if (me->specialized_eval_exists())
833 return me->evaluate(pos);
835 // Initialize score by reading the incrementally updated scores included in
836 // the position object (material + piece square tables) and the material
837 // imbalance. Score is computed internally from the white point of view.
838 Score score = pos.psq_score() + me->imbalance();
840 // Probe the pawn hash table
841 pe = Pawns::probe(pos);
842 score += pe->pawns_score();
844 // Early exit if score is high
845 Value v = (mg_value(score) + eg_value(score)) / 2;
846 if (abs(v) > LazyThreshold)
847 return pos.side_to_move() == WHITE ? v : -v;
849 // Main evaluation begins here
854 score += evaluate_pieces<WHITE, KNIGHT>() - evaluate_pieces<BLACK, KNIGHT>();
855 score += evaluate_pieces<WHITE, BISHOP>() - evaluate_pieces<BLACK, BISHOP>();
856 score += evaluate_pieces<WHITE, ROOK >() - evaluate_pieces<BLACK, ROOK >();
857 score += evaluate_pieces<WHITE, QUEEN >() - evaluate_pieces<BLACK, QUEEN >();
859 score += mobility[WHITE] - mobility[BLACK];
861 score += evaluate_king<WHITE>()
862 - evaluate_king<BLACK>();
864 score += evaluate_threats<WHITE>()
865 - evaluate_threats<BLACK>();
867 score += evaluate_passed_pawns<WHITE>()
868 - evaluate_passed_pawns<BLACK>();
870 if (pos.non_pawn_material() >= SpaceThreshold)
871 score += evaluate_space<WHITE>()
872 - evaluate_space<BLACK>();
874 score += evaluate_initiative(eg_value(score));
876 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
877 ScaleFactor sf = evaluate_scale_factor(eg_value(score));
878 v = mg_value(score) * int(me->game_phase())
879 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
881 v /= int(PHASE_MIDGAME);
883 // In case of tracing add all remaining individual evaluation terms
886 Trace::add(MATERIAL, pos.psq_score());
887 Trace::add(IMBALANCE, me->imbalance());
888 Trace::add(PAWN, pe->pawns_score());
889 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
890 if (pos.non_pawn_material() >= SpaceThreshold)
891 Trace::add(SPACE, evaluate_space<WHITE>()
892 , evaluate_space<BLACK>());
893 Trace::add(TOTAL, score);
896 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
902 /// evaluate() is the evaluator for the outer world. It returns a static evaluation
903 /// of the position from the point of view of the side to move.
905 Value Eval::evaluate(const Position& pos)
907 return Evaluation<>(pos).value();
910 /// trace() is like evaluate(), but instead of returning a value, it returns
911 /// a string (suitable for outputting to stdout) that contains the detailed
912 /// descriptions and values of each evaluation term. Useful for debugging.
914 std::string Eval::trace(const Position& pos) {
916 std::memset(scores, 0, sizeof(scores));
918 Value v = Evaluation<TRACE>(pos).value();
919 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
921 std::stringstream ss;
922 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
923 << " Eval term | White | Black | Total \n"
924 << " | MG EG | MG EG | MG EG \n"
925 << "----------------+-------------+-------------+-------------\n"
926 << " Material | " << Term(MATERIAL)
927 << " Imbalance | " << Term(IMBALANCE)
928 << " Pawns | " << Term(PAWN)
929 << " Knights | " << Term(KNIGHT)
930 << " Bishops | " << Term(BISHOP)
931 << " Rooks | " << Term(ROOK)
932 << " Queens | " << Term(QUEEN)
933 << " Mobility | " << Term(MOBILITY)
934 << " King safety | " << Term(KING)
935 << " Threats | " << Term(THREAT)
936 << " Passed pawns | " << Term(PASSED)
937 << " Space | " << Term(SPACE)
938 << "----------------+-------------+-------------+-------------\n"
939 << " Total | " << Term(TOTAL);
941 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";