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 const Score ThreatenedByHangingPawn = S(40, 60);
175 // Assorted bonuses and penalties used by evaluation
176 const Score KingOnOne = S( 2, 58);
177 const Score KingOnMany = S( 6,125);
178 const Score RookOnPawn = S( 7, 27);
179 const Score RookOnOpenFile = S(43, 21);
180 const Score RookOnSemiOpenFile = S(19, 10);
181 const Score BishopPawns = S( 8, 12);
182 const Score MinorBehindPawn = S(16, 0);
183 const Score TrappedRook = S(92, 0);
184 const Score Unstoppable = S( 0, 20);
185 const Score Hanging = S(31, 26);
186 const Score PawnAttackThreat = S(20, 20);
188 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
189 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
190 // happen in Chess960 games.
191 const Score TrappedBishopA1H1 = S(50, 50);
196 // SpaceMask[Color] contains the area of the board which is considered
197 // by the space evaluation. In the middlegame, each side is given a bonus
198 // based on how many squares inside this area are safe and available for
199 // friendly minor pieces.
200 const Bitboard SpaceMask[COLOR_NB] = {
201 (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
202 (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
205 // King danger constants and variables. The king danger scores are looked-up
206 // in KingDanger[]. Various little "meta-bonuses" measuring the strength
207 // of the enemy attack are added up into an integer, which is used as an
208 // index to KingDanger[].
209 Score KingDanger[512];
211 // KingAttackWeights[PieceType] contains king attack weights by piece type
212 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 7, 5, 4, 1 };
214 // Penalties for enemy's safe checks
215 const int QueenContactCheck = 89;
216 const int RookContactCheck = 71;
217 const int QueenCheck = 50;
218 const int RookCheck = 37;
219 const int BishopCheck = 6;
220 const int KnightCheck = 14;
223 // init_eval_info() initializes king bitboards for given color adding
224 // pawn attacks. To be done at the beginning of the evaluation.
227 void init_eval_info(const Position& pos, EvalInfo& ei) {
229 const Color Them = (Us == WHITE ? BLACK : WHITE);
230 const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
232 ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
233 Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.square<KING>(Them));
234 ei.attackedBy[Them][ALL_PIECES] |= b;
235 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
237 // Init king safety tables only if we are going to use them
238 if (pos.non_pawn_material(Us) >= QueenValueMg)
240 ei.kingRing[Them] = b | shift_bb<Down>(b);
241 b &= ei.attackedBy[Us][PAWN];
242 ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) : 0;
243 ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
246 ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
250 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given color
252 template<PieceType Pt, Color Us, bool DoTrace>
253 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, const Bitboard* mobilityArea) {
257 Score score = SCORE_ZERO;
259 const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
260 const Color Them = (Us == WHITE ? BLACK : WHITE);
261 const Square* pl = pos.squares<Pt>(Us);
263 ei.attackedBy[Us][Pt] = 0;
265 while ((s = *pl++) != SQ_NONE)
267 // Find attacked squares, including x-ray attacks for bishops and rooks
268 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
269 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
270 : pos.attacks_from<Pt>(s);
272 if (ei.pinnedPieces[Us] & s)
273 b &= LineBB[pos.square<KING>(Us)][s];
275 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
277 if (b & ei.kingRing[Them])
279 ei.kingAttackersCount[Us]++;
280 ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
281 Bitboard bb = b & ei.attackedBy[Them][KING];
283 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
287 b &= ~( ei.attackedBy[Them][KNIGHT]
288 | ei.attackedBy[Them][BISHOP]
289 | ei.attackedBy[Them][ROOK]);
291 int mob = popcount<Pt == QUEEN ? Full : Max15>(b & mobilityArea[Us]);
293 mobility[Us] += MobilityBonus[Pt][mob];
295 if (Pt == BISHOP || Pt == KNIGHT)
297 // Bonus for outpost square
298 if ( relative_rank(Us, s) >= RANK_4
299 && relative_rank(Us, s) <= RANK_6
300 && !(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
301 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)];
303 // Bonus when behind a pawn
304 if ( relative_rank(Us, s) < RANK_5
305 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
306 score += MinorBehindPawn;
308 // Penalty for pawns on same color square of bishop
310 score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
312 // An important Chess960 pattern: A cornered bishop blocked by a friendly
313 // pawn diagonally in front of it is a very serious problem, especially
314 // when that pawn is also blocked.
317 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
319 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
320 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
321 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
322 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
329 // Bonus for aligning with enemy pawns on the same rank/file
330 if (relative_rank(Us, s) >= RANK_5)
332 Bitboard alignedPawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
334 score += popcount<Max15>(alignedPawns) * RookOnPawn;
337 // Bonus when on an open or semi-open file
338 if (ei.pi->semiopen_file(Us, file_of(s)))
339 score += ei.pi->semiopen_file(Them, file_of(s)) ? RookOnOpenFile : RookOnSemiOpenFile;
341 // Penalize when trapped by the king, even more if king cannot castle
342 if (mob <= 3 && !ei.pi->semiopen_file(Us, file_of(s)))
344 Square ksq = pos.square<KING>(Us);
346 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
347 && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
348 && !ei.pi->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
349 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
355 Trace::add(Pt, Us, score);
357 // Recursively call evaluate_pieces() of next piece type until KING excluded
358 return score - evaluate_pieces<NextPt, Them, DoTrace>(pos, ei, mobility, mobilityArea);
362 Score evaluate_pieces<KING, WHITE, false>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; }
364 Score evaluate_pieces<KING, WHITE, true>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; }
367 // evaluate_king() assigns bonuses and penalties to a king of a given color
369 template<Color Us, bool DoTrace>
370 Score evaluate_king(const Position& pos, const EvalInfo& ei) {
372 const Color Them = (Us == WHITE ? BLACK : WHITE);
374 Bitboard undefended, b, b1, b2, safe;
376 const Square ksq = pos.square<KING>(Us);
378 // King shelter and enemy pawns storm
379 Score score = ei.pi->king_safety<Us>(pos, ksq);
381 // Main king safety evaluation
382 if (ei.kingAttackersCount[Them])
384 // Find the attacked squares around the king which have no defenders
385 // apart from the king itself
386 undefended = ei.attackedBy[Them][ALL_PIECES]
387 & ei.attackedBy[Us][KING]
388 & ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
389 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
390 | ei.attackedBy[Us][QUEEN]);
392 // Initialize the 'attackUnits' variable, which is used later on as an
393 // index into the KingDanger[] array. The initial value is based on the
394 // number and types of the enemy's attacking pieces, the number of
395 // attacked and undefended squares around our king and the quality of
396 // the pawn shelter (current 'score' value).
397 attackUnits = std::min(74, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
398 + 8 * ei.kingAdjacentZoneAttacksCount[Them]
399 + 25 * popcount<Max15>(undefended)
400 + 11 * !!ei.pinnedPieces[Us]
401 - 60 * !pos.count<QUEEN>(Them)
402 - mg_value(score) / 8;
404 // Analyse the enemy's safe queen contact checks. Firstly, find the
405 // undefended squares around the king reachable by the enemy queen...
406 b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
409 // ...and then remove squares not supported by another enemy piece
410 b &= ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
411 | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK];
414 attackUnits += QueenContactCheck * popcount<Max15>(b);
417 // Analyse the enemy's safe rook contact checks. Firstly, find the
418 // undefended squares around the king reachable by the enemy rooks...
419 b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
421 // Consider only squares where the enemy's rook gives check
422 b &= PseudoAttacks[ROOK][ksq];
426 // ...and then remove squares not supported by another enemy piece
427 b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
428 | ei.attackedBy[Them][BISHOP]);
431 attackUnits += RookContactCheck * popcount<Max15>(b);
434 // Analyse the enemy's safe distance checks for sliders and knights
435 safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
437 b1 = pos.attacks_from<ROOK >(ksq) & safe;
438 b2 = pos.attacks_from<BISHOP>(ksq) & safe;
440 // Enemy queen safe checks
441 b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
443 attackUnits += QueenCheck * popcount<Max15>(b);
445 // Enemy rooks safe checks
446 b = b1 & ei.attackedBy[Them][ROOK];
448 attackUnits += RookCheck * popcount<Max15>(b);
450 // Enemy bishops safe checks
451 b = b2 & ei.attackedBy[Them][BISHOP];
453 attackUnits += BishopCheck * popcount<Max15>(b);
455 // Enemy knights safe checks
456 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
458 attackUnits += KnightCheck * popcount<Max15>(b);
460 // Finally, extract the king danger score from the KingDanger[]
461 // array and subtract the score from evaluation.
462 score -= KingDanger[std::max(std::min(attackUnits, 399), 0)];
466 Trace::add(KING, Us, score);
472 // evaluate_threats() assigns bonuses according to the type of attacking piece
473 // and the type of attacked one.
475 template<Color Us, bool DoTrace>
476 Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
478 const Color Them = (Us == WHITE ? BLACK : WHITE);
479 const Square Up = (Us == WHITE ? DELTA_N : DELTA_S);
480 const Square Left = (Us == WHITE ? DELTA_NW : DELTA_SE);
481 const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);
482 const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);
483 const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
485 enum { Defended, Weak };
486 enum { Minor, Major };
488 Bitboard b, weak, defended, safeThreats;
489 Score score = SCORE_ZERO;
491 // Non-pawn enemies attacked by a pawn
492 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
496 b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
497 | ei.attackedBy[Us][ALL_PIECES]);
499 safeThreats = (shift_bb<Right>(b) | shift_bb<Left>(b)) & weak;
501 if (weak ^ safeThreats)
502 score += ThreatenedByHangingPawn;
505 score += ThreatenedByPawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];
508 // Non-pawn enemies defended by a pawn
509 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
511 // Add a bonus according to the kind of attacking pieces
514 b = defended & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
516 score += Threat[Defended][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
518 b = defended & (ei.attackedBy[Us][ROOK]);
520 score += Threat[Defended][Major][type_of(pos.piece_on(pop_lsb(&b)))];
523 // Enemies not defended by a pawn and under our attack
524 weak = pos.pieces(Them)
525 & ~ei.attackedBy[Them][PAWN]
526 & ei.attackedBy[Us][ALL_PIECES];
528 // Add a bonus according to the kind of attacking pieces
531 b = weak & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
533 score += Threat[Weak][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
535 b = weak & (ei.attackedBy[Us][ROOK] | ei.attackedBy[Us][QUEEN]);
537 score += Threat[Weak][Major][type_of(pos.piece_on(pop_lsb(&b)))];
539 b = weak & ~ei.attackedBy[Them][ALL_PIECES];
541 score += Hanging * popcount<Max15>(b);
543 b = weak & ei.attackedBy[Us][KING];
545 score += more_than_one(b) ? KingOnMany : KingOnOne;
548 // Bonus if some pawns can safely push and attack an enemy piece
549 b = pos.pieces(Us, PAWN) & ~TRank7BB;
550 b = shift_bb<Up>(b | (shift_bb<Up>(b & TRank2BB) & ~pos.pieces()));
553 & ~ei.attackedBy[Them][PAWN]
554 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
556 b = (shift_bb<Left>(b) | shift_bb<Right>(b))
558 & ~ei.attackedBy[Us][PAWN];
561 score += popcount<Max15>(b) * PawnAttackThreat;
564 Trace::add(THREAT, Us, score);
570 // evaluate_passed_pawns() evaluates the passed pawns of the given color
572 template<Color Us, bool DoTrace>
573 Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
575 const Color Them = (Us == WHITE ? BLACK : WHITE);
577 Bitboard b, squaresToQueen, defendedSquares, unsafeSquares;
578 Score score = SCORE_ZERO;
580 b = ei.pi->passed_pawns(Us);
584 Square s = pop_lsb(&b);
586 assert(pos.pawn_passed(Us, s));
588 int r = relative_rank(Us, s) - RANK_2;
589 int rr = r * (r - 1);
591 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
595 Square blockSq = s + pawn_push(Us);
597 // Adjust bonus based on the king's proximity
598 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
599 - distance(pos.square<KING>(Us ), blockSq) * 2 * rr;
601 // If blockSq is not the queening square then consider also a second push
602 if (relative_rank(Us, blockSq) != RANK_8)
603 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
605 // If the pawn is free to advance, then increase the bonus
606 if (pos.empty(blockSq))
608 // If there is a rook or queen attacking/defending the pawn from behind,
609 // consider all the squaresToQueen. Otherwise consider only the squares
610 // in the pawn's path attacked or occupied by the enemy.
611 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
613 Bitboard bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
615 if (!(pos.pieces(Us) & bb))
616 defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
618 if (!(pos.pieces(Them) & bb))
619 unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
621 // If there aren't any enemy attacks, assign a big bonus. Otherwise
622 // assign a smaller bonus if the block square isn't attacked.
623 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 0;
625 // If the path to queen is fully defended, assign a big bonus.
626 // Otherwise assign a smaller bonus if the block square is defended.
627 if (defendedSquares == squaresToQueen)
630 else if (defendedSquares & blockSq)
633 mbonus += k * rr, ebonus += k * rr;
635 else if (pos.pieces(Us) & blockSq)
636 mbonus += rr * 3 + r * 2 + 3, ebonus += rr + r * 2;
639 if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
640 ebonus += ebonus / 4;
642 score += make_score(mbonus, ebonus);
646 Trace::add(PASSED, Us, score * Weights[PassedPawns]);
648 // Add the scores to the middlegame and endgame eval
649 return score * Weights[PassedPawns];
653 // evaluate_space() computes the space evaluation for a given side. The
654 // space evaluation is a simple bonus based on the number of safe squares
655 // available for minor pieces on the central four files on ranks 2--4. Safe
656 // squares one, two or three squares behind a friendly pawn are counted
657 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
658 // improve play on game opening.
660 Score evaluate_space(const Position& pos, const EvalInfo& ei) {
662 const Color Them = (Us == WHITE ? BLACK : WHITE);
664 // Find the safe squares for our pieces inside the area defined by
665 // SpaceMask[]. A square is unsafe if it is attacked by an enemy
666 // pawn, or if it is undefended and attacked by an enemy piece.
667 Bitboard safe = SpaceMask[Us]
668 & ~pos.pieces(Us, PAWN)
669 & ~ei.attackedBy[Them][PAWN]
670 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
672 // Find all squares which are at most three squares behind some friendly pawn
673 Bitboard behind = pos.pieces(Us, PAWN);
674 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
675 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
677 // Since SpaceMask[Us] is fully on our half of the board...
678 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
680 // ...count safe + (behind & safe) with a single popcount
681 int bonus = popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
682 int weight = pos.count<KNIGHT>(Us) + pos.count<BISHOP>(Us)
683 + pos.count<KNIGHT>(Them) + pos.count<BISHOP>(Them);
685 return make_score(bonus * weight * weight, 0);
691 /// evaluate() is the main evaluation function. It returns a static evaluation
692 /// of the position always from the point of view of the side to move.
694 template<bool DoTrace>
695 Value Eval::evaluate(const Position& pos) {
697 assert(!pos.checkers());
700 Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
702 // Initialize score by reading the incrementally updated scores included
703 // in the position object (material + piece square tables).
704 // Score is computed from the point of view of white.
705 score = pos.psq_score();
707 // Probe the material hash table
708 Material::Entry* me = Material::probe(pos);
709 score += me->imbalance();
711 // If we have a specialized evaluation function for the current material
712 // configuration, call it and return.
713 if (me->specialized_eval_exists())
714 return me->evaluate(pos);
716 // Probe the pawn hash table
717 ei.pi = Pawns::probe(pos);
718 score += ei.pi->pawns_score() * Weights[PawnStructure];
720 // Initialize attack and king safety bitboards
721 ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0;
722 init_eval_info<WHITE>(pos, ei);
723 init_eval_info<BLACK>(pos, ei);
725 // Pawns blocked or on ranks 2 and 3. Will be excluded from the mobility area
726 Bitboard blockedPawns[] = {
727 pos.pieces(WHITE, PAWN) & (shift_bb<DELTA_S>(pos.pieces()) | Rank2BB | Rank3BB),
728 pos.pieces(BLACK, PAWN) & (shift_bb<DELTA_N>(pos.pieces()) | Rank7BB | Rank6BB)
731 // Do not include in mobility squares protected by enemy pawns, or occupied
732 // by our blocked pawns or king.
733 Bitboard mobilityArea[] = {
734 ~(ei.attackedBy[BLACK][PAWN] | blockedPawns[WHITE] | pos.square<KING>(WHITE)),
735 ~(ei.attackedBy[WHITE][PAWN] | blockedPawns[BLACK] | pos.square<KING>(BLACK))
738 // Evaluate pieces and mobility
739 score += evaluate_pieces<KNIGHT, WHITE, DoTrace>(pos, ei, mobility, mobilityArea);
740 score += (mobility[WHITE] - mobility[BLACK]) * Weights[Mobility];
742 // Evaluate kings after all other pieces because we need complete attack
743 // information when computing the king safety evaluation.
744 score += evaluate_king<WHITE, DoTrace>(pos, ei)
745 - evaluate_king<BLACK, DoTrace>(pos, ei);
747 // Evaluate tactical threats, we need full attack information including king
748 score += evaluate_threats<WHITE, DoTrace>(pos, ei)
749 - evaluate_threats<BLACK, DoTrace>(pos, ei);
751 // Evaluate passed pawns, we need full attack information including king
752 score += evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)
753 - evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);
755 // If both sides have only pawns, score for potential unstoppable pawns
756 if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK))
759 if ((b = ei.pi->passed_pawns(WHITE)) != 0)
760 score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable;
762 if ((b = ei.pi->passed_pawns(BLACK)) != 0)
763 score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable;
766 // Evaluate space for both sides, only during opening
767 if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 11756)
768 score += (evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei)) * Weights[Space];
770 // Scale winning side if position is more drawish than it appears
771 Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK;
772 ScaleFactor sf = me->scale_factor(pos, strongSide);
774 // If we don't already have an unusual scale factor, check for certain
775 // types of endgames, and use a lower scale for those.
776 if ( me->game_phase() < PHASE_MIDGAME
777 && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
779 if (pos.opposite_bishops())
781 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
782 // is almost a draw, in case of KBP vs KB is even more a draw.
783 if ( pos.non_pawn_material(WHITE) == BishopValueMg
784 && pos.non_pawn_material(BLACK) == BishopValueMg)
785 sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(32) : ScaleFactor(8);
787 // Endgame with opposite-colored bishops, but also other pieces. Still
788 // a bit drawish, but not as drawish as with only the two bishops.
790 sf = ScaleFactor(50 * sf / SCALE_FACTOR_NORMAL);
792 // Endings where weaker side can place his king in front of the opponent's
793 // pawns are drawish.
794 else if ( abs(eg_value(score)) <= BishopValueEg
795 && ei.pi->pawn_span(strongSide) <= 1
796 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
797 sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(56) : ScaleFactor(38);
800 // Scale endgame by number of pawns
801 int p = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
802 int v_eg = 1 + abs(int(eg_value(score)));
803 sf = ScaleFactor(std::max(sf / 2, sf - 7 * SCALE_FACTOR_NORMAL * (14 - p) / v_eg));
805 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
806 Value v = mg_value(score) * int(me->game_phase())
807 + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
809 v /= int(PHASE_MIDGAME);
811 // In case of tracing add all single evaluation terms
814 Trace::add(MATERIAL, pos.psq_score());
815 Trace::add(IMBALANCE, me->imbalance());
816 Trace::add(PAWN, ei.pi->pawns_score());
817 Trace::add(MOBILITY, mobility[WHITE] * Weights[Mobility]
818 , mobility[BLACK] * Weights[Mobility]);
819 Trace::add(SPACE, evaluate_space<WHITE>(pos, ei) * Weights[Space]
820 , evaluate_space<BLACK>(pos, ei) * Weights[Space]);
821 Trace::add(TOTAL, score);
824 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
827 // Explicit template instantiations
828 template Value Eval::evaluate<true >(const Position&);
829 template Value Eval::evaluate<false>(const Position&);
832 /// trace() is like evaluate(), but instead of returning a value, it returns
833 /// a string (suitable for outputting to stdout) that contains the detailed
834 /// descriptions and values of each evaluation term. Useful for debugging.
836 std::string Eval::trace(const Position& pos) {
838 std::memset(scores, 0, sizeof(scores));
840 Value v = evaluate<true>(pos);
841 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
843 std::stringstream ss;
844 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
845 << " Eval term | White | Black | Total \n"
846 << " | MG EG | MG EG | MG EG \n"
847 << "----------------+-------------+-------------+-------------\n"
848 << " Material | " << Term(MATERIAL)
849 << " Imbalance | " << Term(IMBALANCE)
850 << " Pawns | " << Term(PAWN)
851 << " Knights | " << Term(KNIGHT)
852 << " Bishop | " << Term(BISHOP)
853 << " Rooks | " << Term(ROOK)
854 << " Queens | " << Term(QUEEN)
855 << " Mobility | " << Term(MOBILITY)
856 << " King safety | " << Term(KING)
857 << " Threats | " << Term(THREAT)
858 << " Passed pawns | " << Term(PASSED)
859 << " Space | " << Term(SPACE)
860 << "----------------+-------------+-------------+-------------\n"
861 << " Total | " << Term(TOTAL);
863 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
869 /// init() computes evaluation weights, usually at startup
873 const int MaxSlope = 8700;
874 const int Peak = 1280000;
877 for (int i = 0; i < 400; ++i)
879 t = std::min(Peak, std::min(i * i * 27, t + MaxSlope));
880 KingDanger[i] = make_score(t / 1000, 0) * Weights[KingSafety];