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
6 Stockfish is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 Stockfish is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include <cstring> // For std::memset
35 enum Term { // First 8 entries are for PieceType
36 MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
39 double scores[TERM_NB][COLOR_NB][PHASE_NB];
41 double to_cp(Value v) { return double(v) / PawnValueEg; }
43 void add(int idx, Color c, Score s) {
44 scores[idx][c][MG] = to_cp(mg_value(s));
45 scores[idx][c][EG] = to_cp(eg_value(s));
48 void add(int idx, Score w, Score b = SCORE_ZERO) {
49 add(idx, WHITE, w); add(idx, BLACK, b);
52 std::ostream& operator<<(std::ostream& os, Term t) {
54 if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL)
55 os << " --- --- | --- --- | ";
57 os << std::setw(5) << scores[t][WHITE][MG] << " "
58 << std::setw(5) << scores[t][WHITE][EG] << " | "
59 << std::setw(5) << scores[t][BLACK][MG] << " "
60 << std::setw(5) << scores[t][BLACK][EG] << " | ";
62 os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
63 << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
69 using namespace Trace;
71 // Struct EvalInfo contains various information computed and collected
72 // by the evaluation functions.
75 // attackedBy[color][piece type] is a bitboard representing all squares
76 // attacked by a given color and piece type (can be also ALL_PIECES).
77 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
79 // kingRing[color] is the zone around the king which is considered
80 // by the king safety evaluation. This consists of the squares directly
81 // adjacent to the king, and the three (or two, for a king on an edge file)
82 // squares two ranks in front of the king. For instance, if black's king
83 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
84 // f7, g7, h7, f6, g6 and h6.
85 Bitboard kingRing[COLOR_NB];
87 // kingAttackersCount[color] is the number of pieces of the given color
88 // which attack a square in the kingRing of the enemy king.
89 int kingAttackersCount[COLOR_NB];
91 // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
92 // given color which attack a square in the kingRing of the enemy king. The
93 // weights of the individual piece types are given by the elements in the
94 // KingAttackWeights array.
95 int kingAttackersWeight[COLOR_NB];
97 // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
98 // color to squares directly adjacent to the enemy king. Pieces which attack
99 // more than one square are counted multiple times. For instance, if there is
100 // a white knight on g5 and black's king is on g8, this white knight adds 2
101 // to kingAdjacentZoneAttacksCount[WHITE].
102 int kingAdjacentZoneAttacksCount[COLOR_NB];
104 Bitboard pinnedPieces[COLOR_NB];
109 // Evaluation weights, indexed by the corresponding evaluation term
110 enum { Mobility, PawnStructure, PassedPawns, Space, KingSafety };
112 const struct Weight { int mg, eg; } Weights[] = {
113 {289, 344}, {233, 201}, {221, 273}, {46, 0}, {322, 0}
116 Score operator*(Score s, const Weight& w) {
117 return make_score(mg_value(s) * w.mg / 256, eg_value(s) * w.eg / 256);
121 #define V(v) Value(v)
122 #define S(mg, eg) make_score(mg, eg)
124 // MobilityBonus[PieceType][attacked] contains bonuses for middle and end
125 // game, indexed by piece type and number of attacked squares not occupied by
127 const Score MobilityBonus[][32] = {
129 { S(-68,-49), S(-46,-33), S(-3,-12), S( 5, -4), S( 9, 11), S(15, 16), // Knights
130 S( 23, 27), S( 33, 28), S(37, 29) },
131 { S(-49,-44), S(-23,-16), S(16, 1), S(29, 16), S(40, 25), S(51, 34), // Bishops
132 S( 55, 43), S( 61, 49), S(64, 51), S(68, 52), S(73, 55), S(75, 60),
133 S( 80, 65), S( 86, 66) },
134 { S(-50,-57), S(-28,-22), S(-11, 7), S(-1, 29), S( 0, 39), S( 1, 46), // Rooks
135 S( 10, 66), S( 16, 79), S(22, 86), S(23,103), S(30,109), S(33,111),
136 S( 37,115), S( 38,119), S(48,124) },
137 { S(-43,-30), S(-27,-15), S( 1, -5), S( 2, -3), S(14, 10), S(18, 24), // Queens
138 S( 20, 27), S( 33, 37), S(33, 38), S(34, 43), S(40, 46), S(43, 56),
139 S( 46, 61), S( 52, 63), S(52, 63), S(57, 65), S(60, 70), S(61, 74),
140 S( 67, 80), S( 76, 82), S(77, 88), S(82, 94), S(86, 95), S(90, 96),
141 S( 94, 99), S( 96,100), S(99,111), S(99,112) }
144 // Outpost[knight/bishop][supported by pawn] contains bonuses for knights and
145 // bishops outposts, bigger if outpost piece is supported by a pawn.
146 const Score Outpost[][2] = {
147 { S(42,11), S(63,17) }, // Knights
148 { S(18, 5), S(27, 8) } // Bishops
151 // Threat[defended/weak][minor/major attacking][attacked PieceType] contains
152 // bonuses according to which piece type attacks which one.
153 const Score Threat[][2][PIECE_TYPE_NB] = {
154 { { S(0, 0), S( 0, 0), S(19, 37), S(24, 37), S(44, 97), S(35,106) }, // Defended Minor
155 { S(0, 0), S( 0, 0), S( 9, 14), S( 9, 14), S( 7, 14), S(24, 48) } }, // Defended Major
156 { { S(0, 0), S( 0,32), S(33, 41), S(31, 50), S(41,100), S(35,104) }, // Weak Minor
157 { S(0, 0), S( 0,27), S(26, 57), S(26, 57), S(0 , 43), S(23, 51) } } // Weak Major
160 // ThreatenedByPawn[PieceType] contains a penalty according to which piece
161 // type is attacked by an enemy pawn.
162 const Score ThreatenedByPawn[PIECE_TYPE_NB] = {
163 S(0, 0), S(0, 0), S(107, 138), S(84, 122), S(114, 203), S(121, 217)
166 // Passed[mg/eg][rank] contains midgame and endgame bonuses for passed pawns.
167 // We don't use a Score because we process the two components independently.
168 const Value Passed[][RANK_NB] = {
169 { V(0), V( 1), V(34), V(90), V(214), V(328) },
170 { V(7), V(14), V(37), V(63), V(134), V(189) }
173 // PassedFile[File] contains a bonus according to the file of a passed pawn.
174 const Score PassedFile[] = {
175 S( 14, 13), S( 2, 5), S(-3, -4), S(-19, -14),
176 S(-19, -14), S(-3, -4), S( 2, 5), S( 14, 13)
179 const Score ThreatenedByHangingPawn = S(40, 60);
181 // Assorted bonuses and penalties used by evaluation
182 const Score KingOnOne = S( 2, 58);
183 const Score KingOnMany = S( 6,125);
184 const Score RookOnPawn = S( 7, 27);
185 const Score RookOnOpenFile = S(43, 21);
186 const Score RookOnSemiOpenFile = S(19, 10);
187 const Score BishopPawns = S( 8, 12);
188 const Score MinorBehindPawn = S(16, 0);
189 const Score TrappedRook = S(92, 0);
190 const Score Unstoppable = S( 0, 20);
191 const Score Hanging = S(31, 26);
192 const Score PawnAttackThreat = S(20, 20);
193 const Score Checked = S(20, 20);
195 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
196 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
197 // happen in Chess960 games.
198 const Score TrappedBishopA1H1 = S(50, 50);
203 // SpaceMask[Color] contains the area of the board which is considered
204 // by the space evaluation. In the middlegame, each side is given a bonus
205 // based on how many squares inside this area are safe and available for
206 // friendly minor pieces.
207 const Bitboard SpaceMask[COLOR_NB] = {
208 (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
209 (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
212 // King danger constants and variables. The king danger scores are looked-up
213 // in KingDanger[]. Various little "meta-bonuses" measuring the strength
214 // of the enemy attack are added up into an integer, which is used as an
215 // index to KingDanger[].
216 Score KingDanger[512];
218 // KingAttackWeights[PieceType] contains king attack weights by piece type
219 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 7, 5, 4, 1 };
221 // Penalties for enemy's safe checks
222 const int QueenContactCheck = 89;
223 const int RookContactCheck = 71;
224 const int QueenCheck = 50;
225 const int RookCheck = 37;
226 const int BishopCheck = 6;
227 const int KnightCheck = 14;
230 // init_eval_info() initializes king bitboards for given color adding
231 // pawn attacks. To be done at the beginning of the evaluation.
234 void init_eval_info(const Position& pos, EvalInfo& ei) {
236 const Color Them = (Us == WHITE ? BLACK : WHITE);
237 const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
239 ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
240 Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.square<KING>(Them));
241 ei.attackedBy[Them][ALL_PIECES] |= b;
242 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
244 // Init king safety tables only if we are going to use them
245 if (pos.non_pawn_material(Us) >= QueenValueMg)
247 ei.kingRing[Them] = b | shift_bb<Down>(b);
248 b &= ei.attackedBy[Us][PAWN];
249 ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) : 0;
250 ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
253 ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
257 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given color
259 template<PieceType Pt, Color Us, bool DoTrace>
260 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, const Bitboard* mobilityArea) {
264 Score score = SCORE_ZERO;
266 const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
267 const Color Them = (Us == WHITE ? BLACK : WHITE);
268 const Square* pl = pos.squares<Pt>(Us);
270 ei.attackedBy[Us][Pt] = 0;
272 while ((s = *pl++) != SQ_NONE)
274 // Find attacked squares, including x-ray attacks for bishops and rooks
275 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
276 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
277 : pos.attacks_from<Pt>(s);
279 if (ei.pinnedPieces[Us] & s)
280 b &= LineBB[pos.square<KING>(Us)][s];
282 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
284 if (b & ei.kingRing[Them])
286 ei.kingAttackersCount[Us]++;
287 ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
288 Bitboard bb = b & ei.attackedBy[Them][KING];
290 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
294 b &= ~( ei.attackedBy[Them][KNIGHT]
295 | ei.attackedBy[Them][BISHOP]
296 | ei.attackedBy[Them][ROOK]);
298 int mob = popcount<Pt == QUEEN ? Full : Max15>(b & mobilityArea[Us]);
300 mobility[Us] += MobilityBonus[Pt][mob];
302 if (Pt == BISHOP || Pt == KNIGHT)
304 // Bonus for outpost square
305 if ( relative_rank(Us, s) >= RANK_4
306 && relative_rank(Us, s) <= RANK_6
307 && !(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
308 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)];
310 // Bonus when behind a pawn
311 if ( relative_rank(Us, s) < RANK_5
312 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
313 score += MinorBehindPawn;
315 // Penalty for pawns on same color square of bishop
317 score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
319 // An important Chess960 pattern: A cornered bishop blocked by a friendly
320 // pawn diagonally in front of it is a very serious problem, especially
321 // when that pawn is also blocked.
324 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
326 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
327 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
328 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
329 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
336 // Bonus for aligning with enemy pawns on the same rank/file
337 if (relative_rank(Us, s) >= RANK_5)
339 Bitboard alignedPawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
341 score += popcount<Max15>(alignedPawns) * RookOnPawn;
344 // Bonus when on an open or semi-open file
345 if (ei.pi->semiopen_file(Us, file_of(s)))
346 score += ei.pi->semiopen_file(Them, file_of(s)) ? RookOnOpenFile : RookOnSemiOpenFile;
348 // Penalize when trapped by the king, even more if king cannot castle
349 if (mob <= 3 && !ei.pi->semiopen_file(Us, file_of(s)))
351 Square ksq = pos.square<KING>(Us);
353 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
354 && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
355 && !ei.pi->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
356 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
362 Trace::add(Pt, Us, score);
364 // Recursively call evaluate_pieces() of next piece type until KING excluded
365 return score - evaluate_pieces<NextPt, Them, DoTrace>(pos, ei, mobility, mobilityArea);
369 Score evaluate_pieces<KING, WHITE, false>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; }
371 Score evaluate_pieces<KING, WHITE, true>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; }
374 // evaluate_king() assigns bonuses and penalties to a king of a given color
376 template<Color Us, bool DoTrace>
377 Score evaluate_king(const Position& pos, const EvalInfo& ei) {
379 const Color Them = (Us == WHITE ? BLACK : WHITE);
381 Bitboard undefended, b, b1, b2, safe;
383 const Square ksq = pos.square<KING>(Us);
385 // King shelter and enemy pawns storm
386 Score score = ei.pi->king_safety<Us>(pos, ksq);
388 // Main king safety evaluation
389 if (ei.kingAttackersCount[Them])
391 // Find the attacked squares around the king which have no defenders
392 // apart from the king itself
393 undefended = ei.attackedBy[Them][ALL_PIECES]
394 & ei.attackedBy[Us][KING]
395 & ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
396 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
397 | ei.attackedBy[Us][QUEEN]);
399 // Initialize the 'attackUnits' variable, which is used later on as an
400 // index into the KingDanger[] array. The initial value is based on the
401 // number and types of the enemy's attacking pieces, the number of
402 // attacked and undefended squares around our king and the quality of
403 // the pawn shelter (current 'score' value).
404 attackUnits = std::min(74, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
405 + 8 * ei.kingAdjacentZoneAttacksCount[Them]
406 + 25 * popcount<Max15>(undefended)
407 + 11 * !!ei.pinnedPieces[Us]
408 - 60 * !pos.count<QUEEN>(Them)
409 - mg_value(score) / 8;
411 // Analyse the enemy's safe queen contact checks. Firstly, find the
412 // undefended squares around the king reachable by the enemy queen...
413 b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
416 // ...and then remove squares not supported by another enemy piece
417 b &= ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
418 | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK];
421 attackUnits += QueenContactCheck * popcount<Max15>(b);
424 // Analyse the enemy's safe rook contact checks. Firstly, find the
425 // undefended squares around the king reachable by the enemy rooks...
426 b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
428 // Consider only squares where the enemy's rook gives check
429 b &= PseudoAttacks[ROOK][ksq];
433 // ...and then remove squares not supported by another enemy piece
434 b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
435 | ei.attackedBy[Them][BISHOP]);
438 attackUnits += RookContactCheck * popcount<Max15>(b);
441 // Analyse the enemy's safe distance checks for sliders and knights
442 safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
444 b1 = pos.attacks_from<ROOK >(ksq) & safe;
445 b2 = pos.attacks_from<BISHOP>(ksq) & safe;
447 // Enemy queen safe checks
448 b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
451 attackUnits += QueenCheck * popcount<Max15>(b);
455 // Enemy rooks safe checks
456 b = b1 & ei.attackedBy[Them][ROOK];
459 attackUnits += RookCheck * popcount<Max15>(b);
463 // Enemy bishops safe checks
464 b = b2 & ei.attackedBy[Them][BISHOP];
467 attackUnits += BishopCheck * popcount<Max15>(b);
471 // Enemy knights safe checks
472 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
475 attackUnits += KnightCheck * popcount<Max15>(b);
479 // Finally, extract the king danger score from the KingDanger[]
480 // array and subtract the score from evaluation.
481 score -= KingDanger[std::max(std::min(attackUnits, 399), 0)];
485 Trace::add(KING, Us, score);
491 // evaluate_threats() assigns bonuses according to the type of attacking piece
492 // and the type of attacked one.
494 template<Color Us, bool DoTrace>
495 Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
497 const Color Them = (Us == WHITE ? BLACK : WHITE);
498 const Square Up = (Us == WHITE ? DELTA_N : DELTA_S);
499 const Square Left = (Us == WHITE ? DELTA_NW : DELTA_SE);
500 const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);
501 const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);
502 const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
504 enum { Defended, Weak };
505 enum { Minor, Major };
507 Bitboard b, weak, defended, safeThreats;
508 Score score = SCORE_ZERO;
510 // Non-pawn enemies attacked by a pawn
511 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
515 b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
516 | ei.attackedBy[Us][ALL_PIECES]);
518 safeThreats = (shift_bb<Right>(b) | shift_bb<Left>(b)) & weak;
520 if (weak ^ safeThreats)
521 score += ThreatenedByHangingPawn;
524 score += ThreatenedByPawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];
527 // Non-pawn enemies defended by a pawn
528 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
530 // Add a bonus according to the kind of attacking pieces
533 b = defended & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
535 score += Threat[Defended][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
537 b = defended & (ei.attackedBy[Us][ROOK]);
539 score += Threat[Defended][Major][type_of(pos.piece_on(pop_lsb(&b)))];
542 // Enemies not defended by a pawn and under our attack
543 weak = pos.pieces(Them)
544 & ~ei.attackedBy[Them][PAWN]
545 & ei.attackedBy[Us][ALL_PIECES];
547 // Add a bonus according to the kind of attacking pieces
550 b = weak & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
552 score += Threat[Weak][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
554 b = weak & (ei.attackedBy[Us][ROOK] | ei.attackedBy[Us][QUEEN]);
556 score += Threat[Weak][Major][type_of(pos.piece_on(pop_lsb(&b)))];
558 b = weak & ~ei.attackedBy[Them][ALL_PIECES];
560 score += Hanging * popcount<Max15>(b);
562 b = weak & ei.attackedBy[Us][KING];
564 score += more_than_one(b) ? KingOnMany : KingOnOne;
567 // Bonus if some pawns can safely push and attack an enemy piece
568 b = pos.pieces(Us, PAWN) & ~TRank7BB;
569 b = shift_bb<Up>(b | (shift_bb<Up>(b & TRank2BB) & ~pos.pieces()));
572 & ~ei.attackedBy[Them][PAWN]
573 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
575 b = (shift_bb<Left>(b) | shift_bb<Right>(b))
577 & ~ei.attackedBy[Us][PAWN];
580 score += popcount<Max15>(b) * PawnAttackThreat;
583 Trace::add(THREAT, Us, score);
589 // evaluate_passed_pawns() evaluates the passed pawns of the given color
591 template<Color Us, bool DoTrace>
592 Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
594 const Color Them = (Us == WHITE ? BLACK : WHITE);
596 Bitboard b, squaresToQueen, defendedSquares, unsafeSquares;
597 Score score = SCORE_ZERO;
599 b = ei.pi->passed_pawns(Us);
603 Square s = pop_lsb(&b);
605 assert(pos.pawn_passed(Us, s));
607 int r = relative_rank(Us, s) - RANK_2;
608 int rr = r * (r - 1);
610 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
614 Square blockSq = s + pawn_push(Us);
616 // Adjust bonus based on the king's proximity
617 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
618 - distance(pos.square<KING>(Us ), blockSq) * 2 * rr;
620 // If blockSq is not the queening square then consider also a second push
621 if (relative_rank(Us, blockSq) != RANK_8)
622 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
624 // If the pawn is free to advance, then increase the bonus
625 if (pos.empty(blockSq))
627 // If there is a rook or queen attacking/defending the pawn from behind,
628 // consider all the squaresToQueen. Otherwise consider only the squares
629 // in the pawn's path attacked or occupied by the enemy.
630 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
632 Bitboard bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
634 if (!(pos.pieces(Us) & bb))
635 defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
637 if (!(pos.pieces(Them) & bb))
638 unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
640 // If there aren't any enemy attacks, assign a big bonus. Otherwise
641 // assign a smaller bonus if the block square isn't attacked.
642 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 0;
644 // If the path to queen is fully defended, assign a big bonus.
645 // Otherwise assign a smaller bonus if the block square is defended.
646 if (defendedSquares == squaresToQueen)
649 else if (defendedSquares & blockSq)
652 mbonus += k * rr, ebonus += k * rr;
654 else if (pos.pieces(Us) & blockSq)
655 mbonus += rr * 3 + r * 2 + 3, ebonus += rr + r * 2;
658 if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
659 ebonus += ebonus / 4;
661 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
665 Trace::add(PASSED, Us, score * Weights[PassedPawns]);
667 // Add the scores to the middlegame and endgame eval
668 return score * Weights[PassedPawns];
672 // evaluate_space() computes the space evaluation for a given side. The
673 // space evaluation is a simple bonus based on the number of safe squares
674 // available for minor pieces on the central four files on ranks 2--4. Safe
675 // squares one, two or three squares behind a friendly pawn are counted
676 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
677 // improve play on game opening.
679 Score evaluate_space(const Position& pos, const EvalInfo& ei) {
681 const Color Them = (Us == WHITE ? BLACK : WHITE);
683 // Find the safe squares for our pieces inside the area defined by
684 // SpaceMask[]. A square is unsafe if it is attacked by an enemy
685 // pawn, or if it is undefended and attacked by an enemy piece.
686 Bitboard safe = SpaceMask[Us]
687 & ~pos.pieces(Us, PAWN)
688 & ~ei.attackedBy[Them][PAWN]
689 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
691 // Find all squares which are at most three squares behind some friendly pawn
692 Bitboard behind = pos.pieces(Us, PAWN);
693 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
694 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
696 // Since SpaceMask[Us] is fully on our half of the board...
697 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
699 // ...count safe + (behind & safe) with a single popcount
700 int bonus = popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
701 int weight = pos.count<KNIGHT>(Us) + pos.count<BISHOP>(Us)
702 + pos.count<KNIGHT>(Them) + pos.count<BISHOP>(Them);
704 return make_score(bonus * weight * weight, 0);
710 /// evaluate() is the main evaluation function. It returns a static evaluation
711 /// of the position always from the point of view of the side to move.
713 template<bool DoTrace>
714 Value Eval::evaluate(const Position& pos) {
716 assert(!pos.checkers());
719 Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
721 // Initialize score by reading the incrementally updated scores included
722 // in the position object (material + piece square tables).
723 // Score is computed from the point of view of white.
724 score = pos.psq_score();
726 // Probe the material hash table
727 Material::Entry* me = Material::probe(pos);
728 score += me->imbalance();
730 // If we have a specialized evaluation function for the current material
731 // configuration, call it and return.
732 if (me->specialized_eval_exists())
733 return me->evaluate(pos);
735 // Probe the pawn hash table
736 ei.pi = Pawns::probe(pos);
737 score += ei.pi->pawns_score() * Weights[PawnStructure];
739 // Initialize attack and king safety bitboards
740 ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0;
741 init_eval_info<WHITE>(pos, ei);
742 init_eval_info<BLACK>(pos, ei);
744 // Pawns blocked or on ranks 2 and 3. Will be excluded from the mobility area
745 Bitboard blockedPawns[] = {
746 pos.pieces(WHITE, PAWN) & (shift_bb<DELTA_S>(pos.pieces()) | Rank2BB | Rank3BB),
747 pos.pieces(BLACK, PAWN) & (shift_bb<DELTA_N>(pos.pieces()) | Rank7BB | Rank6BB)
750 // Do not include in mobility squares protected by enemy pawns, or occupied
751 // by our blocked pawns or king.
752 Bitboard mobilityArea[] = {
753 ~(ei.attackedBy[BLACK][PAWN] | blockedPawns[WHITE] | pos.square<KING>(WHITE)),
754 ~(ei.attackedBy[WHITE][PAWN] | blockedPawns[BLACK] | pos.square<KING>(BLACK))
757 // Evaluate pieces and mobility
758 score += evaluate_pieces<KNIGHT, WHITE, DoTrace>(pos, ei, mobility, mobilityArea);
759 score += (mobility[WHITE] - mobility[BLACK]) * Weights[Mobility];
761 // Evaluate kings after all other pieces because we need complete attack
762 // information when computing the king safety evaluation.
763 score += evaluate_king<WHITE, DoTrace>(pos, ei)
764 - evaluate_king<BLACK, DoTrace>(pos, ei);
766 // Evaluate tactical threats, we need full attack information including king
767 score += evaluate_threats<WHITE, DoTrace>(pos, ei)
768 - evaluate_threats<BLACK, DoTrace>(pos, ei);
770 // Evaluate passed pawns, we need full attack information including king
771 score += evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)
772 - evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);
774 // If both sides have only pawns, score for potential unstoppable pawns
775 if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK))
778 if ((b = ei.pi->passed_pawns(WHITE)) != 0)
779 score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable;
781 if ((b = ei.pi->passed_pawns(BLACK)) != 0)
782 score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable;
785 // Evaluate space for both sides, only during opening
786 if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 11756)
787 score += (evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei)) * Weights[Space];
789 // Scale winning side if position is more drawish than it appears
790 Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK;
791 ScaleFactor sf = me->scale_factor(pos, strongSide);
793 // If we don't already have an unusual scale factor, check for certain
794 // types of endgames, and use a lower scale for those.
795 if ( me->game_phase() < PHASE_MIDGAME
796 && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
798 if (pos.opposite_bishops())
800 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
801 // is almost a draw, in case of KBP vs KB is even more a draw.
802 if ( pos.non_pawn_material(WHITE) == BishopValueMg
803 && pos.non_pawn_material(BLACK) == BishopValueMg)
804 sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(32) : ScaleFactor(8);
806 // Endgame with opposite-colored bishops, but also other pieces. Still
807 // a bit drawish, but not as drawish as with only the two bishops.
809 sf = ScaleFactor(50 * sf / SCALE_FACTOR_NORMAL);
811 // Endings where weaker side can place his king in front of the opponent's
812 // pawns are drawish.
813 else if ( abs(eg_value(score)) <= BishopValueEg
814 && ei.pi->pawn_span(strongSide) <= 1
815 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
816 sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(56) : ScaleFactor(38);
819 // Scale endgame by number of pawns
820 int p = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
821 int v_eg = 1 + abs(int(eg_value(score)));
822 sf = ScaleFactor(std::max(sf / 2, sf - 7 * SCALE_FACTOR_NORMAL * (14 - p) / v_eg));
824 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
825 Value v = mg_value(score) * int(me->game_phase())
826 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
828 v /= int(PHASE_MIDGAME);
830 // In case of tracing add all single evaluation terms
833 Trace::add(MATERIAL, pos.psq_score());
834 Trace::add(IMBALANCE, me->imbalance());
835 Trace::add(PAWN, ei.pi->pawns_score());
836 Trace::add(MOBILITY, mobility[WHITE] * Weights[Mobility]
837 , mobility[BLACK] * Weights[Mobility]);
838 Trace::add(SPACE, evaluate_space<WHITE>(pos, ei) * Weights[Space]
839 , evaluate_space<BLACK>(pos, ei) * Weights[Space]);
840 Trace::add(TOTAL, score);
843 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
846 // Explicit template instantiations
847 template Value Eval::evaluate<true >(const Position&);
848 template Value Eval::evaluate<false>(const Position&);
851 /// trace() is like evaluate(), but instead of returning a value, it returns
852 /// a string (suitable for outputting to stdout) that contains the detailed
853 /// descriptions and values of each evaluation term. Useful for debugging.
855 std::string Eval::trace(const Position& pos) {
857 std::memset(scores, 0, sizeof(scores));
859 Value v = evaluate<true>(pos);
860 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
862 std::stringstream ss;
863 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
864 << " Eval term | White | Black | Total \n"
865 << " | MG EG | MG EG | MG EG \n"
866 << "----------------+-------------+-------------+-------------\n"
867 << " Material | " << Term(MATERIAL)
868 << " Imbalance | " << Term(IMBALANCE)
869 << " Pawns | " << Term(PAWN)
870 << " Knights | " << Term(KNIGHT)
871 << " Bishop | " << Term(BISHOP)
872 << " Rooks | " << Term(ROOK)
873 << " Queens | " << Term(QUEEN)
874 << " Mobility | " << Term(MOBILITY)
875 << " King safety | " << Term(KING)
876 << " Threats | " << Term(THREAT)
877 << " Passed pawns | " << Term(PASSED)
878 << " Space | " << Term(SPACE)
879 << "----------------+-------------+-------------+-------------\n"
880 << " Total | " << Term(TOTAL);
882 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
888 /// init() computes evaluation weights, usually at startup
892 const int MaxSlope = 8700;
893 const int Peak = 1280000;
896 for (int i = 0; i < 400; ++i)
898 t = std::min(Peak, std::min(i * i * 27, t + MaxSlope));
899 KingDanger[i] = make_score(t / 1000, 0) * Weights[KingSafety];