2 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3 Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4 Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5 Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
7 Stockfish is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Stockfish is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include <cstring> // For std::memset
36 enum Term { // The first 8 entries are for PieceType
37 MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
40 double scores[TERM_NB][COLOR_NB][PHASE_NB];
42 double to_cp(Value v) { return double(v) / PawnValueEg; }
44 void add(int idx, Color c, Score s) {
45 scores[idx][c][MG] = to_cp(mg_value(s));
46 scores[idx][c][EG] = to_cp(eg_value(s));
49 void add(int idx, Score w, Score b = SCORE_ZERO) {
50 add(idx, WHITE, w); add(idx, BLACK, b);
53 std::ostream& operator<<(std::ostream& os, Term t) {
55 if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL)
56 os << " --- --- | --- --- | ";
58 os << std::setw(5) << scores[t][WHITE][MG] << " "
59 << std::setw(5) << scores[t][WHITE][EG] << " | "
60 << std::setw(5) << scores[t][BLACK][MG] << " "
61 << std::setw(5) << scores[t][BLACK][EG] << " | ";
63 os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
64 << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
70 using namespace Trace;
72 // Struct EvalInfo contains various information computed and collected
73 // by the evaluation functions.
78 Bitboard mobilityArea[COLOR_NB];
80 // attackedBy[color][piece type] is a bitboard representing all squares
81 // attacked by a given color and piece type (can be also ALL_PIECES).
82 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
84 // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
85 // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
86 // pawn or squares attacked by 2 pawns are not explicitly added.
87 Bitboard attackedBy2[COLOR_NB];
89 // kingRing[color] is the zone around the king which is considered
90 // by the king safety evaluation. This consists of the squares directly
91 // adjacent to the king, and the three (or two, for a king on an edge file)
92 // squares two ranks in front of the king. For instance, if black's king
93 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
94 // f7, g7, h7, f6, g6 and h6.
95 Bitboard kingRing[COLOR_NB];
97 // kingAttackersCount[color] is the number of pieces of the given color
98 // which attack a square in the kingRing of the enemy king.
99 int kingAttackersCount[COLOR_NB];
101 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
102 // given color which attack a square in the kingRing of the enemy king. The
103 // weights of the individual piece types are given by the elements in the
104 // KingAttackWeights array.
105 int kingAttackersWeight[COLOR_NB];
107 // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
108 // color to squares directly adjacent to the enemy king. Pieces which attack
109 // more than one square are counted multiple times. For instance, if there is
110 // a white knight on g5 and black's king is on g8, this white knight adds 2
111 // to kingAdjacentZoneAttacksCount[WHITE].
112 int kingAdjacentZoneAttacksCount[COLOR_NB];
115 #define V(v) Value(v)
116 #define S(mg, eg) make_score(mg, eg)
118 // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
119 // indexed by piece type and number of attacked squares in the mobility area.
120 const Score MobilityBonus[][32] = {
121 { S(-75,-76), S(-57,-54), S( -9,-28), S( -2,-10), S( 6, 5), S( 14, 12), // Knights
122 S( 22, 26), S( 29, 29), S( 36, 29) },
123 { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
124 S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
125 S( 91, 88), S( 98, 97) },
126 { S(-60,-77), S(-26,-20), S(-11, 27), S( -6, 57), S( -3, 69), S( -1, 82), // Rooks
127 S( 10,109), S( 16,121), S( 24,131), S( 25,143), S( 32,155), S( 32,163),
128 S( 43,167), S( 48,171), S( 56,173) },
129 { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens
130 S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
131 S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
132 S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
133 S(106,184), S(109,191), S(113,206), S(116,212) }
136 // Outpost[knight/bishop][supported by pawn] contains bonuses for minor
137 // pieces if they can reach an outpost square, bigger if that square is
138 // supported by a pawn. If the minor piece occupies an outpost square
139 // then score is doubled.
140 const Score Outpost[][2] = {
141 { S(22, 6), S(33, 9) }, // Knight
142 { S( 9, 2), S(14, 4) } // Bishop
145 // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
146 // friendly pawn on the rook file.
147 const Score RookOnFile[] = { S(20, 7), S(45, 20) };
149 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
150 // which piece type attacks which one. Attacks on lesser pieces which are
151 // pawn-defended are not considered.
152 const Score ThreatByMinor[PIECE_TYPE_NB] = {
153 S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
156 const Score ThreatByRook[PIECE_TYPE_NB] = {
157 S(0, 0), S(0, 25), S(40, 62), S(40, 59), S( 0, 34), S(35, 48)
160 // ThreatByKing[on one/on many] contains bonuses for king attacks on
161 // pawns or pieces which are not pawn-defended.
162 const Score ThreatByKing[] = { S(3, 62), S(9, 138) };
164 // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
165 // We don't use a Score because we process the two components independently.
166 const Value Passed[][RANK_NB] = {
167 { V(5), V( 5), V(31), V(73), V(166), V(252) },
168 { V(7), V(14), V(38), V(73), V(166), V(252) }
171 // PassedFile[File] contains a bonus according to the file of a passed pawn
172 const Score PassedFile[FILE_NB] = {
173 S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
174 S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
177 // Protector[PieceType-2][distance] contains a protecting bonus for our king,
178 // indexed by piece type and distance between the piece and the king.
179 const Score Protector[][8] = {
180 { S(0, 0), S( 7, 9), S( 7, 1), S( 1, 5), S(-10,-4), S( -1,-4), S( -7,-3), S(-16,-10) }, // Knight
181 { S(0, 0), S(11, 8), S(-7,-1), S(-1,-2), S( -1,-7), S(-11,-3), S( -9,-1), S(-16, -1) }, // Bishop
182 { S(0, 0), S(10, 0), S(-2, 2), S(-5, 4), S( -6, 2), S(-14,-3), S( -2,-9), S(-12, -7) }, // Rook
183 { S(0, 0), S( 3,-5), S( 2,-5), S(-4, 0), S( -9,-6), S( -4, 7), S(-13,-7), S(-10, -7) } // Queen
186 // Assorted bonuses and penalties used by evaluation
187 const Score MinorBehindPawn = S( 16, 0);
188 const Score BishopPawns = S( 8, 12);
189 const Score RookOnPawn = S( 8, 24);
190 const Score TrappedRook = S( 92, 0);
191 const Score WeakQueen = S( 50, 10);
192 const Score OtherCheck = S( 10, 10);
193 const Score CloseEnemies = S( 7, 0);
194 const Score PawnlessFlank = S( 20, 80);
195 const Score ThreatByHangingPawn = S( 71, 61);
196 const Score ThreatBySafePawn = S(182,175);
197 const Score ThreatByRank = S( 16, 3);
198 const Score Hanging = S( 48, 27);
199 const Score ThreatByPawnPush = S( 38, 22);
200 const Score HinderPassedPawn = S( 7, 0);
202 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
203 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
204 // happen in Chess960 games.
205 const Score TrappedBishopA1H1 = S(50, 50);
210 // KingAttackWeights[PieceType] contains king attack weights by piece type
211 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
213 // Penalties for enemy's safe checks
214 const int QueenCheck = 810;
215 const int RookCheck = 888;
216 const int BishopCheck = 400;
217 const int KnightCheck = 790;
219 // Threshold for lazy and space evaluation
220 const Value LazyThreshold = Value(1500);
221 const Value SpaceThreshold = Value(12222);
223 // eval_init() initializes king and attack bitboards for a given color
224 // adding pawn attacks. To be done at the beginning of the evaluation.
227 void eval_init(const Position& pos, EvalInfo& ei) {
229 const Color Them = (Us == WHITE ? BLACK : WHITE);
230 const Square Up = (Us == WHITE ? NORTH : SOUTH);
231 const Square Down = (Us == WHITE ? SOUTH : NORTH);
232 const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
234 // Find our pawns on the first two ranks, and those which are blocked
235 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
237 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
238 // are excluded from the mobility area.
239 ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them));
241 // Initialise the attack bitboards with the king and pawn information
242 b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
243 ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us);
245 ei.attackedBy2[Us] = b & ei.attackedBy[Us][PAWN];
246 ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN];
248 // Init our king safety tables only if we are going to use them
249 if (pos.non_pawn_material(Them) >= QueenValueMg)
251 ei.kingRing[Us] = b | shift<Up>(b);
252 ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them));
253 ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0;
256 ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0;
260 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
263 template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT>
264 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
266 const Color Them = (Us == WHITE ? BLACK : WHITE);
267 const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
268 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
269 : Rank5BB | Rank4BB | Rank3BB);
270 const Square* pl = pos.squares<Pt>(Us);
274 Score score = SCORE_ZERO;
276 ei.attackedBy[Us][Pt] = 0;
278 while ((s = *pl++) != SQ_NONE)
280 // Find attacked squares, including x-ray attacks for bishops and rooks
281 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
282 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
283 : pos.attacks_from<Pt>(s);
285 if (pos.pinned_pieces(Us) & s)
286 b &= LineBB[pos.square<KING>(Us)][s];
288 ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
289 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
291 if (b & ei.kingRing[Them])
293 ei.kingAttackersCount[Us]++;
294 ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
295 ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]);
298 int mob = popcount(b & ei.mobilityArea[Us]);
300 mobility[Us] += MobilityBonus[Pt-2][mob];
302 // Bonus for this piece as a king protector
303 score += Protector[Pt-2][distance(s, pos.square<KING>(Us))];
305 if (Pt == BISHOP || Pt == KNIGHT)
307 // Bonus for outpost squares
308 bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them);
310 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2;
313 bb &= b & ~pos.pieces(Us);
315 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)];
318 // Bonus when behind a pawn
319 if ( relative_rank(Us, s) < RANK_5
320 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
321 score += MinorBehindPawn;
323 // Penalty for pawns on the same color square as the bishop
325 score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s);
327 // An important Chess960 pattern: A cornered bishop blocked by a friendly
328 // pawn diagonally in front of it is a very serious problem, especially
329 // when that pawn is also blocked.
332 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
334 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
335 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
336 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
337 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
344 // Bonus for aligning with enemy pawns on the same rank/file
345 if (relative_rank(Us, s) >= RANK_5)
346 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
348 // Bonus when on an open or semi-open file
349 if (ei.pe->semiopen_file(Us, file_of(s)))
350 score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))];
352 // Penalty when trapped by the king, even more if the king cannot castle
355 Square ksq = pos.square<KING>(Us);
357 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
358 && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
359 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
365 // Penalty if any relative pin or discovered attack against the queen
367 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
373 Trace::add(Pt, Us, score);
375 // Recursively call evaluate_pieces() of next piece type until KING is excluded
376 return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
380 Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
382 Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
385 // evaluate_king() assigns bonuses and penalties to a king of a given color
387 const Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
388 const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
389 const Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
391 const Bitboard KingFlank[FILE_NB] = {
392 QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide
395 template<Color Us, bool DoTrace>
396 Score evaluate_king(const Position& pos, const EvalInfo& ei) {
398 const Color Them = (Us == WHITE ? BLACK : WHITE);
399 const Square Up = (Us == WHITE ? NORTH : SOUTH);
400 const Bitboard Camp = (Us == WHITE ? ~Bitboard(0) ^ Rank6BB ^ Rank7BB ^ Rank8BB
401 : ~Bitboard(0) ^ Rank1BB ^ Rank2BB ^ Rank3BB);
403 const Square ksq = pos.square<KING>(Us);
404 Bitboard undefended, b, b1, b2, safe, other;
407 // King shelter and enemy pawns storm
408 Score score = ei.pe->king_safety<Us>(pos, ksq);
410 // Main king safety evaluation
411 if (ei.kingAttackersCount[Them])
413 // Find the attacked squares which are defended only by our king...
414 undefended = ei.attackedBy[Them][ALL_PIECES]
415 & ei.attackedBy[Us][KING]
416 & ~ei.attackedBy2[Us];
418 // ... and those which are not defended at all in the larger king ring
419 b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
420 & ei.kingRing[Us] & ~pos.pieces(Them);
422 // Initialize the 'kingDanger' variable, which will be transformed
423 // later into a king danger score. The initial value is based on the
424 // number and types of the enemy's attacking pieces, the number of
425 // attacked and undefended squares around our king and the quality of
426 // the pawn shelter (current 'score' value).
427 kingDanger = ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]
428 + 103 * ei.kingAdjacentZoneAttacksCount[Them]
429 + 190 * popcount(undefended)
430 + 142 * (popcount(b) + !!pos.pinned_pieces(Us))
431 - 810 * !pos.count<QUEEN>(Them)
432 - 6 * mg_value(score) / 5 - 5;
434 // Analyse the safe enemy's checks which are possible on next move
435 safe = ~pos.pieces(Them);
436 safe &= ~ei.attackedBy[Us][ALL_PIECES] | (undefended & ei.attackedBy2[Them]);
438 b1 = pos.attacks_from<ROOK >(ksq);
439 b2 = pos.attacks_from<BISHOP>(ksq);
441 // Enemy queen safe checks
442 if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
443 kingDanger += QueenCheck;
445 // For minors and rooks, also consider the square safe if attacked twice,
446 // and only defended by our queen.
447 safe |= ei.attackedBy2[Them]
448 & ~(ei.attackedBy2[Us] | pos.pieces(Them))
449 & ei.attackedBy[Us][QUEEN];
451 // Some other potential checks are also analysed, even from squares
452 // currently occupied by the opponent own pieces, as long as the square
453 // is not attacked by our pawns, and is not occupied by a blocked pawn.
454 other = ~( ei.attackedBy[Us][PAWN]
455 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
457 // Enemy rooks safe and other checks
458 if (b1 & ei.attackedBy[Them][ROOK] & safe)
459 kingDanger += RookCheck;
461 else if (b1 & ei.attackedBy[Them][ROOK] & other)
464 // Enemy bishops safe and other checks
465 if (b2 & ei.attackedBy[Them][BISHOP] & safe)
466 kingDanger += BishopCheck;
468 else if (b2 & ei.attackedBy[Them][BISHOP] & other)
471 // Enemy knights safe and other checks
472 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT];
474 kingDanger += KnightCheck;
479 // Transform the kingDanger units into a Score, and substract it from the evaluation
481 score -= make_score(kingDanger * kingDanger / 4096, 0);
484 // King tropism: firstly, find squares that opponent attacks in our king flank
485 File kf = file_of(ksq);
486 b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
488 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
489 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
491 // Secondly, add the squares which are attacked twice in that flank and
492 // which are not defended by our pawns.
493 b = (Us == WHITE ? b << 4 : b >> 4)
494 | (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]);
496 score -= CloseEnemies * popcount(b);
498 // Penalty when our king is on a pawnless flank
499 if (!(pos.pieces(PAWN) & KingFlank[kf]))
500 score -= PawnlessFlank;
503 Trace::add(KING, Us, score);
509 // evaluate_threats() assigns bonuses according to the types of the attacking
510 // and the attacked pieces.
512 template<Color Us, bool DoTrace>
513 Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
515 const Color Them = (Us == WHITE ? BLACK : WHITE);
516 const Square Up = (Us == WHITE ? NORTH : SOUTH);
517 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
518 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
519 const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);
520 const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
522 Bitboard b, weak, defended, stronglyProtected, safeThreats;
523 Score score = SCORE_ZERO;
525 // Non-pawn enemies attacked by a pawn
526 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
530 b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
531 | ei.attackedBy[Us][ALL_PIECES]);
533 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
535 score += ThreatBySafePawn * popcount(safeThreats);
537 if (weak ^ safeThreats)
538 score += ThreatByHangingPawn;
541 // Squares strongly protected by the opponent, either because they attack the
542 // square with a pawn, or because they attack the square twice and we don't.
543 stronglyProtected = ei.attackedBy[Them][PAWN]
544 | (ei.attackedBy2[Them] & ~ei.attackedBy2[Us]);
546 // Non-pawn enemies, strongly protected
547 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
550 // Enemies not strongly protected and under our attack
551 weak = pos.pieces(Them)
553 & ei.attackedBy[Us][ALL_PIECES];
555 // Add a bonus according to the kind of attacking pieces
558 b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
561 Square s = pop_lsb(&b);
562 score += ThreatByMinor[type_of(pos.piece_on(s))];
563 if (type_of(pos.piece_on(s)) != PAWN)
564 score += ThreatByRank * (int)relative_rank(Them, s);
567 b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
570 Square s = pop_lsb(&b);
571 score += ThreatByRook[type_of(pos.piece_on(s))];
572 if (type_of(pos.piece_on(s)) != PAWN)
573 score += ThreatByRank * (int)relative_rank(Them, s);
576 score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
578 b = weak & ei.attackedBy[Us][KING];
580 score += ThreatByKing[more_than_one(b)];
583 // Bonus if some pawns can safely push and attack an enemy piece
584 b = pos.pieces(Us, PAWN) & ~TRank7BB;
585 b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
588 & ~ei.attackedBy[Them][PAWN]
589 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
591 b = (shift<Left>(b) | shift<Right>(b))
593 & ~ei.attackedBy[Us][PAWN];
595 score += ThreatByPawnPush * popcount(b);
598 Trace::add(THREAT, Us, score);
604 // evaluate_passer_pawns() evaluates the passed pawns and candidate passed
605 // pawns of the given color.
607 template<Color Us, bool DoTrace>
608 Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) {
610 const Color Them = (Us == WHITE ? BLACK : WHITE);
612 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
613 Score score = SCORE_ZERO;
615 b = ei.pe->passed_pawns(Us);
619 Square s = pop_lsb(&b);
621 assert(!(pos.pieces(Them, PAWN) & forward_bb(Us, s + pawn_push(Us))));
623 bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
624 score -= HinderPassedPawn * popcount(bb);
626 int r = relative_rank(Us, s) - RANK_2;
627 int rr = r * (r - 1);
629 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
633 Square blockSq = s + pawn_push(Us);
635 // Adjust bonus based on the king's proximity
636 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
637 - distance(pos.square<KING>(Us ), blockSq) * 2 * rr;
639 // If blockSq is not the queening square then consider also a second push
640 if (relative_rank(Us, blockSq) != RANK_8)
641 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
643 // If the pawn is free to advance, then increase the bonus
644 if (pos.empty(blockSq))
646 // If there is a rook or queen attacking/defending the pawn from behind,
647 // consider all the squaresToQueen. Otherwise consider only the squares
648 // in the pawn's path attacked or occupied by the enemy.
649 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
651 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
653 if (!(pos.pieces(Us) & bb))
654 defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
656 if (!(pos.pieces(Them) & bb))
657 unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
659 // If there aren't any enemy attacks, assign a big bonus. Otherwise
660 // assign a smaller bonus if the block square isn't attacked.
661 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
663 // If the path to the queen is fully defended, assign a big bonus.
664 // Otherwise assign a smaller bonus if the block square is defended.
665 if (defendedSquares == squaresToQueen)
668 else if (defendedSquares & blockSq)
671 mbonus += k * rr, ebonus += k * rr;
673 else if (pos.pieces(Us) & blockSq)
674 mbonus += rr + r * 2, ebonus += rr + r * 2;
677 // Scale down bonus for candidate passers which need more than one
678 // pawn push to become passed or have a pawn in front of them.
679 if (!pos.pawn_passed(Us, s + pawn_push(Us)) || (pos.pieces(PAWN) & forward_bb(Us, s)))
680 mbonus /= 2, ebonus /= 2;
682 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
686 Trace::add(PASSED, Us, score);
692 // evaluate_space() computes the space evaluation for a given side. The
693 // space evaluation is a simple bonus based on the number of safe squares
694 // available for minor pieces on the central four files on ranks 2--4. Safe
695 // squares one, two or three squares behind a friendly pawn are counted
696 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
697 // improve play on game opening.
699 Score evaluate_space(const Position& pos, const EvalInfo& ei) {
701 const Color Them = (Us == WHITE ? BLACK : WHITE);
702 const Bitboard SpaceMask =
703 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
704 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
706 // Find the safe squares for our pieces inside the area defined by
707 // SpaceMask. A square is unsafe if it is attacked by an enemy
708 // pawn, or if it is undefended and attacked by an enemy piece.
709 Bitboard safe = SpaceMask
710 & ~pos.pieces(Us, PAWN)
711 & ~ei.attackedBy[Them][PAWN]
712 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
714 // Find all squares which are at most three squares behind some friendly pawn
715 Bitboard behind = pos.pieces(Us, PAWN);
716 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
717 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
719 // Since SpaceMask[Us] is fully on our half of the board...
720 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
722 // ...count safe + (behind & safe) with a single popcount.
723 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
724 int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
726 return make_score(bonus * weight * weight / 16, 0);
730 // evaluate_initiative() computes the initiative correction value for the
731 // position, i.e., second order bonus/malus based on the known attacking/defending
732 // status of the players.
733 Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
735 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
736 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
737 bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
739 // Compute the initiative bonus for the attacking side
740 int initiative = 8 * (asymmetry + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
742 // Now apply the bonus: note that we find the attacking side by extracting
743 // the sign of the endgame value, and that we carefully cap the bonus so
744 // that the endgame score will never change sign after the bonus.
745 int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
747 return make_score(0, value);
751 // evaluate_scale_factor() computes the scale factor for the winning side
752 ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
754 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
755 ScaleFactor sf = ei.me->scale_factor(pos, strongSide);
757 // If we don't already have an unusual scale factor, check for certain
758 // types of endgames, and use a lower scale for those.
759 if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
761 if (pos.opposite_bishops())
763 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
764 // is almost a draw, in case of KBP vs KB, it is even more a draw.
765 if ( pos.non_pawn_material(WHITE) == BishopValueMg
766 && pos.non_pawn_material(BLACK) == BishopValueMg)
767 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
769 // Endgame with opposite-colored bishops, but also other pieces. Still
770 // a bit drawish, but not as drawish as with only the two bishops.
771 return ScaleFactor(46);
773 // Endings where weaker side can place his king in front of the opponent's
774 // pawns are drawish.
775 else if ( abs(eg) <= BishopValueEg
776 && pos.count<PAWN>(strongSide) <= 2
777 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
778 return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
787 /// evaluate() is the main evaluation function. It returns a static evaluation
788 /// of the position from the point of view of the side to move.
790 template<bool DoTrace>
791 Value Eval::evaluate(const Position& pos) {
793 assert(!pos.checkers());
795 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
799 // Probe the material hash table
800 ei.me = Material::probe(pos);
802 // If we have a specialized evaluation function for the current material
803 // configuration, call it and return.
804 if (ei.me->specialized_eval_exists())
805 return ei.me->evaluate(pos);
807 // Initialize score by reading the incrementally updated scores included in
808 // the position object (material + piece square tables) and the material
809 // imbalance. Score is computed internally from the white point of view.
810 Score score = pos.psq_score() + ei.me->imbalance();
812 // Probe the pawn hash table
813 ei.pe = Pawns::probe(pos);
814 score += ei.pe->pawns_score();
816 // Early exit if score is high
817 v = (mg_value(score) + eg_value(score)) / 2;
818 if (abs(v) > LazyThreshold)
819 return pos.side_to_move() == WHITE ? v : -v;
821 // Initialize attack and king safety bitboards
822 eval_init<WHITE>(pos, ei);
823 eval_init<BLACK>(pos, ei);
825 // Evaluate all pieces but king and pawns
826 score += evaluate_pieces<DoTrace>(pos, ei, mobility);
827 score += mobility[WHITE] - mobility[BLACK];
829 // Evaluate kings after all other pieces because we need full attack
830 // information when computing the king safety evaluation.
831 score += evaluate_king<WHITE, DoTrace>(pos, ei)
832 - evaluate_king<BLACK, DoTrace>(pos, ei);
834 // Evaluate tactical threats, we need full attack information including king
835 score += evaluate_threats<WHITE, DoTrace>(pos, ei)
836 - evaluate_threats<BLACK, DoTrace>(pos, ei);
838 // Evaluate passed pawns, we need full attack information including king
839 score += evaluate_passer_pawns<WHITE, DoTrace>(pos, ei)
840 - evaluate_passer_pawns<BLACK, DoTrace>(pos, ei);
842 // Evaluate space for both sides, only during opening
843 if (pos.non_pawn_material() >= SpaceThreshold)
844 score += evaluate_space<WHITE>(pos, ei)
845 - evaluate_space<BLACK>(pos, ei);
847 // Evaluate position potential for the winning side
848 score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
850 // Evaluate scale factor for the winning side
851 ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
853 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
854 v = mg_value(score) * int(ei.me->game_phase())
855 + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
857 v /= int(PHASE_MIDGAME);
859 // In case of tracing add all remaining individual evaluation terms
862 Trace::add(MATERIAL, pos.psq_score());
863 Trace::add(IMBALANCE, ei.me->imbalance());
864 Trace::add(PAWN, ei.pe->pawns_score());
865 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
866 if (pos.non_pawn_material() >= SpaceThreshold)
867 Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
868 , evaluate_space<BLACK>(pos, ei));
869 Trace::add(TOTAL, score);
872 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
875 // Explicit template instantiations
876 template Value Eval::evaluate<true >(const Position&);
877 template Value Eval::evaluate<false>(const Position&);
880 /// trace() is like evaluate(), but instead of returning a value, it returns
881 /// a string (suitable for outputting to stdout) that contains the detailed
882 /// descriptions and values of each evaluation term. Useful for debugging.
884 std::string Eval::trace(const Position& pos) {
886 std::memset(scores, 0, sizeof(scores));
888 Value v = evaluate<true>(pos);
889 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
891 std::stringstream ss;
892 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
893 << " Eval term | White | Black | Total \n"
894 << " | MG EG | MG EG | MG EG \n"
895 << "----------------+-------------+-------------+-------------\n"
896 << " Material | " << Term(MATERIAL)
897 << " Imbalance | " << Term(IMBALANCE)
898 << " Pawns | " << Term(PAWN)
899 << " Knights | " << Term(KNIGHT)
900 << " Bishop | " << Term(BISHOP)
901 << " Rooks | " << Term(ROOK)
902 << " Queens | " << Term(QUEEN)
903 << " Mobility | " << Term(MOBILITY)
904 << " King safety | " << Term(KING)
905 << " Threats | " << Term(THREAT)
906 << " Passed pawns | " << Term(PASSED)
907 << " Space | " << Term(SPACE)
908 << "----------------+-------------+-------------+-------------\n"
909 << " Total | " << Term(TOTAL);
911 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";