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 pinnedPieces[COLOR_NB];
79 Bitboard mobilityArea[COLOR_NB];
81 // attackedBy[color][piece type] is a bitboard representing all squares
82 // attacked by a given color and piece type (can be also ALL_PIECES).
83 Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
85 // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
86 // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
87 // pawn or squares attacked by 2 pawns are not explicitly added.
88 Bitboard attackedBy2[COLOR_NB];
90 // kingRing[color] is the zone around the king which is considered
91 // by the king safety evaluation. This consists of the squares directly
92 // adjacent to the king, and the three (or two, for a king on an edge file)
93 // squares two ranks in front of the king. For instance, if black's king
94 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
95 // f7, g7, h7, f6, g6 and h6.
96 Bitboard kingRing[COLOR_NB];
98 // kingAttackersCount[color] is the number of pieces of the given color
99 // which attack a square in the kingRing of the enemy king.
100 int kingAttackersCount[COLOR_NB];
102 // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
103 // given color which attack a square in the kingRing of the enemy king. The
104 // weights of the individual piece types are given by the elements in the
105 // KingAttackWeights array.
106 int kingAttackersWeight[COLOR_NB];
108 // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
109 // color to squares directly adjacent to the enemy king. Pieces which attack
110 // more than one square are counted multiple times. For instance, if there is
111 // a white knight on g5 and black's king is on g8, this white knight adds 2
112 // to kingAdjacentZoneAttacksCount[WHITE].
113 int kingAdjacentZoneAttacksCount[COLOR_NB];
116 #define V(v) Value(v)
117 #define S(mg, eg) make_score(mg, eg)
119 // MobilityBonus[PieceType][attacked] contains bonuses for middle and end game,
120 // indexed by piece type and number of attacked squares in the mobility area.
121 const Score MobilityBonus[][32] = {
123 { S(-75,-76), S(-56,-54), S( -9,-26), S( -2,-10), S( 6, 5), S( 15, 11), // Knights
124 S( 22, 26), S( 30, 28), S( 36, 29) },
125 { S(-48,-58), S(-21,-19), S( 16, -2), S( 26, 12), S( 37, 22), S( 51, 42), // Bishops
126 S( 54, 54), S( 63, 58), S( 65, 63), S( 71, 70), S( 79, 74), S( 81, 86),
127 S( 92, 90), S( 97, 94) },
128 { S(-56,-78), S(-25,-18), S(-11, 26), S( -5, 55), S( -4, 70), S( -1, 81), // Rooks
129 S( 8,109), S( 14,120), S( 21,128), S( 23,143), S( 31,154), S( 32,160),
130 S( 43,165), S( 49,168), S( 59,169) },
131 { S(-40,-35), S(-25,-12), S( 2, 7), S( 4, 19), S( 14, 37), S( 24, 55), // Queens
132 S( 25, 62), S( 40, 76), S( 43, 79), S( 47, 87), S( 54, 94), S( 56,102),
133 S( 60,111), S( 70,116), S( 72,118), S( 73,122), S( 75,128), S( 77,130),
134 S( 85,133), S( 94,136), S( 99,140), S(108,157), S(112,158), S(113,161),
135 S(118,174), S(119,177), S(123,191), S(128,199) }
138 // Outpost[knight/bishop][supported by pawn] contains bonuses for knights and
139 // bishops outposts, bigger if outpost piece is supported by a pawn.
140 const Score Outpost[][2] = {
141 { S(43,11), S(65,20) }, // Knights
142 { S(20, 3), S(29, 8) } // Bishops
145 // ReachableOutpost[knight/bishop][supported by pawn] contains bonuses for
146 // knights and bishops which can reach an outpost square in one move, bigger
147 // if outpost square is supported by a pawn.
148 const Score ReachableOutpost[][2] = {
149 { S(21, 5), S(35, 8) }, // Knights
150 { S( 8, 0), S(14, 4) } // Bishops
153 // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
154 // friendly pawn on the rook file.
155 const Score RookOnFile[2] = { S(20, 7), S(45, 20) };
157 // ThreatBySafePawn[PieceType] contains bonuses according to which piece
158 // type is attacked by a pawn which is protected or is not attacked.
159 const Score ThreatBySafePawn[PIECE_TYPE_NB] = {
160 S(0, 0), S(0, 0), S(176, 139), S(131, 127), S(217, 218), S(203, 215)
163 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
164 // which piece type attacks which one. Attacks on lesser pieces which are
165 // pawn-defended are not considered.
166 const Score ThreatByMinor[PIECE_TYPE_NB] = {
167 S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
170 const Score ThreatByRook[PIECE_TYPE_NB] = {
171 S(0, 0), S(0, 25), S(40, 62), S(40, 59), S( 0, 34), S(35, 48)
174 // ThreatByKing[on one/on many] contains bonuses for king attacks on
175 // pawns or pieces which are not pawn-defended.
176 const Score ThreatByKing[2] = { S(3, 62), S(9, 138) };
178 // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
179 // We don't use a Score because we process the two components independently.
180 const Value Passed[][RANK_NB] = {
181 { V(5), V( 5), V(31), V(73), V(166), V(252) },
182 { V(7), V(14), V(38), V(73), V(166), V(252) }
185 // PassedFile[File] contains a bonus according to the file of a passed pawn
186 const Score PassedFile[FILE_NB] = {
187 S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
188 S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
191 // Assorted bonuses and penalties used by evaluation
192 const Score MinorBehindPawn = S(16, 0);
193 const Score BishopPawns = S( 8, 12);
194 const Score RookOnPawn = S( 8, 24);
195 const Score TrappedRook = S(92, 0);
196 const Score WeakQueen = S(50, 10);
197 const Score OtherCheck = S(10, 10);
198 const Score CloseEnemies = S( 7, 0);
199 const Score PawnlessFlank = S(20, 80);
200 const Score LooseEnemies = S( 0, 25);
201 const Score ThreatByHangingPawn = S(71, 61);
202 const Score ThreatByRank = S(16, 3);
203 const Score Hanging = S(48, 27);
204 const Score ThreatByPawnPush = S(38, 22);
205 const Score HinderPassedPawn = S( 7, 0);
207 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
208 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
209 // happen in Chess960 games.
210 const Score TrappedBishopA1H1 = S(50, 50);
215 // KingAttackWeights[PieceType] contains king attack weights by piece type
216 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
218 // Penalties for enemy's safe checks
219 const int QueenContactCheck = 997;
220 const int QueenCheck = 745;
221 const int RookCheck = 688;
222 const int BishopCheck = 588;
223 const int KnightCheck = 924;
225 // Threshold for lazy evaluation
226 const Value LazyEval = Value(1500);
228 // eval_init() initializes king and attack bitboards for a given color
229 // adding pawn attacks. To be done at the beginning of the evaluation.
232 void eval_init(const Position& pos, EvalInfo& ei) {
234 const Color Them = (Us == WHITE ? BLACK : WHITE);
235 const Square Up = (Us == WHITE ? NORTH : SOUTH);
236 const Square Down = (Us == WHITE ? SOUTH : NORTH);
237 const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
239 ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
241 // Find our pawns on the first two ranks, and those which are blocked
242 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
244 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
245 // are excluded from the mobility area.
246 ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them));
248 // Initialise the attack bitboards with the king and pawn information
249 b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
250 ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us);
252 ei.attackedBy2[Us] = b & ei.attackedBy[Us][PAWN];
253 ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN];
255 // Init our king safety tables only if we are going to use them
256 if (pos.non_pawn_material(Them) >= QueenValueMg)
258 ei.kingRing[Us] = b | shift<Up>(b);
259 ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them));
260 ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0;
263 ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0;
267 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
270 template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT>
271 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
273 const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
274 const Color Them = (Us == WHITE ? BLACK : WHITE);
275 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
276 : Rank5BB | Rank4BB | Rank3BB);
277 const Square* pl = pos.squares<Pt>(Us);
281 Score score = SCORE_ZERO;
283 ei.attackedBy[Us][Pt] = 0;
285 while ((s = *pl++) != SQ_NONE)
287 // Find attacked squares, including x-ray attacks for bishops and rooks
288 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
289 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
290 : pos.attacks_from<Pt>(s);
292 if (ei.pinnedPieces[Us] & s)
293 b &= LineBB[pos.square<KING>(Us)][s];
295 ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
296 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
298 if (b & ei.kingRing[Them])
300 ei.kingAttackersCount[Us]++;
301 ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
302 ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]);
306 b &= ~( ei.attackedBy[Them][KNIGHT]
307 | ei.attackedBy[Them][BISHOP]
308 | ei.attackedBy[Them][ROOK]);
310 int mob = popcount(b & ei.mobilityArea[Us]);
312 mobility[Us] += MobilityBonus[Pt][mob];
314 if (Pt == BISHOP || Pt == KNIGHT)
316 // Bonus for outpost squares
317 bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them);
319 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)];
322 bb &= b & ~pos.pieces(Us);
324 score += ReachableOutpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)];
327 // Bonus when behind a pawn
328 if ( relative_rank(Us, s) < RANK_5
329 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
330 score += MinorBehindPawn;
332 // Penalty for pawns on the same color square as the bishop
334 score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s);
336 // An important Chess960 pattern: A cornered bishop blocked by a friendly
337 // pawn diagonally in front of it is a very serious problem, especially
338 // when that pawn is also blocked.
341 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
343 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
344 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
345 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
346 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
353 // Bonus for aligning with enemy pawns on the same rank/file
354 if (relative_rank(Us, s) >= RANK_5)
355 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
357 // Bonus when on an open or semi-open file
358 if (ei.pe->semiopen_file(Us, file_of(s)))
359 score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))];
361 // Penalty when trapped by the king, even more if the king cannot castle
364 Square ksq = pos.square<KING>(Us);
366 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
367 && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
368 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
374 // Penalty if any relative pin or discovered attack against the queen
376 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
382 Trace::add(Pt, Us, score);
384 // Recursively call evaluate_pieces() of next piece type until KING is excluded
385 return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
389 Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
391 Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
394 // evaluate_king() assigns bonuses and penalties to a king of a given color
396 const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
398 const Bitboard KingFlank[FILE_NB] = {
399 CenterFiles >> 2, CenterFiles >> 2, CenterFiles >> 2, CenterFiles, CenterFiles,
400 CenterFiles << 2, CenterFiles << 2, CenterFiles << 2
403 template<Color Us, bool DoTrace>
404 Score evaluate_king(const Position& pos, const EvalInfo& ei) {
406 const Color Them = (Us == WHITE ? BLACK : WHITE);
407 const Square Up = (Us == WHITE ? NORTH : SOUTH);
408 const Bitboard Camp = (Us == WHITE ? ~Bitboard(0) ^ Rank6BB ^ Rank7BB ^ Rank8BB
409 : ~Bitboard(0) ^ Rank1BB ^ Rank2BB ^ Rank3BB);
411 const Square ksq = pos.square<KING>(Us);
412 Bitboard undefended, b, b1, b2, safe, other;
415 // King shelter and enemy pawns storm
416 Score score = ei.pe->king_safety<Us>(pos, ksq);
418 // Main king safety evaluation
419 if (ei.kingAttackersCount[Them])
421 // Find the attacked squares which are defended only by our king...
422 undefended = ei.attackedBy[Them][ALL_PIECES]
423 & ei.attackedBy[Us][KING]
424 & ~ei.attackedBy2[Us];
426 // ... and those which are not defended at all in the larger king ring
427 b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
428 & ei.kingRing[Us] & ~pos.pieces(Them);
430 // Initialize the 'kingDanger' variable, which will be transformed
431 // later into a king danger score. The initial value is based on the
432 // number and types of the enemy's attacking pieces, the number of
433 // attacked and undefended squares around our king and the quality of
434 // the pawn shelter (current 'score' value).
435 kingDanger = std::min(807, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
436 + 101 * ei.kingAdjacentZoneAttacksCount[Them]
437 + 235 * popcount(undefended)
438 + 134 * (popcount(b) + !!ei.pinnedPieces[Us])
439 - 717 * !pos.count<QUEEN>(Them)
440 - 7 * mg_value(score) / 5 - 5;
442 // Analyse the enemy's safe queen contact checks. Firstly, find the
443 // undefended squares around our king reachable by the enemy queen...
444 b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
446 // ...and keep squares supported by another enemy piece.
447 kingDanger += QueenContactCheck * popcount(b & ei.attackedBy2[Them]);
449 // Analyse the safe enemy's checks which are possible on next move
450 safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
452 b1 = pos.attacks_from<ROOK >(ksq);
453 b2 = pos.attacks_from<BISHOP>(ksq);
455 // Enemy queen safe checks
456 if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
457 kingDanger += QueenCheck;
459 // For minors and rooks, also consider the square safe if attacked twice,
460 // and only defended by our queen.
461 safe |= ei.attackedBy2[Them]
462 & ~(ei.attackedBy2[Us] | pos.pieces(Them))
463 & ei.attackedBy[Us][QUEEN];
465 // Some other potential checks are also analysed, even from squares
466 // currently occupied by the opponent own pieces, as long as the square
467 // is not attacked by our pawns, and is not occupied by a blocked pawn.
468 other = ~( ei.attackedBy[Us][PAWN]
469 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
471 // Enemy rooks safe and other checks
472 if (b1 & ei.attackedBy[Them][ROOK] & safe)
473 kingDanger += RookCheck;
475 else if (b1 & ei.attackedBy[Them][ROOK] & other)
478 // Enemy bishops safe and other checks
479 if (b2 & ei.attackedBy[Them][BISHOP] & safe)
480 kingDanger += BishopCheck;
482 else if (b2 & ei.attackedBy[Them][BISHOP] & other)
485 // Enemy knights safe and other checks
486 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT];
488 kingDanger += KnightCheck;
493 // Transform the kingDanger units into a Score, and substract it from the evaluation
495 score -= make_score(std::min(kingDanger * kingDanger / 4096, 2 * int(BishopValueMg)), 0);
498 // King tropism: firstly, find squares that opponent attacks in our king flank
499 File kf = file_of(ksq);
500 b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
502 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
503 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
505 // Secondly, add the squares which are attacked twice in that flank and
506 // which are not defended by our pawns.
507 b = (Us == WHITE ? b << 4 : b >> 4)
508 | (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]);
510 score -= CloseEnemies * popcount(b);
512 // Penalty when our king is on a pawnless flank
513 if (!(pos.pieces(PAWN) & KingFlank[kf]))
514 score -= PawnlessFlank;
517 Trace::add(KING, Us, score);
523 // evaluate_threats() assigns bonuses according to the types of the attacking
524 // and the attacked pieces.
526 template<Color Us, bool DoTrace>
527 Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
529 const Color Them = (Us == WHITE ? BLACK : WHITE);
530 const Square Up = (Us == WHITE ? NORTH : SOUTH);
531 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
532 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
533 const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);
534 const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
536 Bitboard b, weak, defended, safeThreats;
537 Score score = SCORE_ZERO;
539 // Small bonus if the opponent has loose pawns or pieces
540 if ( (pos.pieces(Them) ^ pos.pieces(Them, QUEEN, KING))
541 & ~(ei.attackedBy[Us][ALL_PIECES] | ei.attackedBy[Them][ALL_PIECES]))
542 score += LooseEnemies;
544 // Non-pawn enemies attacked by a pawn
545 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
549 b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
550 | ei.attackedBy[Us][ALL_PIECES]);
552 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
554 if (weak ^ safeThreats)
555 score += ThreatByHangingPawn;
558 score += ThreatBySafePawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];
561 // Non-pawn enemies defended by a pawn
562 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
564 // Enemies not defended by a pawn and under our attack
565 weak = pos.pieces(Them)
566 & ~ei.attackedBy[Them][PAWN]
567 & ei.attackedBy[Us][ALL_PIECES];
569 // Add a bonus according to the kind of attacking pieces
572 b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
575 Square s = pop_lsb(&b);
576 score += ThreatByMinor[type_of(pos.piece_on(s))];
577 if (type_of(pos.piece_on(s)) != PAWN)
578 score += ThreatByRank * (int)relative_rank(Them, s);
581 b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
584 Square s = pop_lsb(&b);
585 score += ThreatByRook[type_of(pos.piece_on(s))];
586 if (type_of(pos.piece_on(s)) != PAWN)
587 score += ThreatByRank * (int)relative_rank(Them, s);
590 score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
592 b = weak & ei.attackedBy[Us][KING];
594 score += ThreatByKing[more_than_one(b)];
597 // Bonus if some pawns can safely push and attack an enemy piece
598 b = pos.pieces(Us, PAWN) & ~TRank7BB;
599 b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
602 & ~ei.attackedBy[Them][PAWN]
603 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
605 b = (shift<Left>(b) | shift<Right>(b))
607 & ~ei.attackedBy[Us][PAWN];
609 score += ThreatByPawnPush * popcount(b);
612 Trace::add(THREAT, Us, score);
618 // evaluate_passed_pawns() evaluates the passed pawns of the given color
620 template<Color Us, bool DoTrace>
621 Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
623 const Color Them = (Us == WHITE ? BLACK : WHITE);
625 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
626 Score score = SCORE_ZERO;
628 b = ei.pe->passed_pawns(Us);
632 Square s = pop_lsb(&b);
634 assert(pos.pawn_passed(Us, s));
635 assert(!(pos.pieces(PAWN) & forward_bb(Us, s)));
637 bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
638 score -= HinderPassedPawn * popcount(bb);
640 int r = relative_rank(Us, s) - RANK_2;
641 int rr = r * (r - 1);
643 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
647 Square blockSq = s + pawn_push(Us);
649 // Adjust bonus based on the king's proximity
650 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
651 - distance(pos.square<KING>(Us ), blockSq) * 2 * rr;
653 // If blockSq is not the queening square then consider also a second push
654 if (relative_rank(Us, blockSq) != RANK_8)
655 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
657 // If the pawn is free to advance, then increase the bonus
658 if (pos.empty(blockSq))
660 // If there is a rook or queen attacking/defending the pawn from behind,
661 // consider all the squaresToQueen. Otherwise consider only the squares
662 // in the pawn's path attacked or occupied by the enemy.
663 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
665 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
667 if (!(pos.pieces(Us) & bb))
668 defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
670 if (!(pos.pieces(Them) & bb))
671 unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
673 // If there aren't any enemy attacks, assign a big bonus. Otherwise
674 // assign a smaller bonus if the block square isn't attacked.
675 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
677 // If the path to the queen is fully defended, assign a big bonus.
678 // Otherwise assign a smaller bonus if the block square is defended.
679 if (defendedSquares == squaresToQueen)
682 else if (defendedSquares & blockSq)
685 mbonus += k * rr, ebonus += k * rr;
687 else if (pos.pieces(Us) & blockSq)
688 mbonus += rr + r * 2, ebonus += rr + r * 2;
691 // Assign a small bonus when the opponent has no pieces left
692 if (!pos.non_pawn_material(Them))
695 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
699 Trace::add(PASSED, Us, score);
701 // Add the scores to the middlegame and endgame eval
706 // evaluate_space() computes the space evaluation for a given side. The
707 // space evaluation is a simple bonus based on the number of safe squares
708 // available for minor pieces on the central four files on ranks 2--4. Safe
709 // squares one, two or three squares behind a friendly pawn are counted
710 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
711 // improve play on game opening.
713 Score evaluate_space(const Position& pos, const EvalInfo& ei) {
715 const Color Them = (Us == WHITE ? BLACK : WHITE);
716 const Bitboard SpaceMask =
717 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
718 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
720 // Find the safe squares for our pieces inside the area defined by
721 // SpaceMask. A square is unsafe if it is attacked by an enemy
722 // pawn, or if it is undefended and attacked by an enemy piece.
723 Bitboard safe = SpaceMask
724 & ~pos.pieces(Us, PAWN)
725 & ~ei.attackedBy[Them][PAWN]
726 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
728 // Find all squares which are at most three squares behind some friendly pawn
729 Bitboard behind = pos.pieces(Us, PAWN);
730 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
731 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
733 // Since SpaceMask[Us] is fully on our half of the board...
734 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
736 // ...count safe + (behind & safe) with a single popcount.
737 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
738 bonus = std::min(16, bonus);
739 int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
741 return make_score(bonus * weight * weight / 18, 0);
745 // evaluate_initiative() computes the initiative correction value for the
746 // position, i.e., second order bonus/malus based on the known attacking/defending
747 // status of the players.
748 Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
750 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
751 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
752 int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
754 // Compute the initiative bonus for the attacking side
755 int initiative = 8 * (asymmetry + kingDistance - 15) + 12 * pawns;
757 // Now apply the bonus: note that we find the attacking side by extracting
758 // the sign of the endgame value, and that we carefully cap the bonus so
759 // that the endgame score will never be divided by more than two.
760 int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg / 2));
762 return make_score(0, value);
766 // evaluate_scale_factor() computes the scale factor for the winning side
767 ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
769 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
770 ScaleFactor sf = ei.me->scale_factor(pos, strongSide);
772 // If we don't already have an unusual scale factor, check for certain
773 // types of endgames, and use a lower scale for those.
774 if ( ei.me->game_phase() < PHASE_MIDGAME
775 && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
777 if (pos.opposite_bishops())
779 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
780 // is almost a draw, in case of KBP vs KB, it is even more a draw.
781 if ( pos.non_pawn_material(WHITE) == BishopValueMg
782 && pos.non_pawn_material(BLACK) == BishopValueMg)
783 sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
785 // Endgame with opposite-colored bishops, but also other pieces. Still
786 // a bit drawish, but not as drawish as with only the two bishops.
788 sf = ScaleFactor(46);
790 // Endings where weaker side can place his king in front of the opponent's
791 // pawns are drawish.
792 else if ( abs(eg) <= BishopValueEg
793 && pos.count<PAWN>(strongSide) <= 2
794 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
795 sf = ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
802 Value lazy_eval(Value mg, Value eg) {
804 if (mg > LazyEval && eg > LazyEval)
805 return LazyEval + ((mg + eg) / 2 - LazyEval) / 4;
807 else if (mg < -LazyEval && eg < -LazyEval)
808 return -LazyEval + ((mg + eg) / 2 + LazyEval) / 4;
816 /// evaluate() is the main evaluation function. It returns a static evaluation
817 /// of the position from the point of view of the side to move.
819 template<bool DoTrace>
820 Value Eval::evaluate(const Position& pos) {
822 assert(!pos.checkers());
824 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
827 // Probe the material hash table
828 ei.me = Material::probe(pos);
830 // If we have a specialized evaluation function for the current material
831 // configuration, call it and return.
832 if (ei.me->specialized_eval_exists())
833 return ei.me->evaluate(pos);
835 // Initialize score by reading the incrementally updated scores included in
836 // the position object (material + piece square tables) and the material
837 // imbalance. Score is computed internally from the white point of view.
838 Score score = pos.psq_score() + ei.me->imbalance();
840 // Probe the pawn hash table
841 ei.pe = Pawns::probe(pos);
842 score += ei.pe->pawns_score();
844 // We have taken into account all cheap evaluation terms.
845 // If score exceeds a threshold return a lazy evaluation.
846 Value lazy = lazy_eval(mg_value(score), eg_value(score));
848 return pos.side_to_move() == WHITE ? lazy : -lazy;
850 // Initialize attack and king safety bitboards
851 eval_init<WHITE>(pos, ei);
852 eval_init<BLACK>(pos, ei);
854 // Evaluate all pieces but king and pawns
855 score += evaluate_pieces<DoTrace>(pos, ei, mobility);
856 score += mobility[WHITE] - mobility[BLACK];
858 // Evaluate kings after all other pieces because we need full attack
859 // information when computing the king safety evaluation.
860 score += evaluate_king<WHITE, DoTrace>(pos, ei)
861 - evaluate_king<BLACK, DoTrace>(pos, ei);
863 // Evaluate tactical threats, we need full attack information including king
864 score += evaluate_threats<WHITE, DoTrace>(pos, ei)
865 - evaluate_threats<BLACK, DoTrace>(pos, ei);
867 // Evaluate passed pawns, we need full attack information including king
868 score += evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)
869 - evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);
871 // Evaluate space for both sides, only during opening
872 if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
873 score += evaluate_space<WHITE>(pos, ei)
874 - evaluate_space<BLACK>(pos, ei);
876 // Evaluate position potential for the winning side
877 score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
879 // Evaluate scale factor for the winning side
880 ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
882 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
883 Value v = mg_value(score) * int(ei.me->game_phase())
884 + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
886 v /= int(PHASE_MIDGAME);
888 // In case of tracing add all remaining individual evaluation terms
891 Trace::add(MATERIAL, pos.psq_score());
892 Trace::add(IMBALANCE, ei.me->imbalance());
893 Trace::add(PAWN, ei.pe->pawns_score());
894 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
895 if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
896 Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
897 , evaluate_space<BLACK>(pos, ei));
898 Trace::add(TOTAL, score);
901 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
904 // Explicit template instantiations
905 template Value Eval::evaluate<true >(const Position&);
906 template Value Eval::evaluate<false>(const Position&);
909 /// trace() is like evaluate(), but instead of returning a value, it returns
910 /// a string (suitable for outputting to stdout) that contains the detailed
911 /// descriptions and values of each evaluation term. Useful for debugging.
913 std::string Eval::trace(const Position& pos) {
915 std::memset(scores, 0, sizeof(scores));
917 Value v = evaluate<true>(pos);
918 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
920 std::stringstream ss;
921 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
922 << " Eval term | White | Black | Total \n"
923 << " | MG EG | MG EG | MG EG \n"
924 << "----------------+-------------+-------------+-------------\n"
925 << " Material | " << Term(MATERIAL)
926 << " Imbalance | " << Term(IMBALANCE)
927 << " Pawns | " << Term(PAWN)
928 << " Knights | " << Term(KNIGHT)
929 << " Bishop | " << Term(BISHOP)
930 << " Rooks | " << Term(ROOK)
931 << " Queens | " << Term(QUEEN)
932 << " Mobility | " << Term(MOBILITY)
933 << " King safety | " << Term(KING)
934 << " Threats | " << Term(THREAT)
935 << " Passed pawns | " << Term(PASSED)
936 << " Space | " << Term(SPACE)
937 << "----------------+-------------+-------------+-------------\n"
938 << " Total | " << Term(TOTAL);
940 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";