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-2010 Marco Costalba, Joona Kiiski, Tord Romstad
6 Stockfish is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 Stockfish is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
32 #include "ucioption.h"
36 //// Local definitions
41 // Struct EvalInfo contains various information computed and collected
42 // by the evaluation functions.
45 // Middle and end game position's static evaluations
48 // margin[color] stores the evaluation margins we should consider for
49 // the given position. This is a kind of uncertainty estimation and
50 // typically is used by the search for pruning decisions.
53 // Pointers to material and pawn hash table entries
57 // attackedBy[color][piece type] is a bitboard representing all squares
58 // attacked by a given color and piece type, attackedBy[color][0] contains
59 // all squares attacked by the given color.
60 Bitboard attackedBy[2][8];
62 // kingZone[color] is the zone around the enemy king which is considered
63 // by the king safety evaluation. This consists of the squares directly
64 // adjacent to the king, and the three (or two, for a king on an edge file)
65 // squares two ranks in front of the king. For instance, if black's king
66 // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
67 // f7, g7, h7, f6, g6 and h6.
70 // kingAttackersCount[color] is the number of pieces of the given color
71 // which attack a square in the kingZone of the enemy king.
72 int kingAttackersCount[2];
74 // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
75 // given color which attack a square in the kingZone of the enemy king. The
76 // weights of the individual piece types are given by the variables
77 // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
78 // KnightAttackWeight in evaluate.cpp
79 int kingAttackersWeight[2];
81 // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
82 // directly adjacent to the king of the given color. Pieces which attack
83 // more than one square are counted multiple times. For instance, if black's
84 // king is on g8 and there's a white knight on g5, this knight adds
85 // 2 to kingAdjacentZoneAttacksCount[BLACK].
86 int kingAdjacentZoneAttacksCount[2];
89 const int Sign[2] = { 1, -1 };
91 // Evaluation grain size, must be a power of 2
92 const int GrainSize = 8;
94 // Evaluation weights, initialized from UCI options
95 enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
99 #define S(mg, eg) make_score(mg, eg)
101 // Internal evaluation weights. These are applied on top of the evaluation
102 // weights read from UCI parameters. The purpose is to be able to change
103 // the evaluation weights while keeping the default values of the UCI
104 // parameters at 100, which looks prettier.
106 // Values modified by Joona Kiiski
107 const Score WeightsInternal[] = {
108 S(248, 271), S(233, 201), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
111 // MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
112 // end game, indexed by piece type and number of attacked squares not occupied
113 // by friendly pieces.
114 const Score MobilityBonus[][32] = {
116 { S(-38,-33), S(-25,-23), S(-12,-13), S( 0, -3), S(12, 7), S(25, 17), // Knights
117 S( 31, 22), S( 38, 27), S( 38, 27) },
118 { S(-25,-30), S(-11,-16), S( 3, -2), S(17, 12), S(31, 26), S(45, 40), // Bishops
119 S( 57, 52), S( 65, 60), S( 71, 65), S(74, 69), S(76, 71), S(78, 73),
120 S( 79, 74), S( 80, 75), S( 81, 76), S(81, 76) },
121 { S(-20,-36), S(-14,-19), S( -8, -3), S(-2, 13), S( 4, 29), S(10, 46), // Rooks
122 S( 14, 62), S( 19, 79), S( 23, 95), S(26,106), S(27,111), S(28,114),
123 S( 29,116), S( 30,117), S( 31,118), S(32,118) },
124 { S(-10,-18), S( -8,-13), S( -6, -7), S(-3, -2), S(-1, 3), S( 1, 8), // Queens
125 S( 3, 13), S( 5, 19), S( 8, 23), S(10, 27), S(12, 32), S(15, 34),
126 S( 16, 35), S( 17, 35), S( 18, 35), S(20, 35), S(20, 35), S(20, 35),
127 S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
128 S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
129 S( 20, 35), S( 20, 35) }
132 // OutpostBonus[PieceType][Square] contains outpost bonuses of knights and
133 // bishops, indexed by piece type and square (from white's point of view).
134 const Value OutpostBonus[][64] = {
137 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
138 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
139 V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
140 V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
141 V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
142 V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0),
143 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
144 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) },
146 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
147 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
148 V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
149 V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
150 V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
151 V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0),
152 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
153 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) }
156 // ThreatBonus[attacking][attacked] contains threat bonuses according to
157 // which piece type attacks which one.
158 const Score ThreatBonus[][8] = {
160 { S(0, 0), S( 7, 39), S( 0, 0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
161 { S(0, 0), S( 7, 39), S(24, 49), S( 0, 0), S(41,100), S(41,100) }, // BISHOP
162 { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0, 0), S(24, 49) }, // ROOK
163 { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0, 0) } // QUEEN
166 // ThreatedByPawnPenalty[PieceType] contains a penalty according to which
167 // piece type is attacked by an enemy pawn.
168 const Score ThreatedByPawnPenalty[] = {
169 S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
174 // Rooks and queens on the 7th rank (modified by Joona Kiiski)
175 const Score RookOn7thBonus = make_score(47, 98);
176 const Score QueenOn7thBonus = make_score(27, 54);
178 // Rooks on open files (modified by Joona Kiiski)
179 const Score RookOpenFileBonus = make_score(43, 43);
180 const Score RookHalfOpenFileBonus = make_score(19, 19);
182 // Penalty for rooks trapped inside a friendly king which has lost the
184 const Value TrappedRookPenalty = Value(180);
186 // The SpaceMask[Color] contains the area of the board which is considered
187 // by the space evaluation. In the middle game, each side is given a bonus
188 // based on how many squares inside this area are safe and available for
189 // friendly minor pieces.
190 const Bitboard SpaceMask[2] = {
191 (1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
192 (1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
193 (1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
194 (1ULL << SQ_C7) | (1ULL << SQ_D7) | (1ULL << SQ_E7) | (1ULL << SQ_F7) |
195 (1ULL << SQ_C6) | (1ULL << SQ_D6) | (1ULL << SQ_E6) | (1ULL << SQ_F6) |
196 (1ULL << SQ_C5) | (1ULL << SQ_D5) | (1ULL << SQ_E5) | (1ULL << SQ_F5)
199 // King danger constants and variables. The king danger scores are taken
200 // from the KingDangerTable[]. Various little "meta-bonuses" measuring
201 // the strength of the enemy attack are added up into an integer, which
202 // is used as an index to KingDangerTable[].
204 // KingAttackWeights[PieceType] contains king attack weights by piece type
205 const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
207 // Bonuses for enemy's safe checks
208 const int QueenContactCheckBonus = 3;
209 const int QueenCheckBonus = 2;
210 const int RookCheckBonus = 1;
211 const int BishopCheckBonus = 1;
212 const int KnightCheckBonus = 1;
214 // InitKingDanger[Square] contains penalties based on the position of the
215 // defending king, indexed by king's square (from white's point of view).
216 const int InitKingDanger[] = {
217 2, 0, 2, 5, 5, 2, 0, 2,
218 2, 2, 4, 8, 8, 4, 2, 2,
219 7, 10, 12, 12, 12, 12, 10, 7,
220 15, 15, 15, 15, 15, 15, 15, 15,
221 15, 15, 15, 15, 15, 15, 15, 15,
222 15, 15, 15, 15, 15, 15, 15, 15,
223 15, 15, 15, 15, 15, 15, 15, 15,
224 15, 15, 15, 15, 15, 15, 15, 15
227 // KingDangerTable[Color][attackUnits] contains the actual king danger
228 // weighted scores, indexed by color and by a calculated integer number.
229 Score KingDangerTable[2][128];
231 // Pawn and material hash tables, indexed by the current thread id.
232 // Note that they will be initialized at 0 being global variables.
233 MaterialInfoTable* MaterialTable[MAX_THREADS];
234 PawnInfoTable* PawnTable[MAX_THREADS];
236 // Function prototypes
237 template<bool HasPopCnt>
238 Value do_evaluate(const Position& pos, Value margins[]);
240 template<Color Us, bool HasPopCnt>
241 void init_attack_tables(const Position& pos, EvalInfo& ei);
243 template<Color Us, bool HasPopCnt>
244 Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
246 template<Color Us, bool HasPopCnt>
247 void evaluate_king(const Position& pos, EvalInfo& ei);
250 void evaluate_threats(const Position& pos, EvalInfo& ei);
252 template<Color Us, bool HasPopCnt>
253 int evaluate_space(const Position& pos, EvalInfo& ei);
256 void evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
258 inline Score apply_weight(Score v, Score weight);
259 Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
260 Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
270 /// Prefetches in pawn hash tables
272 void prefetchPawn(Key key, int threadID) {
274 PawnTable[threadID]->prefetch(key);
277 /// evaluate() is the main evaluation function. It always computes two
278 /// values, an endgame score and a middle game score, and interpolates
279 /// between them based on the remaining material.
280 Value evaluate(const Position& pos, Value margins[]) {
282 return CpuHasPOPCNT ? do_evaluate<true>(pos, margins)
283 : do_evaluate<false>(pos, margins);
288 template<bool HasPopCnt>
289 Value do_evaluate(const Position& pos, Value margins[]) {
292 ScaleFactor factor[2];
296 assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
297 assert(!pos.is_check());
299 // Initialize by reading the incrementally updated scores included in the
300 // position object (material + piece square tables).
301 ei.value = pos.value();
303 // Probe the material hash table
304 ei.mi = MaterialTable[pos.thread()]->get_material_info(pos);
305 ei.value += ei.mi->material_value();
307 // If we have a specialized evaluation function for the current material
308 // configuration, call it and return.
309 if (ei.mi->specialized_eval_exists())
310 return ei.mi->evaluate(pos);
312 // After get_material_info() call that modifies them
313 factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
314 factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
316 // Probe the pawn hash table
317 ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
318 ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
320 // Initialize attack bitboards with pawns evaluation
321 init_attack_tables<WHITE, HasPopCnt>(pos, ei);
322 init_attack_tables<BLACK, HasPopCnt>(pos, ei);
324 // Evaluate pieces and mobility
325 mobility = evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei)
326 - evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
327 ei.value += apply_weight(mobility, Weights[Mobility]);
329 // Kings. Kings are evaluated after all other pieces for both sides,
330 // because we need complete attack information for all pieces when computing
331 // the king safety evaluation.
332 evaluate_king<WHITE, HasPopCnt>(pos, ei);
333 evaluate_king<BLACK, HasPopCnt>(pos, ei);
335 // Evaluate tactical threats, we need full attack info including king
336 evaluate_threats<WHITE>(pos, ei);
337 evaluate_threats<BLACK>(pos, ei);
339 // Evaluate passed pawns, we need full attack info including king
340 evaluate_passed_pawns<WHITE>(pos, ei);
341 evaluate_passed_pawns<BLACK>(pos, ei);
343 Phase phase = ei.mi->game_phase();
345 // Middle-game specific evaluation terms
346 if (phase > PHASE_ENDGAME)
348 // Evaluate pawn storms in positions with opposite castling
349 if ( square_file(pos.king_square(WHITE)) >= FILE_E
350 && square_file(pos.king_square(BLACK)) <= FILE_D)
352 ei.value += make_score(ei.pi->queenside_storm_value(WHITE) - ei.pi->kingside_storm_value(BLACK), 0);
354 else if ( square_file(pos.king_square(WHITE)) <= FILE_D
355 && square_file(pos.king_square(BLACK)) >= FILE_E)
357 ei.value += make_score(ei.pi->kingside_storm_value(WHITE) - ei.pi->queenside_storm_value(BLACK), 0);
359 // Evaluate space for both sides
360 if (ei.mi->space_weight() > 0)
362 int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
363 ei.value += apply_weight(make_score(s * ei.mi->space_weight(), 0), Weights[Space]);
367 // If we don't already have an unusual scale factor, check for opposite
368 // colored bishop endgames, and use a lower scale for those
369 if ( phase < PHASE_MIDGAME
370 && pos.opposite_colored_bishops()
371 && ( (factor[WHITE] == SCALE_FACTOR_NORMAL && eg_value(ei.value) > VALUE_ZERO)
372 || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(ei.value) < VALUE_ZERO)))
376 // Only the two bishops ?
377 if ( pos.non_pawn_material(WHITE) == BishopValueMidgame
378 && pos.non_pawn_material(BLACK) == BishopValueMidgame)
380 // Check for KBP vs KB with only a single pawn that is almost
381 // certainly a draw or at least two pawns.
382 bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
383 sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
386 // Endgame with opposite-colored bishops, but also other pieces. Still
387 // a bit drawish, but not as drawish as with only the two bishops.
388 sf = ScaleFactor(50);
390 if (factor[WHITE] == SCALE_FACTOR_NORMAL)
392 if (factor[BLACK] == SCALE_FACTOR_NORMAL)
396 // Populate margins[]
397 margins[WHITE] = ei.margin[WHITE];
398 margins[BLACK] = ei.margin[BLACK];
400 // Interpolate between the middle game and the endgame score
401 return Sign[pos.side_to_move()] * scale_by_game_phase(ei.value, phase, factor);
406 /// init_eval() initializes various tables used by the evaluation function
408 void init_eval(int threads) {
410 assert(threads <= MAX_THREADS);
412 for (int i = 0; i < MAX_THREADS; i++)
417 delete MaterialTable[i];
419 MaterialTable[i] = NULL;
423 PawnTable[i] = new PawnInfoTable();
424 if (!MaterialTable[i])
425 MaterialTable[i] = new MaterialInfoTable();
430 /// quit_eval() releases heap-allocated memory at program termination
434 for (int i = 0; i < MAX_THREADS; i++)
437 delete MaterialTable[i];
439 MaterialTable[i] = NULL;
444 /// read_weights() reads evaluation weights from the corresponding UCI parameters
446 void read_weights(Color us) {
448 // King safety is asymmetrical. Our king danger level is weighted by
449 // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
450 const int kingDangerUs = (us == WHITE ? KingDangerUs : KingDangerThem);
451 const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
453 Weights[Mobility] = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
454 Weights[PawnStructure] = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
455 Weights[PassedPawns] = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
456 Weights[Space] = weight_option("Space", "Space", WeightsInternal[Space]);
457 Weights[kingDangerUs] = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
458 Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
460 // If running in analysis mode, make sure we use symmetrical king safety. We do this
461 // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
462 if (get_option_value_bool("UCI_AnalyseMode"))
463 Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
471 // init_attack_tables() initializes king bitboards for both sides adding
472 // pawn attacks. To be done before other evaluations.
474 template<Color Us, bool HasPopCnt>
475 void init_attack_tables(const Position& pos, EvalInfo& ei) {
477 const Color Them = (Us == WHITE ? BLACK : WHITE);
479 Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
480 ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
481 ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
482 b &= ei.attackedBy[Us][PAWN];
483 ei.kingAttackersCount[Us] = b ? count_1s_max_15<HasPopCnt>(b) / 2 : 0;
484 ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
488 // evaluate_outposts() evaluates bishop and knight outposts squares
490 template<PieceType Piece, Color Us>
491 void evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
493 const Color Them = (Us == WHITE ? BLACK : WHITE);
495 assert (Piece == BISHOP || Piece == KNIGHT);
497 // Initial bonus based on square
498 Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
500 // Increase bonus if supported by pawn, especially if the opponent has
501 // no minor piece which can exchange the outpost piece
502 if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
504 if ( pos.pieces(KNIGHT, Them) == EmptyBoardBB
505 && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
506 bonus += bonus + bonus / 2;
510 ei.value += Sign[Us] * make_score(bonus, bonus);
514 // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
516 template<PieceType Piece, Color Us, bool HasPopCnt>
517 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Bitboard no_mob_area) {
523 Score mobility = SCORE_ZERO;
525 const Color Them = (Us == WHITE ? BLACK : WHITE);
526 const Square* ptr = pos.piece_list_begin(Us, Piece);
528 ei.attackedBy[Us][Piece] = 0;
530 while ((s = *ptr++) != SQ_NONE)
532 // Find attacked squares, including x-ray attacks for bishops and rooks
533 if (Piece == KNIGHT || Piece == QUEEN)
534 b = pos.attacks_from<Piece>(s);
535 else if (Piece == BISHOP)
536 b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
537 else if (Piece == ROOK)
538 b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
542 // Update attack info
543 ei.attackedBy[Us][Piece] |= b;
546 if (b & ei.kingZone[Us])
548 ei.kingAttackersCount[Us]++;
549 ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
550 Bitboard bb = (b & ei.attackedBy[Them][KING]);
552 ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
556 mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & no_mob_area)
557 : count_1s<HasPopCnt>(b & no_mob_area));
559 mobility += MobilityBonus[Piece][mob];
561 // Decrease score if we are attacked by an enemy pawn. Remaining part
562 // of threat evaluation must be done later when we have full attack info.
563 if (bit_is_set(ei.attackedBy[Them][PAWN], s))
564 ei.value -= Sign[Us] * ThreatedByPawnPenalty[Piece];
566 // Bishop and knight outposts squares
567 if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
568 evaluate_outposts<Piece, Us>(pos, ei, s);
570 // Queen or rook on 7th rank
571 if ( (Piece == ROOK || Piece == QUEEN)
572 && relative_rank(Us, s) == RANK_7
573 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
575 ei.value += Sign[Us] * (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
578 // Special extra evaluation for rooks
581 // Open and half-open files
583 if (ei.pi->file_is_half_open(Us, f))
585 if (ei.pi->file_is_half_open(Them, f))
586 ei.value += Sign[Us] * RookOpenFileBonus;
588 ei.value += Sign[Us] * RookHalfOpenFileBonus;
591 // Penalize rooks which are trapped inside a king. Penalize more if
592 // king has lost right to castle.
593 if (mob > 6 || ei.pi->file_is_half_open(Us, f))
596 ksq = pos.king_square(Us);
598 if ( square_file(ksq) >= FILE_E
599 && square_file(s) > square_file(ksq)
600 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
602 // Is there a half-open file between the king and the edge of the board?
603 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
604 ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
605 : (TrappedRookPenalty - mob * 16), 0);
607 else if ( square_file(ksq) <= FILE_D
608 && square_file(s) < square_file(ksq)
609 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
611 // Is there a half-open file between the king and the edge of the board?
612 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
613 ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
614 : (TrappedRookPenalty - mob * 16), 0);
622 // evaluate_threats<>() assigns bonuses according to the type of attacking piece
623 // and the type of attacked one.
626 void evaluate_threats(const Position& pos, EvalInfo& ei) {
628 const Color Them = (Us == WHITE ? BLACK : WHITE);
631 Score bonus = SCORE_ZERO;
633 // Enemy pieces not defended by a pawn and under our attack
634 Bitboard weakEnemies = pos.pieces_of_color(Them)
635 & ~ei.attackedBy[Them][PAWN]
636 & ei.attackedBy[Us][0];
640 // Add bonus according to type of attacked enemy pieces and to the
641 // type of attacking piece, from knights to queens. Kings are not
642 // considered because are already special handled in king evaluation.
643 for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
645 b = ei.attackedBy[Us][pt1] & weakEnemies;
647 for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
648 if (b & pos.pieces(pt2))
649 bonus += ThreatBonus[pt1][pt2];
651 ei.value += Sign[Us] * bonus;
655 // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
656 // pieces of a given color.
658 template<Color Us, bool HasPopCnt>
659 Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
661 const Color Them = (Us == WHITE ? BLACK : WHITE);
663 Score mobility = SCORE_ZERO;
665 // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
666 const Bitboard no_mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
668 mobility += evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, no_mob_area);
669 mobility += evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, no_mob_area);
670 mobility += evaluate_pieces<ROOK, Us, HasPopCnt>(pos, ei, no_mob_area);
671 mobility += evaluate_pieces<QUEEN, Us, HasPopCnt>(pos, ei, no_mob_area);
673 // Sum up all attacked squares
674 ei.attackedBy[Us][0] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
675 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
676 | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
681 // evaluate_king<>() assigns bonuses and penalties to a king of a given color
683 template<Color Us, bool HasPopCnt>
684 void evaluate_king(const Position& pos, EvalInfo& ei) {
686 const Color Them = (Us == WHITE ? BLACK : WHITE);
688 Bitboard undefended, b, b1, b2, safe;
691 const Square ksq = pos.king_square(Us);
694 ei.value += Sign[Us] * ei.pi->king_shelter(pos, Us, ksq);
696 // King safety. This is quite complicated, and is almost certainly far
697 // from optimally tuned.
698 if ( pos.piece_count(Them, QUEEN) >= 1
699 && ei.kingAttackersCount[Them] >= 2
700 && pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
701 && ei.kingAdjacentZoneAttacksCount[Them])
703 // Is it the attackers turn to move?
704 sente = (Them == pos.side_to_move());
706 // Find the attacked squares around the king which has no defenders
707 // apart from the king itself
708 undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
709 undefended &= ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
710 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
711 | ei.attackedBy[Us][QUEEN]);
713 // Initialize the 'attackUnits' variable, which is used later on as an
714 // index to the KingDangerTable[] array. The initial value is based on
715 // the number and types of the enemy's attacking pieces, the number of
716 // attacked and undefended squares around our king, the square of the
717 // king, and the quality of the pawn shelter.
718 attackUnits = Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
719 + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended))
720 + InitKingDanger[relative_square(Us, ksq)]
721 - mg_value(ei.pi->king_shelter(pos, Us, ksq)) / 32;
723 // Analyse enemy's safe queen contact checks. First find undefended
724 // squares around the king attacked by enemy queen...
725 b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces_of_color(Them);
728 // ...then remove squares not supported by another enemy piece
729 b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
730 | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
732 attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
735 // Analyse enemy's safe distance checks for sliders and knights
736 safe = ~(pos.pieces_of_color(Them) | ei.attackedBy[Us][0]);
738 b1 = pos.attacks_from<ROOK>(ksq) & safe;
739 b2 = pos.attacks_from<BISHOP>(ksq) & safe;
741 // Enemy queen safe checks
742 b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
744 attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
746 // Enemy rooks safe checks
747 b = b1 & ei.attackedBy[Them][ROOK];
749 attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
751 // Enemy bishops safe checks
752 b = b2 & ei.attackedBy[Them][BISHOP];
754 attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
756 // Enemy knights safe checks
757 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
759 attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
761 // To index KingDangerTable[] attackUnits must be in [0, 99] range
762 attackUnits = Min(99, Max(0, attackUnits));
764 // Finally, extract the king danger score from the KingDangerTable[]
765 // array and subtract the score from evaluation. Set also ei.margin[]
766 // value that will be used for pruning because this value can sometimes
767 // be very big, and so capturing a single attacking piece can therefore
768 // result in a score change far bigger than the value of the captured piece.
769 ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
770 ei.margin[Us] = mg_value(KingDangerTable[Us][attackUnits]);
772 ei.margin[Us] = VALUE_ZERO;
776 // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
779 void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
781 const Color Them = (Us == WHITE ? BLACK : WHITE);
783 Score bonus = SCORE_ZERO;
784 Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
785 Bitboard b = ei.pi->passed_pawns(Us);
791 Square s = pop_1st_bit(&b);
793 assert(pos.pawn_is_passed(Us, s));
795 int r = int(relative_rank(Us, s) - RANK_2);
796 int tr = r * (r - 1);
798 // Base bonus based on rank
799 Value mbonus = Value(20 * tr);
800 Value ebonus = Value(10 + r * r * 10);
804 Square blockSq = s + pawn_push(Us);
806 // Adjust bonus based on kings proximity
807 ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * tr);
808 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * 1 * tr);
809 ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * tr);
811 // If the pawn is free to advance, increase bonus
812 if (pos.square_is_empty(blockSq))
814 squaresToQueen = squares_in_front_of(Us, s);
815 defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
817 // If there is an enemy rook or queen attacking the pawn from behind,
818 // add all X-ray attacks by the rook or queen. Otherwise consider only
819 // the squares in the pawn's path attacked or occupied by the enemy.
820 if ( (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
821 && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
822 unsafeSquares = squaresToQueen;
824 unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces_of_color(Them));
826 // If there aren't enemy attacks or pieces along the path to queen give
827 // huge bonus. Even bigger if we protect the pawn's path.
829 ebonus += Value(tr * (squaresToQueen == defendedSquares ? 17 : 15));
831 // OK, there are enemy attacks or pieces (but not pawns). Are those
832 // squares which are attacked by the enemy also attacked by us ?
833 // If yes, big bonus (but smaller than when there are no enemy attacks),
834 // if no, somewhat smaller bonus.
835 ebonus += Value(tr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
837 // At last, add a small bonus when there are no *friendly* pieces
838 // in the pawn's path.
839 if (!(squaresToQueen & pos.pieces_of_color(Us)))
844 // Increase the bonus if the passed pawn is supported by a friendly pawn
845 // on the same rank and a bit smaller if it's on the previous rank.
846 supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
847 if (supportingPawns & rank_bb(s))
848 ebonus += Value(r * 20);
849 else if (supportingPawns & rank_bb(s - pawn_push(Us)))
850 ebonus += Value(r * 12);
852 // Rook pawns are a special case: They are sometimes worse, and
853 // sometimes better than other passed pawns. It is difficult to find
854 // good rules for determining whether they are good or bad. For now,
855 // we try the following: Increase the value for rook pawns if the
856 // other side has no pieces apart from a knight, and decrease the
857 // value if the other side has a rook or queen.
858 if (square_file(s) == FILE_A || square_file(s) == FILE_H)
860 if (pos.non_pawn_material(Them) <= KnightValueMidgame)
861 ebonus += ebonus / 4;
862 else if (pos.pieces(ROOK, QUEEN, Them))
863 ebonus -= ebonus / 4;
865 bonus += make_score(mbonus, ebonus);
869 // Add the scores to the middle game and endgame eval
870 ei.value += Sign[Us] * apply_weight(bonus, Weights[PassedPawns]);
874 // evaluate_space() computes the space evaluation for a given side. The
875 // space evaluation is a simple bonus based on the number of safe squares
876 // available for minor pieces on the central four files on ranks 2--4. Safe
877 // squares one, two or three squares behind a friendly pawn are counted
878 // twice. Finally, the space bonus is scaled by a weight taken from the
879 // material hash table.
880 template<Color Us, bool HasPopCnt>
881 int evaluate_space(const Position& pos, EvalInfo& ei) {
883 const Color Them = (Us == WHITE ? BLACK : WHITE);
885 // Find the safe squares for our pieces inside the area defined by
886 // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
887 // pawn, or if it is undefended and attacked by an enemy piece.
888 Bitboard safe = SpaceMask[Us]
889 & ~pos.pieces(PAWN, Us)
890 & ~ei.attackedBy[Them][PAWN]
891 & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
893 // Find all squares which are at most three squares behind some friendly pawn
894 Bitboard behind = pos.pieces(PAWN, Us);
895 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
896 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
898 return count_1s_max_15<HasPopCnt>(safe) + count_1s_max_15<HasPopCnt>(behind & safe);
902 // apply_weight() applies an evaluation weight to a value trying to prevent overflow
904 inline Score apply_weight(Score v, Score w) {
905 return make_score((int(mg_value(v)) * mg_value(w)) / 0x100, (int(eg_value(v)) * eg_value(w)) / 0x100);
909 // scale_by_game_phase() interpolates between a middle game and an endgame score,
910 // based on game phase. It also scales the return value by a ScaleFactor array.
912 Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]) {
914 assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
915 assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
916 assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
918 Value eg = eg_value(v);
919 ScaleFactor f = sf[eg > VALUE_ZERO ? WHITE : BLACK];
920 Value ev = Value((eg * int(f)) / SCALE_FACTOR_NORMAL);
922 int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
923 return Value(result & ~(GrainSize - 1));
927 // weight_option() computes the value of an evaluation weight, by combining
928 // two UCI-configurable weights (midgame and endgame) with an internal weight.
930 Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
932 // Scale option value from 100 to 256
933 int mg = get_option_value_int(mgOpt) * 256 / 100;
934 int eg = get_option_value_int(egOpt) * 256 / 100;
936 return apply_weight(make_score(mg, eg), internalWeight);
939 // init_safety() initizes the king safety evaluation, based on UCI
940 // parameters. It is called from read_weights().
944 const Value MaxSlope = Value(30);
945 const Value Peak = Value(1280);
948 // First setup the base table
949 for (int i = 0; i < 100; i++)
951 t[i] = Value(int(0.4 * i * i));
954 t[i] = Min(t[i], t[i - 1] + MaxSlope);
956 t[i] = Min(t[i], Peak);
959 // Then apply the weights and get the final KingDangerTable[] array
960 for (Color c = WHITE; c <= BLACK; c++)
961 for (int i = 0; i < 100; i++)
962 KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);