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 minor
139 // pieces if they can reach an outpost square, bigger if that square is
140 // supported by a pawn. If the minor piece occupies an outpost square
141 // then score is doubled.
142 const Score Outpost[][2] = {
143 { S(22, 6), S(33, 9) }, // Knight
144 { S( 9, 2), S(14, 4) } // Bishop
147 // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
148 // friendly pawn on the rook file.
149 const Score RookOnFile[2] = { S(20, 7), S(45, 20) };
151 // ThreatBySafePawn[PieceType] contains bonuses according to which piece
152 // type is attacked by a pawn which is protected or is not attacked.
153 const Score ThreatBySafePawn[PIECE_TYPE_NB] = {
154 S(0, 0), S(0, 0), S(176, 139), S(131, 127), S(217, 218), S(203, 215)
157 // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
158 // which piece type attacks which one. Attacks on lesser pieces which are
159 // pawn-defended are not considered.
160 const Score ThreatByMinor[PIECE_TYPE_NB] = {
161 S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
164 const Score ThreatByRook[PIECE_TYPE_NB] = {
165 S(0, 0), S(0, 25), S(40, 62), S(40, 59), S( 0, 34), S(35, 48)
168 // ThreatByKing[on one/on many] contains bonuses for king attacks on
169 // pawns or pieces which are not pawn-defended.
170 const Score ThreatByKing[2] = { S(3, 62), S(9, 138) };
172 // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
173 // We don't use a Score because we process the two components independently.
174 const Value Passed[][RANK_NB] = {
175 { V(5), V( 5), V(31), V(73), V(166), V(252) },
176 { V(7), V(14), V(38), V(73), V(166), V(252) }
179 // PassedFile[File] contains a bonus according to the file of a passed pawn
180 const Score PassedFile[FILE_NB] = {
181 S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
182 S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
185 // Assorted bonuses and penalties used by evaluation
186 const Score MinorBehindPawn = S(16, 0);
187 const Score BishopPawns = S( 8, 12);
188 const Score RookOnPawn = S( 8, 24);
189 const Score TrappedRook = S(92, 0);
190 const Score WeakQueen = S(50, 10);
191 const Score OtherCheck = S(10, 10);
192 const Score CloseEnemies = S( 7, 0);
193 const Score PawnlessFlank = S(20, 80);
194 const Score LooseEnemies = S( 0, 25);
195 const Score ThreatByHangingPawn = S(71, 61);
196 const Score ThreatByRank = S(16, 3);
197 const Score Hanging = S(48, 27);
198 const Score ThreatByPawnPush = S(38, 22);
199 const Score HinderPassedPawn = S( 7, 0);
201 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
202 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
203 // happen in Chess960 games.
204 const Score TrappedBishopA1H1 = S(50, 50);
209 // KingAttackWeights[PieceType] contains king attack weights by piece type
210 const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
212 // Penalties for enemy's safe checks
213 const int QueenContactCheck = 997;
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 LazyEval = 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 ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
235 // Find our pawns on the first two ranks, and those which are blocked
236 Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
238 // Squares occupied by those pawns, by our king, or controlled by enemy pawns
239 // are excluded from the mobility area.
240 ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them));
242 // Initialise the attack bitboards with the king and pawn information
243 b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
244 ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us);
246 ei.attackedBy2[Us] = b & ei.attackedBy[Us][PAWN];
247 ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN];
249 // Init our king safety tables only if we are going to use them
250 if (pos.non_pawn_material(Them) >= QueenValueMg)
252 ei.kingRing[Us] = b | shift<Up>(b);
253 ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them));
254 ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0;
257 ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0;
261 // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
264 template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT>
265 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
267 const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
268 const Color Them = (Us == WHITE ? BLACK : WHITE);
269 const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
270 : Rank5BB | Rank4BB | Rank3BB);
271 const Square* pl = pos.squares<Pt>(Us);
275 Score score = SCORE_ZERO;
277 ei.attackedBy[Us][Pt] = 0;
279 while ((s = *pl++) != SQ_NONE)
281 // Find attacked squares, including x-ray attacks for bishops and rooks
282 b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
283 : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
284 : pos.attacks_from<Pt>(s);
286 if (ei.pinnedPieces[Us] & s)
287 b &= LineBB[pos.square<KING>(Us)][s];
289 ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
290 ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
292 if (b & ei.kingRing[Them])
294 ei.kingAttackersCount[Us]++;
295 ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
296 ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]);
300 b &= ~( ei.attackedBy[Them][KNIGHT]
301 | ei.attackedBy[Them][BISHOP]
302 | ei.attackedBy[Them][ROOK]);
304 int mob = popcount(b & ei.mobilityArea[Us]);
306 mobility[Us] += MobilityBonus[Pt][mob];
308 if (Pt == BISHOP || Pt == KNIGHT)
310 // Bonus for outpost squares
311 bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them);
313 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2;
316 bb &= b & ~pos.pieces(Us);
318 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)];
321 // Bonus when behind a pawn
322 if ( relative_rank(Us, s) < RANK_5
323 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
324 score += MinorBehindPawn;
326 // Penalty for pawns on the same color square as the bishop
328 score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s);
330 // An important Chess960 pattern: A cornered bishop blocked by a friendly
331 // pawn diagonally in front of it is a very serious problem, especially
332 // when that pawn is also blocked.
335 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
337 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
338 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
339 score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
340 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
347 // Bonus for aligning with enemy pawns on the same rank/file
348 if (relative_rank(Us, s) >= RANK_5)
349 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
351 // Bonus when on an open or semi-open file
352 if (ei.pe->semiopen_file(Us, file_of(s)))
353 score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))];
355 // Penalty when trapped by the king, even more if the king cannot castle
358 Square ksq = pos.square<KING>(Us);
360 if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
361 && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
362 score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
368 // Penalty if any relative pin or discovered attack against the queen
370 if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
376 Trace::add(Pt, Us, score);
378 // Recursively call evaluate_pieces() of next piece type until KING is excluded
379 return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
383 Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
385 Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
388 // evaluate_king() assigns bonuses and penalties to a king of a given color
390 const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
392 const Bitboard KingFlank[FILE_NB] = {
393 CenterFiles >> 2, CenterFiles >> 2, CenterFiles >> 2, CenterFiles, CenterFiles,
394 CenterFiles << 2, CenterFiles << 2, CenterFiles << 2
397 template<Color Us, bool DoTrace>
398 Score evaluate_king(const Position& pos, const EvalInfo& ei) {
400 const Color Them = (Us == WHITE ? BLACK : WHITE);
401 const Square Up = (Us == WHITE ? NORTH : SOUTH);
402 const Bitboard Camp = (Us == WHITE ? ~Bitboard(0) ^ Rank6BB ^ Rank7BB ^ Rank8BB
403 : ~Bitboard(0) ^ Rank1BB ^ Rank2BB ^ Rank3BB);
405 const Square ksq = pos.square<KING>(Us);
406 Bitboard undefended, b, b1, b2, safe, other;
409 // King shelter and enemy pawns storm
410 Score score = ei.pe->king_safety<Us>(pos, ksq);
412 // Main king safety evaluation
413 if (ei.kingAttackersCount[Them])
415 // Find the attacked squares which are defended only by our king...
416 undefended = ei.attackedBy[Them][ALL_PIECES]
417 & ei.attackedBy[Us][KING]
418 & ~ei.attackedBy2[Us];
420 // ... and those which are not defended at all in the larger king ring
421 b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
422 & ei.kingRing[Us] & ~pos.pieces(Them);
424 // Initialize the 'kingDanger' variable, which will be transformed
425 // later into a king danger score. The initial value is based on the
426 // number and types of the enemy's attacking pieces, the number of
427 // attacked and undefended squares around our king and the quality of
428 // the pawn shelter (current 'score' value).
429 kingDanger = std::min(807, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
430 + 101 * ei.kingAdjacentZoneAttacksCount[Them]
431 + 235 * popcount(undefended)
432 + 134 * (popcount(b) + !!ei.pinnedPieces[Us])
433 - 717 * !pos.count<QUEEN>(Them)
434 - 7 * mg_value(score) / 5 - 5;
436 // Analyse the enemy's safe queen contact checks. Firstly, find the
437 // undefended squares around our king reachable by the enemy queen...
438 b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
440 // ...and keep squares supported by another enemy piece.
441 kingDanger += QueenContactCheck * popcount(b & ei.attackedBy2[Them]);
443 // Analyse the safe enemy's checks which are possible on next move
444 safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
446 b1 = pos.attacks_from<ROOK >(ksq);
447 b2 = pos.attacks_from<BISHOP>(ksq);
449 // Enemy queen safe checks
450 if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
451 kingDanger += QueenCheck;
453 // For minors and rooks, also consider the square safe if attacked twice,
454 // and only defended by our queen.
455 safe |= ei.attackedBy2[Them]
456 & ~(ei.attackedBy2[Us] | pos.pieces(Them))
457 & ei.attackedBy[Us][QUEEN];
459 // Some other potential checks are also analysed, even from squares
460 // currently occupied by the opponent own pieces, as long as the square
461 // is not attacked by our pawns, and is not occupied by a blocked pawn.
462 other = ~( ei.attackedBy[Us][PAWN]
463 | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
465 // Enemy rooks safe and other checks
466 if (b1 & ei.attackedBy[Them][ROOK] & safe)
467 kingDanger += RookCheck;
469 else if (b1 & ei.attackedBy[Them][ROOK] & other)
472 // Enemy bishops safe and other checks
473 if (b2 & ei.attackedBy[Them][BISHOP] & safe)
474 kingDanger += BishopCheck;
476 else if (b2 & ei.attackedBy[Them][BISHOP] & other)
479 // Enemy knights safe and other checks
480 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT];
482 kingDanger += KnightCheck;
487 // Transform the kingDanger units into a Score, and substract it from the evaluation
489 score -= make_score(std::min(kingDanger * kingDanger / 4096, 2 * int(BishopValueMg)), 0);
492 // King tropism: firstly, find squares that opponent attacks in our king flank
493 File kf = file_of(ksq);
494 b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
496 assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
497 assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
499 // Secondly, add the squares which are attacked twice in that flank and
500 // which are not defended by our pawns.
501 b = (Us == WHITE ? b << 4 : b >> 4)
502 | (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]);
504 score -= CloseEnemies * popcount(b);
506 // Penalty when our king is on a pawnless flank
507 if (!(pos.pieces(PAWN) & KingFlank[kf]))
508 score -= PawnlessFlank;
511 Trace::add(KING, Us, score);
517 // evaluate_threats() assigns bonuses according to the types of the attacking
518 // and the attacked pieces.
520 template<Color Us, bool DoTrace>
521 Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
523 const Color Them = (Us == WHITE ? BLACK : WHITE);
524 const Square Up = (Us == WHITE ? NORTH : SOUTH);
525 const Square Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
526 const Square Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
527 const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);
528 const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
530 Bitboard b, weak, defended, safeThreats;
531 Score score = SCORE_ZERO;
533 // Small bonus if the opponent has loose pawns or pieces
534 if ( (pos.pieces(Them) ^ pos.pieces(Them, QUEEN, KING))
535 & ~(ei.attackedBy[Us][ALL_PIECES] | ei.attackedBy[Them][ALL_PIECES]))
536 score += LooseEnemies;
538 // Non-pawn enemies attacked by a pawn
539 weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
543 b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
544 | ei.attackedBy[Us][ALL_PIECES]);
546 safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
548 if (weak ^ safeThreats)
549 score += ThreatByHangingPawn;
552 score += ThreatBySafePawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];
555 // Non-pawn enemies defended by a pawn
556 defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
558 // Enemies not defended by a pawn and under our attack
559 weak = pos.pieces(Them)
560 & ~ei.attackedBy[Them][PAWN]
561 & ei.attackedBy[Us][ALL_PIECES];
563 // Add a bonus according to the kind of attacking pieces
566 b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
569 Square s = pop_lsb(&b);
570 score += ThreatByMinor[type_of(pos.piece_on(s))];
571 if (type_of(pos.piece_on(s)) != PAWN)
572 score += ThreatByRank * (int)relative_rank(Them, s);
575 b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
578 Square s = pop_lsb(&b);
579 score += ThreatByRook[type_of(pos.piece_on(s))];
580 if (type_of(pos.piece_on(s)) != PAWN)
581 score += ThreatByRank * (int)relative_rank(Them, s);
584 score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
586 b = weak & ei.attackedBy[Us][KING];
588 score += ThreatByKing[more_than_one(b)];
591 // Bonus if some pawns can safely push and attack an enemy piece
592 b = pos.pieces(Us, PAWN) & ~TRank7BB;
593 b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
596 & ~ei.attackedBy[Them][PAWN]
597 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
599 b = (shift<Left>(b) | shift<Right>(b))
601 & ~ei.attackedBy[Us][PAWN];
603 score += ThreatByPawnPush * popcount(b);
606 Trace::add(THREAT, Us, score);
612 // evaluate_passed_pawns() evaluates the passed pawns of the given color
614 template<Color Us, bool DoTrace>
615 Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
617 const Color Them = (Us == WHITE ? BLACK : WHITE);
619 Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
620 Score score = SCORE_ZERO;
622 b = ei.pe->passed_pawns(Us);
626 Square s = pop_lsb(&b);
628 assert(pos.pawn_passed(Us, s));
629 assert(!(pos.pieces(PAWN) & forward_bb(Us, s)));
631 bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
632 score -= HinderPassedPawn * popcount(bb);
634 int r = relative_rank(Us, s) - RANK_2;
635 int rr = r * (r - 1);
637 Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
641 Square blockSq = s + pawn_push(Us);
643 // Adjust bonus based on the king's proximity
644 ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr
645 - distance(pos.square<KING>(Us ), blockSq) * 2 * rr;
647 // If blockSq is not the queening square then consider also a second push
648 if (relative_rank(Us, blockSq) != RANK_8)
649 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
651 // If the pawn is free to advance, then increase the bonus
652 if (pos.empty(blockSq))
654 // If there is a rook or queen attacking/defending the pawn from behind,
655 // consider all the squaresToQueen. Otherwise consider only the squares
656 // in the pawn's path attacked or occupied by the enemy.
657 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
659 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
661 if (!(pos.pieces(Us) & bb))
662 defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
664 if (!(pos.pieces(Them) & bb))
665 unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
667 // If there aren't any enemy attacks, assign a big bonus. Otherwise
668 // assign a smaller bonus if the block square isn't attacked.
669 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
671 // If the path to the queen is fully defended, assign a big bonus.
672 // Otherwise assign a smaller bonus if the block square is defended.
673 if (defendedSquares == squaresToQueen)
676 else if (defendedSquares & blockSq)
679 mbonus += k * rr, ebonus += k * rr;
681 else if (pos.pieces(Us) & blockSq)
682 mbonus += rr + r * 2, ebonus += rr + r * 2;
685 // Assign a small bonus when the opponent has no pieces left
686 if (!pos.non_pawn_material(Them))
689 score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
693 Trace::add(PASSED, Us, score);
695 // Add the scores to the middlegame and endgame eval
700 // evaluate_space() computes the space evaluation for a given side. The
701 // space evaluation is a simple bonus based on the number of safe squares
702 // available for minor pieces on the central four files on ranks 2--4. Safe
703 // squares one, two or three squares behind a friendly pawn are counted
704 // twice. Finally, the space bonus is multiplied by a weight. The aim is to
705 // improve play on game opening.
707 Score evaluate_space(const Position& pos, const EvalInfo& ei) {
709 const Color Them = (Us == WHITE ? BLACK : WHITE);
710 const Bitboard SpaceMask =
711 Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
712 : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
714 // Find the safe squares for our pieces inside the area defined by
715 // SpaceMask. A square is unsafe if it is attacked by an enemy
716 // pawn, or if it is undefended and attacked by an enemy piece.
717 Bitboard safe = SpaceMask
718 & ~pos.pieces(Us, PAWN)
719 & ~ei.attackedBy[Them][PAWN]
720 & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
722 // Find all squares which are at most three squares behind some friendly pawn
723 Bitboard behind = pos.pieces(Us, PAWN);
724 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
725 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
727 // Since SpaceMask[Us] is fully on our half of the board...
728 assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
730 // ...count safe + (behind & safe) with a single popcount.
731 int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
732 bonus = std::min(16, bonus);
733 int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
735 return make_score(bonus * weight * weight / 18, 0);
739 // evaluate_initiative() computes the initiative correction value for the
740 // position, i.e., second order bonus/malus based on the known attacking/defending
741 // status of the players.
742 Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
744 int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
745 - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
746 int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
748 // Compute the initiative bonus for the attacking side
749 int initiative = 8 * (asymmetry + kingDistance - 15) + 12 * pawns;
751 // Now apply the bonus: note that we find the attacking side by extracting
752 // the sign of the endgame value, and that we carefully cap the bonus so
753 // that the endgame score will never be divided by more than two.
754 int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg / 2));
756 return make_score(0, value);
760 // evaluate_scale_factor() computes the scale factor for the winning side
761 ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
763 Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
764 ScaleFactor sf = ei.me->scale_factor(pos, strongSide);
766 // If we don't already have an unusual scale factor, check for certain
767 // types of endgames, and use a lower scale for those.
768 if ( ei.me->game_phase() < PHASE_MIDGAME
769 && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
771 if (pos.opposite_bishops())
773 // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
774 // is almost a draw, in case of KBP vs KB, it is even more a draw.
775 if ( pos.non_pawn_material(WHITE) == BishopValueMg
776 && pos.non_pawn_material(BLACK) == BishopValueMg)
777 sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
779 // Endgame with opposite-colored bishops, but also other pieces. Still
780 // a bit drawish, but not as drawish as with only the two bishops.
782 sf = ScaleFactor(46);
784 // Endings where weaker side can place his king in front of the opponent's
785 // pawns are drawish.
786 else if ( abs(eg) <= BishopValueEg
787 && pos.count<PAWN>(strongSide) <= 2
788 && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
789 sf = ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
796 Value lazy_eval(Value mg, Value eg) {
798 if (mg > LazyEval && eg > LazyEval)
799 return LazyEval + ((mg + eg) / 2 - LazyEval) / 4;
801 else if (mg < -LazyEval && eg < -LazyEval)
802 return -LazyEval + ((mg + eg) / 2 + LazyEval) / 4;
810 /// evaluate() is the main evaluation function. It returns a static evaluation
811 /// of the position from the point of view of the side to move.
813 template<bool DoTrace>
814 Value Eval::evaluate(const Position& pos) {
816 assert(!pos.checkers());
818 Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
821 // Probe the material hash table
822 ei.me = Material::probe(pos);
824 // If we have a specialized evaluation function for the current material
825 // configuration, call it and return.
826 if (ei.me->specialized_eval_exists())
827 return ei.me->evaluate(pos);
829 // Initialize score by reading the incrementally updated scores included in
830 // the position object (material + piece square tables) and the material
831 // imbalance. Score is computed internally from the white point of view.
832 Score score = pos.psq_score() + ei.me->imbalance();
834 // Probe the pawn hash table
835 ei.pe = Pawns::probe(pos);
836 score += ei.pe->pawns_score();
838 // We have taken into account all cheap evaluation terms.
839 // If score exceeds a threshold return a lazy evaluation.
840 Value lazy = lazy_eval(mg_value(score), eg_value(score));
842 return pos.side_to_move() == WHITE ? lazy : -lazy;
844 // Initialize attack and king safety bitboards
845 eval_init<WHITE>(pos, ei);
846 eval_init<BLACK>(pos, ei);
848 // Evaluate all pieces but king and pawns
849 score += evaluate_pieces<DoTrace>(pos, ei, mobility);
850 score += mobility[WHITE] - mobility[BLACK];
852 // Evaluate kings after all other pieces because we need full attack
853 // information when computing the king safety evaluation.
854 score += evaluate_king<WHITE, DoTrace>(pos, ei)
855 - evaluate_king<BLACK, DoTrace>(pos, ei);
857 // Evaluate tactical threats, we need full attack information including king
858 score += evaluate_threats<WHITE, DoTrace>(pos, ei)
859 - evaluate_threats<BLACK, DoTrace>(pos, ei);
861 // Evaluate passed pawns, we need full attack information including king
862 score += evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)
863 - evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);
865 // Evaluate space for both sides, only during opening
866 if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
867 score += evaluate_space<WHITE>(pos, ei)
868 - evaluate_space<BLACK>(pos, ei);
870 // Evaluate position potential for the winning side
871 score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
873 // Evaluate scale factor for the winning side
874 ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
876 // Interpolate between a middlegame and a (scaled by 'sf') endgame score
877 Value v = mg_value(score) * int(ei.me->game_phase())
878 + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
880 v /= int(PHASE_MIDGAME);
882 // In case of tracing add all remaining individual evaluation terms
885 Trace::add(MATERIAL, pos.psq_score());
886 Trace::add(IMBALANCE, ei.me->imbalance());
887 Trace::add(PAWN, ei.pe->pawns_score());
888 Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
889 if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
890 Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
891 , evaluate_space<BLACK>(pos, ei));
892 Trace::add(TOTAL, score);
895 return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
898 // Explicit template instantiations
899 template Value Eval::evaluate<true >(const Position&);
900 template Value Eval::evaluate<false>(const Position&);
903 /// trace() is like evaluate(), but instead of returning a value, it returns
904 /// a string (suitable for outputting to stdout) that contains the detailed
905 /// descriptions and values of each evaluation term. Useful for debugging.
907 std::string Eval::trace(const Position& pos) {
909 std::memset(scores, 0, sizeof(scores));
911 Value v = evaluate<true>(pos);
912 v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
914 std::stringstream ss;
915 ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
916 << " Eval term | White | Black | Total \n"
917 << " | MG EG | MG EG | MG EG \n"
918 << "----------------+-------------+-------------+-------------\n"
919 << " Material | " << Term(MATERIAL)
920 << " Imbalance | " << Term(IMBALANCE)
921 << " Pawns | " << Term(PAWN)
922 << " Knights | " << Term(KNIGHT)
923 << " Bishop | " << Term(BISHOP)
924 << " Rooks | " << Term(ROOK)
925 << " Queens | " << Term(QUEEN)
926 << " Mobility | " << Term(MOBILITY)
927 << " King safety | " << Term(KING)
928 << " Threats | " << Term(THREAT)
929 << " Passed pawns | " << Term(PASSED)
930 << " Space | " << Term(SPACE)
931 << "----------------+-------------+-------------+-------------\n"
932 << " Total | " << Term(TOTAL);
934 ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";