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[4][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[2] = { 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[2] = { 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[4][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 = 745;
215 const int RookCheck = 688;
216 const int BishopCheck = 588;
217 const int KnightCheck = 924;
219 // Threshold for lazy evaluation
220 const Value LazyThreshold = Value(1500);
222 // eval_init() initializes king and attack bitboards for a given color
223 // adding pawn attacks. To be done at the beginning of the evaluation.
226 void eval_init(const Position& pos, EvalInfo& ei) {
228 const Color Them = (Us == WHITE ? BLACK : WHITE);
229 const Square Up = (Us == WHITE ? NORTH : SOUTH);
230 const Square Down = (Us == WHITE ? SOUTH : NORTH);
231 const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
233 // Find our pawns on the first two ranks, and those which are blocked
234 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
236 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
237 // are excluded from the mobility area.
238 ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them));
240 // Initialise the attack bitboards with the king and pawn information
241 b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
242 ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us);
244 ei.attackedBy2[Us] = b & ei.attackedBy[Us][PAWN];
245 ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN];
247 // Init our king safety tables only if we are going to use them
248 if (pos.non_pawn_material(Them) >= QueenValueMg)
250 ei.kingRing[Us] = b | shift<Up>(b);
251 ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them));
252 ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0;
255 ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0;
259 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
262 template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT>
263 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
265 const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
266 const Color Them = (Us == WHITE ? BLACK : WHITE);
267 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
268 : Rank5BB | Rank4BB | Rank3BB);
269 const Square* pl = pos.squares<Pt>(Us);
273 Score score = SCORE_ZERO;
275 ei.attackedBy[Us][Pt] = 0;
277 while ((s = *pl++) != SQ_NONE)
279 // Find attacked squares, including x-ray attacks for bishops and rooks
280 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
281 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
282 : pos.attacks_from<Pt>(s);
284 if (pos.pinned_pieces(Us) & s)
285 b &= LineBB[pos.square<KING>(Us)][s];
287 ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
288 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
290 if (b & ei.kingRing[Them])
292 ei.kingAttackersCount[Us]++;
293 ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
294 ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]);
297 int mob = popcount(b & ei.mobilityArea[Us]);
299 mobility[Us] += MobilityBonus[Pt-2][mob];
301 // Bonus for this piece as a king protector
302 score += Protector[Pt-2][distance(s, pos.square<KING>(Us))];
304 if (Pt == BISHOP || Pt == KNIGHT)
306 // Bonus for outpost squares
307 bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them);
309 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2;
312 bb &= b & ~pos.pieces(Us);
314 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)];
317 // Bonus when behind a pawn
318 if ( relative_rank(Us, s) < RANK_5
319 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
320 score += MinorBehindPawn;
322 // Penalty for pawns on the same color square as the bishop
324 score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s);
326 // An important Chess960 pattern: A cornered bishop blocked by a friendly
327 // pawn diagonally in front of it is a very serious problem, especially
328 // when that pawn is also blocked.
331 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
333 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
334 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
335 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
336 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
343 // Bonus for aligning with enemy pawns on the same rank/file
344 if (relative_rank(Us, s) >= RANK_5)
345 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
347 // Bonus when on an open or semi-open file
348 if (ei.pe->semiopen_file(Us, file_of(s)))
349 score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))];
351 // Penalty when trapped by the king, even more if the king cannot castle
354 Square ksq = pos.square<KING>(Us);
356 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
357 && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
358 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
364 // Penalty if any relative pin or discovered attack against the queen
366 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
372 Trace::add(Pt, Us, score);
374 // Recursively call evaluate_pieces() of next piece type until KING is excluded
375 return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
379 Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
381 Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
384 // evaluate_king() assigns bonuses and penalties to a king of a given color
386 const Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
387 const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
388 const Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
390 const Bitboard KingFlank[FILE_NB] = {
391 QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide
394 template<Color Us, bool DoTrace>
395 Score evaluate_king(const Position& pos, const EvalInfo& ei) {
397 const Color Them = (Us == WHITE ? BLACK : WHITE);
398 const Square Up = (Us == WHITE ? NORTH : SOUTH);
399 const Bitboard Camp = (Us == WHITE ? ~Bitboard(0) ^ Rank6BB ^ Rank7BB ^ Rank8BB
400 : ~Bitboard(0) ^ Rank1BB ^ Rank2BB ^ Rank3BB);
402 const Square ksq = pos.square<KING>(Us);
403 Bitboard undefended, b, b1, b2, safe, other;
406 // King shelter and enemy pawns storm
407 Score score = ei.pe->king_safety<Us>(pos, ksq);
409 // Main king safety evaluation
410 if (ei.kingAttackersCount[Them])
412 // Find the attacked squares which are defended only by our king...
413 undefended = ei.attackedBy[Them][ALL_PIECES]
414 & ei.attackedBy[Us][KING]
415 & ~ei.attackedBy2[Us];
417 // ... and those which are not defended at all in the larger king ring
418 b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
419 & ei.kingRing[Us] & ~pos.pieces(Them);
421 // Initialize the 'kingDanger' variable, which will be transformed
422 // later into a king danger score. The initial value is based on the
423 // number and types of the enemy's attacking pieces, the number of
424 // attacked and undefended squares around our king and the quality of
425 // the pawn shelter (current 'score' value).
426 kingDanger = std::min(807, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
427 + 101 * ei.kingAdjacentZoneAttacksCount[Them]
428 + 235 * popcount(undefended)
429 + 134 * (popcount(b) + !!pos.pinned_pieces(Us))
430 - 717 * !pos.count<QUEEN>(Them)
431 - 7 * mg_value(score) / 5 - 5;
433 // Analyse the safe enemy's checks which are possible on next move
434 safe = ~pos.pieces(Them);
435 safe &= ~ei.attackedBy[Us][ALL_PIECES] | (undefended & ei.attackedBy2[Them]);
437 b1 = pos.attacks_from<ROOK >(ksq);
438 b2 = pos.attacks_from<BISHOP>(ksq);
440 // Enemy queen safe checks
441 if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
442 kingDanger += QueenCheck;
444 // For minors and rooks, also consider the square safe if attacked twice,
445 // and only defended by our queen.
446 safe |= ei.attackedBy2[Them]
447 & ~(ei.attackedBy2[Us] | pos.pieces(Them))
448 & ei.attackedBy[Us][QUEEN];
450 // Some other potential checks are also analysed, even from squares
451 // currently occupied by the opponent own pieces, as long as the square
452 // is not attacked by our pawns, and is not occupied by a blocked pawn.
453 other = ~( ei.attackedBy[Us][PAWN]
454 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
456 // Enemy rooks safe and other checks
457 if (b1 & ei.attackedBy[Them][ROOK] & safe)
458 kingDanger += RookCheck;
460 else if (b1 & ei.attackedBy[Them][ROOK] & other)
463 // Enemy bishops safe and other checks
464 if (b2 & ei.attackedBy[Them][BISHOP] & safe)
465 kingDanger += BishopCheck;
467 else if (b2 & ei.attackedBy[Them][BISHOP] & other)
470 // Enemy knights safe and other checks
471 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT];
473 kingDanger += KnightCheck;
478 // Transform the kingDanger units into a Score, and substract it from the evaluation
480 score -= make_score(std::min(kingDanger * kingDanger / 4096, 2 * int(BishopValueMg)), 0);
483 // King tropism: firstly, find squares that opponent attacks in our king flank
484 File kf = file_of(ksq);
485 b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
487 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
488 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
490 // Secondly, add the squares which are attacked twice in that flank and
491 // which are not defended by our pawns.
492 b = (Us == WHITE ? b << 4 : b >> 4)
493 | (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]);
495 score -= CloseEnemies * popcount(b);
497 // Penalty when our king is on a pawnless flank
498 if (!(pos.pieces(PAWN) & KingFlank[kf]))
499 score -= PawnlessFlank;
502 Trace::add(KING, Us, score);
508 // evaluate_threats() assigns bonuses according to the types of the attacking
509 // and the attacked pieces.
511 template<Color Us, bool DoTrace>
512 Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
514 const Color Them = (Us == WHITE ? BLACK : WHITE);
515 const Square Up = (Us == WHITE ? NORTH : SOUTH);
516 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
517 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
518 const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);
519 const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
521 Bitboard b, weak, defended, stronglyProtected, safeThreats;
522 Score score = SCORE_ZERO;
524 // Non-pawn enemies attacked by a pawn
525 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
529 b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
530 | ei.attackedBy[Us][ALL_PIECES]);
532 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
534 if (weak ^ safeThreats)
535 score += ThreatByHangingPawn;
537 score += ThreatBySafePawn * popcount(safeThreats);
540 // Squares strongly protected by the opponent, either because they attack the
541 // square with a pawn, or because they attack the square twice and we don't.
542 stronglyProtected = ei.attackedBy[Them][PAWN]
543 | (ei.attackedBy2[Them] & ~ei.attackedBy2[Us]);
545 // Non-pawn enemies, strongly protected
546 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
549 // Enemies not strongly protected and under our attack
550 weak = pos.pieces(Them)
552 & ei.attackedBy[Us][ALL_PIECES];
554 // Add a bonus according to the kind of attacking pieces
557 b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
560 Square s = pop_lsb(&b);
561 score += ThreatByMinor[type_of(pos.piece_on(s))];
562 if (type_of(pos.piece_on(s)) != PAWN)
563 score += ThreatByRank * (int)relative_rank(Them, s);
566 b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
569 Square s = pop_lsb(&b);
570 score += ThreatByRook[type_of(pos.piece_on(s))];
571 if (type_of(pos.piece_on(s)) != PAWN)
572 score += ThreatByRank * (int)relative_rank(Them, s);
575 score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
577 b = weak & ei.attackedBy[Us][KING];
579 score += ThreatByKing[more_than_one(b)];
582 // Bonus if some pawns can safely push and attack an enemy piece
583 b = pos.pieces(Us, PAWN) & ~TRank7BB;
584 b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
587 & ~ei.attackedBy[Them][PAWN]
588 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
590 b = (shift<Left>(b) | shift<Right>(b))
592 & ~ei.attackedBy[Us][PAWN];
594 score += ThreatByPawnPush * popcount(b);
597 Trace::add(THREAT, Us, score);
603 // evaluate_passer_pawns() evaluates the passed pawns and candidate passed
604 // pawns of the given color.
606 template<Color Us, bool DoTrace>
607 Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) {
609 const Color Them = (Us == WHITE ? BLACK : WHITE);
611 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
612 Score score = SCORE_ZERO;
614 b = ei.pe->passed_pawns(Us);
618 Square s = pop_lsb(&b);
620 assert(!(pos.pieces(PAWN) & forward_bb(Us, s)));
622 bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
623 score -= HinderPassedPawn * popcount(bb);
625 int r = relative_rank(Us, s) - RANK_2;
626 int rr = r * (r - 1);
628 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
632 Square blockSq = s + pawn_push(Us);
634 // Adjust bonus based on the king's proximity
635 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
636 - distance(pos.square<KING>(Us ), blockSq) * 2 * rr;
638 // If blockSq is not the queening square then consider also a second push
639 if (relative_rank(Us, blockSq) != RANK_8)
640 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
642 // If the pawn is free to advance, then increase the bonus
643 if (pos.empty(blockSq))
645 // If there is a rook or queen attacking/defending the pawn from behind,
646 // consider all the squaresToQueen. Otherwise consider only the squares
647 // in the pawn's path attacked or occupied by the enemy.
648 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
650 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
652 if (!(pos.pieces(Us) & bb))
653 defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
655 if (!(pos.pieces(Them) & bb))
656 unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
658 // If there aren't any enemy attacks, assign a big bonus. Otherwise
659 // assign a smaller bonus if the block square isn't attacked.
660 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
662 // If the path to the queen is fully defended, assign a big bonus.
663 // Otherwise assign a smaller bonus if the block square is defended.
664 if (defendedSquares == squaresToQueen)
667 else if (defendedSquares & blockSq)
670 mbonus += k * rr, ebonus += k * rr;
672 else if (pos.pieces(Us) & blockSq)
673 mbonus += rr + r * 2, ebonus += rr + r * 2;
676 // Scale down bonus for candidate passers which need more than one
677 // pawn push to become passed.
678 if (!pos.pawn_passed(Us, s + pawn_push(Us)))
679 mbonus /= 2, ebonus /= 2;
681 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
685 Trace::add(PASSED, Us, score);
691 // evaluate_space() computes the space evaluation for a given side. The
692 // space evaluation is a simple bonus based on the number of safe squares
693 // available for minor pieces on the central four files on ranks 2--4. Safe
694 // squares one, two or three squares behind a friendly pawn are counted
695 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
696 // improve play on game opening.
698 Score evaluate_space(const Position& pos, const EvalInfo& ei) {
700 const Color Them = (Us == WHITE ? BLACK : WHITE);
701 const Bitboard SpaceMask =
702 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
703 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
705 // Find the safe squares for our pieces inside the area defined by
706 // SpaceMask. A square is unsafe if it is attacked by an enemy
707 // pawn, or if it is undefended and attacked by an enemy piece.
708 Bitboard safe = SpaceMask
709 & ~pos.pieces(Us, PAWN)
710 & ~ei.attackedBy[Them][PAWN]
711 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
713 // Find all squares which are at most three squares behind some friendly pawn
714 Bitboard behind = pos.pieces(Us, PAWN);
715 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
716 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
718 // Since SpaceMask[Us] is fully on our half of the board...
719 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
721 // ...count safe + (behind & safe) with a single popcount.
722 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
723 bonus = std::min(16, bonus);
724 int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
726 return make_score(bonus * weight * weight / 18, 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() >= 12222)
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() >= 12222)
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";