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-2018 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 int king_distance(Color c, Square s);
101 template<Color Us> Score evaluate_passed_pawns();
102 template<Color Us> Score evaluate_space();
103 template<Color Us, PieceType Pt> Score evaluate_pieces();
104 ScaleFactor evaluate_scale_factor(Value eg);
105 Score evaluate_initiative(Value eg);
111 Bitboard mobilityArea[COLOR_NB];
112 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
114 // attackedBy[color][piece type] is a bitboard representing all squares
115 // attacked by a given color and piece type. Special "piece types" which are
116 // also calculated are QUEEN_DIAGONAL and ALL_PIECES.
117 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
119 // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
120 // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
121 // pawn or squares attacked by 2 pawns are not explicitly added.
122 Bitboard attackedBy2[COLOR_NB];
124 // kingRing[color] is the zone around the king which is considered
125 // by the king safety evaluation. This consists of the squares directly
126 // adjacent to the king, and (only for a king on its first rank) the
127 // squares two ranks in front of the king. For instance, if black's king
128 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
129 // f7, g7, h7, f6, g6 and h6.
130 Bitboard kingRing[COLOR_NB];
132 // kingAttackersCount[color] is the number of pieces of the given color
133 // which attack a square in the kingRing of the enemy king.
134 int kingAttackersCount[COLOR_NB];
136 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
137 // given color which attack a square in the kingRing of the enemy king. The
138 // weights of the individual piece types are given by the elements in the
139 // KingAttackWeights array.
140 int kingAttackersWeight[COLOR_NB];
142 // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
143 // color to squares directly adjacent to the enemy king. Pieces which attack
144 // more than one square are counted multiple times. For instance, if there is
145 // a white knight on g5 and black's king is on g8, this white knight adds 2
146 // to kingAdjacentZoneAttacksCount[WHITE].
147 int kingAdjacentZoneAttacksCount[COLOR_NB];
150 #define V(v) Value(v)
151 #define S(mg, eg) make_score(mg, eg)
153 // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
154 // indexed by piece type and number of attacked squares in the mobility area.
155 const Score MobilityBonus[][32] = {
156 { S(-75,-76), S(-57,-54), S( -9,-28), S( -2,-10), S( 6, 5), S( 14, 12), // Knights
157 S( 22, 26), S( 29, 29), S( 36, 29) },
158 { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
159 S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
160 S( 91, 88), S( 98, 97) },
161 { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
162 S( 9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
163 S( 46,166), S( 48,169), S( 58,171) },
164 { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens
165 S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
166 S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
167 S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
168 S(106,184), S(109,191), S(113,206), S(116,212) }
171 // Outpost[knight/bishop][supported by pawn] contains bonuses for minor
172 // pieces if they can reach an outpost square, bigger if that square is
173 // supported by a pawn. If the minor piece occupies an outpost square
174 // then score is doubled.
175 const Score Outpost[][2] = {
176 { S(22, 6), S(36,12) }, // Knight
177 { S( 9, 2), S(15, 5) } // Bishop
180 // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
181 // friendly pawn on the rook file.
182 const Score RookOnFile[] = { S(20, 7), S(45, 20) };
184 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
185 // which piece type attacks which one. Attacks on lesser pieces which are
186 // pawn-defended are not considered.
187 const Score ThreatByMinor[PIECE_TYPE_NB] = {
188 S(0, 0), S(0, 31), S(39, 42), S(57, 44), S(68, 112), S(47, 120)
191 const Score ThreatByRook[PIECE_TYPE_NB] = {
192 S(0, 0), S(0, 24), S(38, 71), S(38, 61), S(0, 38), S(36, 38)
195 // ThreatByKing[on one/on many] contains bonuses for king attacks on
196 // pawns or pieces which are not pawn-defended.
197 const Score ThreatByKing[] = { S(3, 65), S(9, 145) };
199 // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
200 // We don't use a Score because we process the two components independently.
201 const Value Passed[][RANK_NB] = {
202 { V(0), V(5), V( 5), V(32), V(70), V(172), V(217) },
203 { V(0), V(7), V(13), V(42), V(70), V(170), V(269) }
206 // PassedFile[File] contains a bonus according to the file of a passed pawn
207 const Score PassedFile[FILE_NB] = {
208 S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
209 S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
212 // Rank factor applied on some bonus for passed pawn on rank 4 or beyond
213 const int RankFactor[RANK_NB] = {0, 0, 0, 2, 7, 12, 19};
215 // KingProtector[PieceType-2] contains a bonus according to distance from king
216 const Score KingProtector[] = { S(-3, -5), S(-4, -3), S(-3, 0), S(-1, 1) };
218 // Assorted bonuses and penalties used by evaluation
219 const Score MinorBehindPawn = S( 16, 0);
220 const Score BishopPawns = S( 8, 12);
221 const Score LongRangedBishop = S( 22, 0);
222 const Score RookOnPawn = S( 8, 24);
223 const Score TrappedRook = S( 92, 0);
224 const Score WeakQueen = S( 50, 10);
225 const Score CloseEnemies = S( 7, 0);
226 const Score PawnlessFlank = S( 20, 80);
227 const Score ThreatBySafePawn = S(175,168);
228 const Score ThreatByRank = S( 16, 3);
229 const Score Hanging = S( 52, 30);
230 const Score WeakUnopposedPawn = S( 5, 25);
231 const Score ThreatByPawnPush = S( 47, 26);
232 const Score ThreatByAttackOnQueen = S( 42, 21);
233 const Score HinderPassedPawn = S( 8, 1);
234 const Score TrappedBishopA1H1 = S( 50, 50);
239 // KingAttackWeights[PieceType] contains king attack weights by piece type
240 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
242 // Penalties for enemy's safe checks
243 const int QueenSafeCheck = 780;
244 const int RookSafeCheck = 880;
245 const int BishopSafeCheck = 435;
246 const int KnightSafeCheck = 790;
248 // Threshold for lazy and space evaluation
249 const Value LazyThreshold = Value(1500);
250 const Value SpaceThreshold = Value(12222);
253 // initialize() computes king and pawn attacks, and the king ring bitboard
254 // for a given color. This is done at the beginning of the evaluation.
256 template<Tracing T> template<Color Us>
257 void Evaluation<T>::initialize() {
259 const Color Them = (Us == WHITE ? BLACK : WHITE);
260 const Direction Up = (Us == WHITE ? NORTH : SOUTH);
261 const Direction Down = (Us == WHITE ? SOUTH : NORTH);
262 const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
264 // Find our pawns on the first two ranks, and those which are blocked
265 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
267 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
268 // are excluded from the mobility area.
269 mobilityArea[Us] = ~(b | pos.square<KING>(Us) | pe->pawn_attacks(Them));
271 // Initialise the attack bitboards with the king and pawn information
272 b = attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
273 attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
275 attackedBy2[Us] = b & attackedBy[Us][PAWN];
276 attackedBy[Us][ALL_PIECES] = b | attackedBy[Us][PAWN];
278 // Init our king safety tables only if we are going to use them
279 if (pos.non_pawn_material(Them) >= RookValueMg + KnightValueMg)
282 if (relative_rank(Us, pos.square<KING>(Us)) == RANK_1)
283 kingRing[Us] |= shift<Up>(b);
285 kingAttackersCount[Them] = popcount(b & pe->pawn_attacks(Them));
286 kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
289 kingRing[Us] = kingAttackersCount[Them] = 0;
293 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
296 template<Tracing T> template<Color Us, PieceType Pt>
297 Score Evaluation<T>::evaluate_pieces() {
299 const Color Them = (Us == WHITE ? BLACK : WHITE);
300 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
301 : Rank5BB | Rank4BB | Rank3BB);
302 const Square* pl = pos.squares<Pt>(Us);
306 Score score = SCORE_ZERO;
308 attackedBy[Us][Pt] = 0;
311 attackedBy[Us][QUEEN_DIAGONAL] = 0;
313 while ((s = *pl++) != SQ_NONE)
315 // Find attacked squares, including x-ray attacks for bishops and rooks
316 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
317 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
318 : pos.attacks_from<Pt>(s);
320 if (pos.pinned_pieces(Us) & s)
321 b &= LineBB[pos.square<KING>(Us)][s];
323 attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
324 attackedBy[Us][ALL_PIECES] |= attackedBy[Us][Pt] |= b;
327 attackedBy[Us][QUEEN_DIAGONAL] |= b & PseudoAttacks[BISHOP][s];
329 if (b & kingRing[Them])
331 kingAttackersCount[Us]++;
332 kingAttackersWeight[Us] += KingAttackWeights[Pt];
333 kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
336 int mob = popcount(b & mobilityArea[Us]);
338 mobility[Us] += MobilityBonus[Pt - 2][mob];
340 // Bonus for this piece as a king protector
341 score += KingProtector[Pt - 2] * distance(s, pos.square<KING>(Us));
343 if (Pt == BISHOP || Pt == KNIGHT)
345 // Bonus for outpost squares
346 bb = OutpostRanks & ~pe->pawn_attacks_span(Them);
348 score += Outpost[Pt == BISHOP][bool(attackedBy[Us][PAWN] & s)] * 2;
351 bb &= b & ~pos.pieces(Us);
353 score += Outpost[Pt == BISHOP][bool(attackedBy[Us][PAWN] & bb)];
356 // Bonus when behind a pawn
357 if ( relative_rank(Us, s) < RANK_5
358 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
359 score += MinorBehindPawn;
363 // Penalty for pawns on the same color square as the bishop
364 score -= BishopPawns * pe->pawns_on_same_color_squares(Us, s);
366 // Bonus for bishop on a long diagonal which can "see" both center squares
367 if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))
368 score += LongRangedBishop;
371 // An important Chess960 pattern: A cornered bishop blocked by a friendly
372 // pawn diagonally in front of it is a very serious problem, especially
373 // when that pawn is also blocked.
376 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
378 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
379 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
380 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
381 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
388 // Bonus for aligning with enemy pawns on the same rank/file
389 if (relative_rank(Us, s) >= RANK_5)
390 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
392 // Bonus when on an open or semi-open file
393 if (pe->semiopen_file(Us, file_of(s)))
394 score += RookOnFile[bool(pe->semiopen_file(Them, file_of(s)))];
396 // Penalty when trapped by the king, even more if the king cannot castle
399 Square ksq = pos.square<KING>(Us);
401 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
402 && !pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
403 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
409 // Penalty if any relative pin or discovered attack against the queen
411 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
417 Trace::add(Pt, Us, score);
423 // evaluate_king() assigns bonuses and penalties to a king of a given color
425 template<Tracing T> template<Color Us>
426 Score Evaluation<T>::evaluate_king() {
428 const Color Them = (Us == WHITE ? BLACK : WHITE);
429 const Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
430 : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
432 const Square ksq = pos.square<KING>(Us);
433 Bitboard weak, b, b1, b2, safe, unsafeChecks;
435 // King shelter and enemy pawns storm
436 Score score = pe->king_safety<Us>(pos, ksq);
438 // Main king safety evaluation
439 if (kingAttackersCount[Them] > (1 - pos.count<QUEEN>(Them)))
441 // Attacked squares defended at most once by our queen or king
442 weak = attackedBy[Them][ALL_PIECES]
444 & (attackedBy[Us][KING] | attackedBy[Us][QUEEN] | ~attackedBy[Us][ALL_PIECES]);
446 int kingDanger = unsafeChecks = 0;
448 // Analyse the safe enemy's checks which are possible on next move
449 safe = ~pos.pieces(Them);
450 safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
452 b1 = attacks_bb<ROOK >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
453 b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
455 // Enemy queen safe checks
456 if ((b1 | b2) & attackedBy[Them][QUEEN] & safe & ~attackedBy[Us][QUEEN])
457 kingDanger += QueenSafeCheck;
459 b1 &= attackedBy[Them][ROOK];
460 b2 &= attackedBy[Them][BISHOP];
462 // Enemy rooks checks
464 kingDanger += RookSafeCheck;
468 // Enemy bishops checks
470 kingDanger += BishopSafeCheck;
474 // Enemy knights checks
475 b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
477 kingDanger += KnightSafeCheck;
481 // Unsafe or occupied checking squares will also be considered, as long as
482 // the square is in the attacker's mobility area.
483 unsafeChecks &= mobilityArea[Them];
485 kingDanger += kingAttackersCount[Them] * kingAttackersWeight[Them]
486 + 102 * kingAdjacentZoneAttacksCount[Them]
487 + 191 * popcount(kingRing[Us] & weak)
488 + 143 * popcount(pos.pinned_pieces(Us) | unsafeChecks)
489 - 848 * !pos.count<QUEEN>(Them)
490 - 9 * mg_value(score) / 8
493 // Transform the kingDanger units into a Score, and subtract it from the evaluation
496 int mobilityDanger = mg_value(mobility[Them] - mobility[Us]);
497 kingDanger = std::max(0, kingDanger + mobilityDanger);
498 score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
502 // King tropism: firstly, find squares that opponent attacks in our king flank
503 File kf = file_of(ksq);
504 b = attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
506 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
507 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
509 // Secondly, add the squares which are attacked twice in that flank and
510 // which are not defended by our pawns.
511 b = (Us == WHITE ? b << 4 : b >> 4)
512 | (b & attackedBy2[Them] & ~attackedBy[Us][PAWN]);
514 score -= CloseEnemies * popcount(b);
516 // Penalty when our king is on a pawnless flank
517 if (!(pos.pieces(PAWN) & KingFlank[kf]))
518 score -= PawnlessFlank;
521 Trace::add(KING, Us, score);
527 // evaluate_threats() assigns bonuses according to the types of the attacking
528 // and the attacked pieces.
530 template<Tracing T> template<Color Us>
531 Score Evaluation<T>::evaluate_threats() {
533 const Color Them = (Us == WHITE ? BLACK : WHITE);
534 const Direction Up = (Us == WHITE ? NORTH : SOUTH);
535 const Direction Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
536 const Direction Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
537 const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
539 Bitboard b, weak, defended, stronglyProtected, safeThreats;
540 Score score = SCORE_ZERO;
542 // Non-pawn enemies attacked by a pawn
543 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & attackedBy[Us][PAWN];
547 b = pos.pieces(Us, PAWN) & ( ~attackedBy[Them][ALL_PIECES]
548 | attackedBy[Us][ALL_PIECES]);
550 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
552 score += ThreatBySafePawn * popcount(safeThreats);
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);
616 // Add a bonus for safe slider attack threats on opponent queen
617 safeThreats = ~pos.pieces(Us) & ~attackedBy2[Them] & attackedBy2[Us];
618 b = (attackedBy[Us][BISHOP] & attackedBy[Them][QUEEN_DIAGONAL])
619 | (attackedBy[Us][ROOK ] & attackedBy[Them][QUEEN] & ~attackedBy[Them][QUEEN_DIAGONAL]);
621 score += ThreatByAttackOnQueen * popcount(b & safeThreats);
624 Trace::add(THREAT, Us, score);
629 // king_distance() returns an estimate of the distance that the king
630 // of the given color has to run to reach square s.
632 int Evaluation<T>::king_distance(Color c, Square s) {
633 return std::min(distance(pos.square<KING>(c), s), 5);
636 // evaluate_passed_pawns() evaluates the passed pawns and candidate passed
637 // pawns of the given color.
639 template<Tracing T> template<Color Us>
640 Score Evaluation<T>::evaluate_passed_pawns() {
642 const Color Them = (Us == WHITE ? BLACK : WHITE);
643 const Direction Up = (Us == WHITE ? NORTH : SOUTH);
645 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
646 Score score = SCORE_ZERO;
648 b = pe->passed_pawns(Us);
652 Square s = pop_lsb(&b);
654 assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
656 bb = forward_file_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
657 score -= HinderPassedPawn * popcount(bb);
659 int r = relative_rank(Us, s);
660 int rr = RankFactor[r];
662 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
666 Square blockSq = s + Up;
668 // Adjust bonus based on the king's proximity
669 ebonus += (king_distance(Them, blockSq) * 5 - king_distance(Us, blockSq) * 2) * rr;
671 // If blockSq is not the queening square then consider also a second push
673 ebonus -= king_distance(Us, blockSq + Up) * rr;
675 // If the pawn is free to advance, then increase the bonus
676 if (pos.empty(blockSq))
678 // If there is a rook or queen attacking/defending the pawn from behind,
679 // consider all the squaresToQueen. Otherwise consider only the squares
680 // in the pawn's path attacked or occupied by the enemy.
681 defendedSquares = unsafeSquares = squaresToQueen = forward_file_bb(Us, s);
683 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
685 if (!(pos.pieces(Us) & bb))
686 defendedSquares &= attackedBy[Us][ALL_PIECES];
688 if (!(pos.pieces(Them) & bb))
689 unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
691 // If there aren't any enemy attacks, assign a big bonus. Otherwise
692 // assign a smaller bonus if the block square isn't attacked.
693 int k = !unsafeSquares ? 20 : !(unsafeSquares & blockSq) ? 9 : 0;
695 // If the path to the queen is fully defended, assign a big bonus.
696 // Otherwise assign a smaller bonus if the block square is defended.
697 if (defendedSquares == squaresToQueen)
700 else if (defendedSquares & blockSq)
703 mbonus += k * rr, ebonus += k * rr;
705 else if (pos.pieces(Us) & blockSq)
706 mbonus += rr + r * 2, ebonus += rr + r * 2;
709 // Scale down bonus for candidate passers which need more than one
710 // pawn push to become passed or have a pawn in front of them.
711 if (!pos.pawn_passed(Us, s + Up) || (pos.pieces(PAWN) & forward_file_bb(Us, s)))
712 mbonus /= 2, ebonus /= 2;
714 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
718 Trace::add(PASSED, Us, score);
724 // evaluate_space() computes the space evaluation for a given side. The
725 // space evaluation is a simple bonus based on the number of safe squares
726 // available for minor pieces on the central four files on ranks 2--4. Safe
727 // squares one, two or three squares behind a friendly pawn are counted
728 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
729 // improve play on game opening.
731 template<Tracing T> template<Color Us>
732 Score Evaluation<T>::evaluate_space() {
734 const Color Them = (Us == WHITE ? BLACK : WHITE);
735 const Bitboard SpaceMask =
736 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
737 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
739 // Find the safe squares for our pieces inside the area defined by
740 // SpaceMask. A square is unsafe if it is attacked by an enemy
741 // pawn, or if it is undefended and attacked by an enemy piece.
742 Bitboard safe = SpaceMask
743 & ~pos.pieces(Us, PAWN)
744 & ~attackedBy[Them][PAWN]
745 & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
747 // Find all squares which are at most three squares behind some friendly pawn
748 Bitboard behind = pos.pieces(Us, PAWN);
749 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
750 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
752 // Since SpaceMask[Us] is fully on our half of the board...
753 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
755 // ...count safe + (behind & safe) with a single popcount.
756 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
757 int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
759 return make_score(bonus * weight * weight / 16, 0);
763 // evaluate_initiative() computes the initiative correction value for the
764 // position, i.e., second order bonus/malus based on the known attacking/defending
765 // status of the players.
768 Score Evaluation<T>::evaluate_initiative(Value eg) {
770 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
771 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
772 bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
774 // Compute the initiative bonus for the attacking side
775 int initiative = 8 * (pe->pawn_asymmetry() + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
777 // Now apply the bonus: note that we find the attacking side by extracting
778 // the sign of the endgame value, and that we carefully cap the bonus so
779 // that the endgame score will never change sign after the bonus.
780 int v = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
783 Trace::add(INITIATIVE, make_score(0, v));
785 return make_score(0, v);
789 // evaluate_scale_factor() computes the scale factor for the winning side
792 ScaleFactor Evaluation<T>::evaluate_scale_factor(Value eg) {
794 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
795 ScaleFactor sf = me->scale_factor(pos, strongSide);
797 // If we don't already have an unusual scale factor, check for certain
798 // types of endgames, and use a lower scale for those.
799 if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
801 if (pos.opposite_bishops())
803 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
804 // is almost a draw, in case of KBP vs KB, it is even more a draw.
805 if ( pos.non_pawn_material(WHITE) == BishopValueMg
806 && pos.non_pawn_material(BLACK) == BishopValueMg)
807 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
809 // Endgame with opposite-colored bishops, but also other pieces. Still
810 // a bit drawish, but not as drawish as with only the two bishops.
811 return ScaleFactor(46);
813 // Endings where weaker side can place his king in front of the opponent's
814 // pawns are drawish.
815 else if ( abs(eg) <= BishopValueEg
816 && pos.count<PAWN>(strongSide) <= 2
817 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
818 return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
825 // value() is the main function of the class. It computes the various parts of
826 // the evaluation and returns the value of the position from the point of view
827 // of the side to move.
830 Value Evaluation<T>::value() {
832 assert(!pos.checkers());
834 // Probe the material hash table
835 me = Material::probe(pos);
837 // If we have a specialized evaluation function for the current material
838 // configuration, call it and return.
839 if (me->specialized_eval_exists())
840 return me->evaluate(pos);
842 // Initialize score by reading the incrementally updated scores included in
843 // the position object (material + piece square tables) and the material
844 // imbalance. Score is computed internally from the white point of view.
845 Score score = pos.psq_score() + me->imbalance() + Eval::Contempt;
847 // Probe the pawn hash table
848 pe = Pawns::probe(pos);
849 score += pe->pawns_score();
851 // Early exit if score is high
852 Value v = (mg_value(score) + eg_value(score)) / 2;
853 if (abs(v) > LazyThreshold)
854 return pos.side_to_move() == WHITE ? v : -v;
856 // Main evaluation begins here
861 score += evaluate_pieces<WHITE, KNIGHT>() - evaluate_pieces<BLACK, KNIGHT>();
862 score += evaluate_pieces<WHITE, BISHOP>() - evaluate_pieces<BLACK, BISHOP>();
863 score += evaluate_pieces<WHITE, ROOK >() - evaluate_pieces<BLACK, ROOK >();
864 score += evaluate_pieces<WHITE, QUEEN >() - evaluate_pieces<BLACK, QUEEN >();
866 score += mobility[WHITE] - mobility[BLACK];
868 score += evaluate_king<WHITE>()
869 - evaluate_king<BLACK>();
871 score += evaluate_threats<WHITE>()
872 - evaluate_threats<BLACK>();
874 score += evaluate_passed_pawns<WHITE>()
875 - evaluate_passed_pawns<BLACK>();
877 if (pos.non_pawn_material() >= SpaceThreshold)
878 score += evaluate_space<WHITE>()
879 - evaluate_space<BLACK>();
881 score += evaluate_initiative(eg_value(score));
883 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
884 ScaleFactor sf = evaluate_scale_factor(eg_value(score));
885 v = mg_value(score) * int(me->game_phase())
886 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
888 v /= int(PHASE_MIDGAME);
890 // In case of tracing add all remaining individual evaluation terms
893 Trace::add(MATERIAL, pos.psq_score());
894 Trace::add(IMBALANCE, me->imbalance());
895 Trace::add(PAWN, pe->pawns_score());
896 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
897 if (pos.non_pawn_material() >= SpaceThreshold)
898 Trace::add(SPACE, evaluate_space<WHITE>()
899 , evaluate_space<BLACK>());
900 Trace::add(TOTAL, score);
903 return pos.side_to_move() == WHITE ? v : -v; // Side to move point of view
908 Score Eval::Contempt = SCORE_ZERO;
910 /// evaluate() is the evaluator for the outer world. It returns a static evaluation
911 /// of the position from the point of view of the side to move.
913 Value Eval::evaluate(const Position& pos)
915 return Evaluation<>(pos).value() + Eval::Tempo;
918 /// trace() is like evaluate(), but instead of returning a value, it returns
919 /// a string (suitable for outputting to stdout) that contains the detailed
920 /// descriptions and values of each evaluation term. Useful for debugging.
922 std::string Eval::trace(const Position& pos) {
924 std::memset(scores, 0, sizeof(scores));
926 Eval::Contempt = SCORE_ZERO;
928 Value v = Eval::Tempo + Evaluation<TRACE>(pos).value();
930 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
932 std::stringstream ss;
933 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
934 << " Eval term | White | Black | Total \n"
935 << " | MG EG | MG EG | MG EG \n"
936 << "----------------+-------------+-------------+-------------\n"
937 << " Material | " << Term(MATERIAL)
938 << " Imbalance | " << Term(IMBALANCE)
939 << " Pawns | " << Term(PAWN)
940 << " Knights | " << Term(KNIGHT)
941 << " Bishops | " << Term(BISHOP)
942 << " Rooks | " << Term(ROOK)
943 << " Queens | " << Term(QUEEN)
944 << " Mobility | " << Term(MOBILITY)
945 << " King safety | " << Term(KING)
946 << " Threats | " << Term(THREAT)
947 << " Passed pawns | " << Term(PASSED)
948 << " Space | " << Term(SPACE)
949 << " Initiative | " << Term(INITIATIVE)
950 << "----------------+-------------+-------------+-------------\n"
951 << " Total | " << Term(TOTAL);
953 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";