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/>.
34 #include "ucioption.h"
38 //// Local definitions
43 const int Sign[2] = { 1, -1 };
45 // Evaluation grain size, must be a power of 2
46 const int GrainSize = 8;
48 // Evaluation weights, initialized from UCI options
49 enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
53 #define S(mg, eg) make_score(mg, eg)
55 // Internal evaluation weights. These are applied on top of the evaluation
56 // weights read from UCI parameters. The purpose is to be able to change
57 // the evaluation weights while keeping the default values of the UCI
58 // parameters at 100, which looks prettier.
60 // Values modified by Joona Kiiski
61 const Score WeightsInternal[] = {
62 S(248, 271), S(233, 201), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
65 // Knight mobility bonus in middle game and endgame, indexed by the number
66 // of attacked squares not occupied by friendly piecess.
67 const Score KnightMobilityBonus[16] = {
68 S(-38,-33), S(-25,-23), S(-12,-13), S( 0,-3),
69 S( 12, 7), S( 25, 17), S( 31, 22), S(38, 27), S(38, 27)
72 // Bishop mobility bonus in middle game and endgame, indexed by the number
73 // of attacked squares not occupied by friendly pieces. X-ray attacks through
74 // queens are also included.
75 const Score BishopMobilityBonus[16] = {
76 S(-25,-30), S(-11,-16), S( 3, -2), S(17, 12),
77 S( 31, 26), S( 45, 40), S(57, 52), S(65, 60),
78 S( 71, 65), S( 74, 69), S(76, 71), S(78, 73),
79 S( 79, 74), S( 80, 75), S(81, 76), S(81, 76)
82 // Rook mobility bonus in middle game and endgame, indexed by the number
83 // of attacked squares not occupied by friendly pieces. X-ray attacks through
84 // queens and rooks are also included.
85 const Score RookMobilityBonus[16] = {
86 S(-20,-36), S(-14,-19), S(-8, -3), S(-2, 13),
87 S( 4, 29), S( 10, 46), S(14, 62), S(19, 79),
88 S( 23, 95), S( 26,106), S(27,111), S(28,114),
89 S( 29,116), S( 30,117), S(31,118), S(32,118)
92 // Queen mobility bonus in middle game and endgame, indexed by the number
93 // of attacked squares not occupied by friendly pieces.
94 const Score QueenMobilityBonus[32] = {
95 S(-10,-18), S(-8,-13), S(-6, -7), S(-3, -2), S(-1, 3), S( 1, 8),
96 S( 3, 13), S( 5, 19), S( 8, 23), S(10, 27), S(12, 32), S(15, 34),
97 S( 16, 35), S(17, 35), S(18, 35), S(20, 35), S(20, 35), S(20, 35),
98 S( 20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35),
99 S( 20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35), S(20, 35),
100 S( 20, 35), S(20, 35)
103 // Pointers table to access mobility tables through piece type
104 const Score* MobilityBonus[8] = { 0, 0, KnightMobilityBonus, BishopMobilityBonus,
105 RookMobilityBonus, QueenMobilityBonus, 0, 0 };
107 // Outpost bonuses for knights and bishops, indexed by square (from white's
109 const Value KnightOutpostBonus[64] = {
111 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
112 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
113 V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0), // 3
114 V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0), // 4
115 V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0), // 5
116 V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0), // 6
117 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
118 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) // 8
121 const Value BishopOutpostBonus[64] = {
123 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
124 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
125 V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), // 3
126 V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), // 4
127 V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0), // 5
128 V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0), // 6
129 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
130 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) // 8
133 // ThreatBonus[attacking][attacked] contains bonus according to which
134 // piece type attacks which one.
135 const Score ThreatBonus[8][8] = {
137 { S(0, 0), S( 7, 39), S( 0, 0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
138 { S(0, 0), S( 7, 39), S(24, 49), S( 0, 0), S(41,100), S(41,100) }, // BISHOP
139 { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0, 0), S(24, 49) }, // ROOK
140 { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0, 0) } // QUEEN
143 // ThreatedByPawnPenalty[] contains a penalty according to which piece
144 // type is attacked by an enemy pawn.
145 const Score ThreatedByPawnPenalty[8] = {
146 S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
151 // Threats weights indexed by sente (side to move has a bigger weight)
152 const int ConcurrentThreatsWeight[2] = { 3, 15 };
153 const int ThreatsWeight[2] = { 249, 267 };
155 // Bonus for unstoppable passed pawns
156 const Value UnstoppablePawnValue = Value(0x500);
158 // Rooks and queens on the 7th rank (modified by Joona Kiiski)
159 const Score RookOn7thBonus = make_score(47, 98);
160 const Score QueenOn7thBonus = make_score(27, 54);
162 // Rooks on open files (modified by Joona Kiiski)
163 const Score RookOpenFileBonus = make_score(43, 43);
164 const Score RookHalfOpenFileBonus = make_score(19, 19);
166 // Penalty for rooks trapped inside a friendly king which has lost the
168 const Value TrappedRookPenalty = Value(180);
170 // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
172 const Score TrappedBishopA7H7Penalty = make_score(300, 300);
174 // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
175 const Bitboard MaskA7H7[2] = {
176 ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
177 ((1ULL << SQ_A2) | (1ULL << SQ_H2))
180 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
181 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
182 // happen in Chess960 games.
183 const Score TrappedBishopA1H1Penalty = make_score(100, 100);
185 // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
186 const Bitboard MaskA1H1[2] = {
187 ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
188 ((1ULL << SQ_A8) | (1ULL << SQ_H8))
191 // The SpaceMask[color] contains the area of the board which is considered
192 // by the space evaluation. In the middle game, each side is given a bonus
193 // based on how many squares inside this area are safe and available for
194 // friendly minor pieces.
195 const Bitboard SpaceMask[2] = {
196 (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
197 (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
198 (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
199 (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
200 (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
201 (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
204 /// King danger constants and variables. The king danger scores are taken
205 /// from the KingDangerTable[]. Various little "meta-bonuses" measuring
206 /// the strength of the enemy attack are added up into an integer, which
207 /// is used as an index to KingDangerTable[].
209 // KingAttackWeights[] contains king attack weights by piece type
210 const int KingAttackWeights[8] = { 0, 0, 2, 2, 3, 5 };
212 // Bonuses for enemy's safe checks
213 const int QueenContactCheckBonus = 3;
214 const int DiscoveredCheckBonus = 3;
215 const int QueenCheckBonus = 2;
216 const int RookCheckBonus = 1;
217 const int BishopCheckBonus = 1;
218 const int KnightCheckBonus = 1;
220 // InitKingDanger[] contains bonuses based on the position of the defending
222 const int InitKingDanger[64] = {
223 2, 0, 2, 5, 5, 2, 0, 2,
224 2, 2, 4, 8, 8, 4, 2, 2,
225 7, 10, 12, 12, 12, 12, 10, 7,
226 15, 15, 15, 15, 15, 15, 15, 15,
227 15, 15, 15, 15, 15, 15, 15, 15,
228 15, 15, 15, 15, 15, 15, 15, 15,
229 15, 15, 15, 15, 15, 15, 15, 15,
230 15, 15, 15, 15, 15, 15, 15, 15
233 // KingDangerTable[color][] contains the actual king danger weighted scores
234 Score KingDangerTable[2][128];
236 // Pawn and material hash tables, indexed by the current thread id.
237 // Note that they will be initialized at 0 being global variables.
238 MaterialInfoTable* MaterialTable[MAX_THREADS];
239 PawnInfoTable* PawnTable[MAX_THREADS];
241 // Sizes of pawn and material hash tables
242 const int PawnTableSize = 16384;
243 const int MaterialTableSize = 1024;
245 // Function prototypes
246 template<bool HasPopCnt>
247 Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
249 template<Color Us, bool HasPopCnt>
250 void init_attack_tables(const Position& pos, EvalInfo& ei);
252 template<Color Us, bool HasPopCnt>
253 void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
255 template<Color Us, bool HasPopCnt>
256 void evaluate_king(const Position& pos, EvalInfo& ei);
259 void evaluate_threats(const Position& pos, EvalInfo& ei);
261 template<Color Us, bool HasPopCnt>
262 void evaluate_space(const Position& pos, EvalInfo& ei);
265 void evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
267 void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
268 void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo& ei);
269 void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei);
270 inline Score apply_weight(Score v, Score weight);
271 Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
272 Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
281 /// evaluate() is the main evaluation function. It always computes two
282 /// values, an endgame score and a middle game score, and interpolates
283 /// between them based on the remaining material.
284 Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
286 return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
287 : do_evaluate<false>(pos, ei, threadID);
292 template<bool HasPopCnt>
293 Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
295 ScaleFactor factor[2];
298 assert(threadID >= 0 && threadID < MAX_THREADS);
299 assert(!pos.is_check());
301 memset(&ei, 0, sizeof(EvalInfo));
303 // Initialize by reading the incrementally updated scores included in the
304 // position object (material + piece square tables)
305 ei.value = pos.value();
307 // Probe the material hash table
308 ei.mi = MaterialTable[threadID]->get_material_info(pos);
309 ei.value += ei.mi->material_value();
311 // If we have a specialized evaluation function for the current material
312 // configuration, call it and return
313 if (ei.mi->specialized_eval_exists())
314 return ei.mi->evaluate(pos);
316 // After get_material_info() call that modifies them
317 factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
318 factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
320 // Probe the pawn hash table
321 ei.pi = PawnTable[threadID]->get_pawn_info(pos);
322 ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
324 // Initialize attack bitboards with pawns evaluation
325 init_attack_tables<WHITE, HasPopCnt>(pos, ei);
326 init_attack_tables<BLACK, HasPopCnt>(pos, ei);
329 evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
330 evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
332 // Kings. Kings are evaluated after all other pieces for both sides,
333 // because we need complete attack information for all pieces when computing
334 // the king safety evaluation.
335 evaluate_king<WHITE, HasPopCnt>(pos, ei);
336 evaluate_king<BLACK, HasPopCnt>(pos, ei);
338 // Evaluate tactical threats, we need full attack info including king
339 evaluate_threats<WHITE>(pos, ei);
340 evaluate_threats<BLACK>(pos, ei);
342 // Evaluate passed pawns, we need full attack info including king
343 evaluate_passed_pawns<WHITE>(pos, ei);
344 evaluate_passed_pawns<BLACK>(pos, ei);
346 // If one side has only a king, check whether exsists any unstoppable passed pawn
347 if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
348 evaluate_unstoppable_pawns(pos, ei);
350 Phase phase = ei.mi->game_phase();
352 // Middle-game specific evaluation terms
353 if (phase > PHASE_ENDGAME)
355 // Pawn storms in positions with opposite castling
356 if ( square_file(pos.king_square(WHITE)) >= FILE_E
357 && square_file(pos.king_square(BLACK)) <= FILE_D)
359 ei.value += make_score(ei.pi->queenside_storm_value(WHITE) - ei.pi->kingside_storm_value(BLACK), 0);
361 else if ( square_file(pos.king_square(WHITE)) <= FILE_D
362 && square_file(pos.king_square(BLACK)) >= FILE_E)
364 ei.value += make_score(ei.pi->kingside_storm_value(WHITE) - ei.pi->queenside_storm_value(BLACK), 0);
366 // Evaluate space for both sides
367 if (ei.mi->space_weight() > 0)
369 evaluate_space<WHITE, HasPopCnt>(pos, ei);
370 evaluate_space<BLACK, HasPopCnt>(pos, ei);
375 ei.value += apply_weight(ei.mobility, Weights[Mobility]);
377 // If we don't already have an unusual scale factor, check for opposite
378 // colored bishop endgames, and use a lower scale for those
379 if ( phase < PHASE_MIDGAME
380 && pos.opposite_colored_bishops()
381 && ( (factor[WHITE] == SCALE_FACTOR_NORMAL && eg_value(ei.value) > Value(0))
382 || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(ei.value) < Value(0))))
386 // Only the two bishops ?
387 if ( pos.non_pawn_material(WHITE) == BishopValueMidgame
388 && pos.non_pawn_material(BLACK) == BishopValueMidgame)
390 // Check for KBP vs KB with only a single pawn that is almost
391 // certainly a draw or at least two pawns.
392 bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
393 sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
396 // Endgame with opposite-colored bishops, but also other pieces. Still
397 // a bit drawish, but not as drawish as with only the two bishops.
398 sf = ScaleFactor(50);
400 if (factor[WHITE] == SCALE_FACTOR_NORMAL)
402 if (factor[BLACK] == SCALE_FACTOR_NORMAL)
406 // Interpolate between the middle game and the endgame score
407 return Sign[pos.side_to_move()] * scale_by_game_phase(ei.value, phase, factor);
412 /// init_eval() initializes various tables used by the evaluation function
414 void init_eval(int threads) {
416 assert(threads <= MAX_THREADS);
418 for (int i = 0; i < MAX_THREADS; i++)
423 delete MaterialTable[i];
425 MaterialTable[i] = NULL;
429 PawnTable[i] = new PawnInfoTable(PawnTableSize);
430 if (!MaterialTable[i])
431 MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
436 /// quit_eval() releases heap-allocated memory at program termination
440 for (int i = 0; i < MAX_THREADS; i++)
443 delete MaterialTable[i];
445 MaterialTable[i] = NULL;
450 /// read_weights() reads evaluation weights from the corresponding UCI parameters
452 void read_weights(Color us) {
454 // King safety is asymmetrical. Our king danger level is weighted by
455 // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
456 const int kingDangerUs = (us == WHITE ? KingDangerUs : KingDangerThem);
457 const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
459 Weights[Mobility] = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
460 Weights[PawnStructure] = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
461 Weights[PassedPawns] = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
462 Weights[Space] = weight_option("Space", "Space", WeightsInternal[Space]);
463 Weights[kingDangerUs] = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
464 Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
466 // If running in analysis mode, make sure we use symmetrical king safety. We do this
467 // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
468 if (get_option_value_bool("UCI_AnalyseMode"))
469 Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
477 // init_king_tables() initializes king bitboards for both sides adding
478 // pawn attacks. To be done before other evaluations.
480 template<Color Us, bool HasPopCnt>
481 void init_attack_tables(const Position& pos, EvalInfo& ei) {
483 const Color Them = (Us == WHITE ? BLACK : WHITE);
485 Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
486 ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
487 ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
488 b &= ei.attackedBy[Us][PAWN];
490 ei.kingAttackersCount[Us] = count_1s_max_15<HasPopCnt>(b) / 2;
494 // evaluate_outposts() evaluates bishop and knight outposts squares
496 template<PieceType Piece, Color Us>
497 void evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
499 const Color Them = (Us == WHITE ? BLACK : WHITE);
501 // Initial bonus based on square
502 Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
503 : KnightOutpostBonus[relative_square(Us, s)]);
505 // Increase bonus if supported by pawn, especially if the opponent has
506 // no minor piece which can exchange the outpost piece
507 if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
509 if ( pos.pieces(KNIGHT, Them) == EmptyBoardBB
510 && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
511 bonus += bonus + bonus / 2;
515 ei.value += Sign[Us] * make_score(bonus, bonus);
519 // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
521 template<PieceType Piece, Color Us, bool HasPopCnt>
522 void evaluate_pieces(const Position& pos, EvalInfo& ei, Bitboard no_mob_area) {
529 const Color Them = (Us == WHITE ? BLACK : WHITE);
530 const Square* ptr = pos.piece_list_begin(Us, Piece);
532 while ((s = *ptr++) != SQ_NONE)
534 // Find attacked squares, including x-ray attacks for bishops and rooks
535 if (Piece == KNIGHT || Piece == QUEEN)
536 b = pos.attacks_from<Piece>(s);
537 else if (Piece == BISHOP)
538 b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
539 else if (Piece == ROOK)
540 b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
544 // Update attack info
545 ei.attackedBy[Us][Piece] |= b;
548 if (b & ei.kingZone[Us])
550 ei.kingAttackersCount[Us]++;
551 ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
552 Bitboard bb = (b & ei.attackedBy[Them][KING]);
554 ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
558 mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & no_mob_area)
559 : count_1s<HasPopCnt>(b & no_mob_area));
561 ei.mobility += Sign[Us] * MobilityBonus[Piece][mob];
563 // Decrease score if we are attacked by an enemy pawn. Remaining part
564 // of threat evaluation must be done later when we have full attack info.
565 if (bit_is_set(ei.attackedBy[Them][PAWN], s))
566 ei.value -= Sign[Us] * ThreatedByPawnPenalty[Piece];
568 // Bishop and knight outposts squares
569 if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
570 evaluate_outposts<Piece, Us>(pos, ei, s);
572 // Special patterns: trapped bishops on a7/h7/a2/h2
573 // and trapped bishops on a1/h1/a8/h8 in Chess960.
576 if (bit_is_set(MaskA7H7[Us], s))
577 evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
579 if (Chess960 && bit_is_set(MaskA1H1[Us], s))
580 evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
583 // Queen or rook on 7th rank
584 if ( (Piece == ROOK || Piece == QUEEN)
585 && relative_rank(Us, s) == RANK_7
586 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
588 ei.value += Sign[Us] * (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
591 // Special extra evaluation for rooks
594 // Open and half-open files
596 if (ei.pi->file_is_half_open(Us, f))
598 if (ei.pi->file_is_half_open(Them, f))
599 ei.value += Sign[Us] * RookOpenFileBonus;
601 ei.value += Sign[Us] * RookHalfOpenFileBonus;
604 // Penalize rooks which are trapped inside a king. Penalize more if
605 // king has lost right to castle.
606 if (mob > 6 || ei.pi->file_is_half_open(Us, f))
609 ksq = pos.king_square(Us);
611 if ( square_file(ksq) >= FILE_E
612 && square_file(s) > square_file(ksq)
613 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
615 // Is there a half-open file between the king and the edge of the board?
616 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
617 ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
618 : (TrappedRookPenalty - mob * 16), 0);
620 else if ( square_file(ksq) <= FILE_D
621 && square_file(s) < square_file(ksq)
622 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
624 // Is there a half-open file between the king and the edge of the board?
625 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
626 ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
627 : (TrappedRookPenalty - mob * 16), 0);
634 // evaluate_threats<>() assigns bonuses according to the type of attacking piece
635 // and the type of attacked one.
638 void evaluate_threats(const Position& pos, EvalInfo& ei) {
640 const Color Them = (Us == WHITE ? BLACK : WHITE);
644 int sente, threatCount = 0;
645 Score bonus = make_score(0, 0);
647 // Enemy pieces not defended by a pawn and under our attack
648 Bitboard weakEnemies = pos.pieces_of_color(Them)
649 & ~ei.attackedBy[Them][PAWN]
650 & ei.attackedBy[Us][0];
654 // Add bonus according to type of attacked enemy pieces and to the
655 // type of attacking piece, from knights to queens. Kings are not
656 // considered because are already special handled in king evaluation.
657 for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
659 b = ei.attackedBy[Us][pt1] & weakEnemies;
661 for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
662 if (b & pos.pieces(pt2))
664 bonus += ThreatBonus[pt1][pt2];
669 sente = (Us == pos.side_to_move());
671 // Non linear threat evaluation. Increase threats score according to the
672 // number of concurrent threats and to the side to move.
673 mg = (mg_value(bonus) + mg_value(bonus) * ConcurrentThreatsWeight[sente] * threatCount / 256) * ThreatsWeight[sente] / 256;
674 eg = (eg_value(bonus) + eg_value(bonus) * ConcurrentThreatsWeight[sente] * threatCount / 256) * ThreatsWeight[sente] / 256;
676 ei.value += Sign[Us] * make_score(mg, eg);
680 // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
681 // pieces of a given color.
683 template<Color Us, bool HasPopCnt>
684 void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
686 const Color Them = (Us == WHITE ? BLACK : WHITE);
688 // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
689 const Bitboard no_mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
691 evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, no_mob_area);
692 evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, no_mob_area);
693 evaluate_pieces<ROOK, Us, HasPopCnt>(pos, ei, no_mob_area);
694 evaluate_pieces<QUEEN, Us, HasPopCnt>(pos, ei, no_mob_area);
696 // Sum up all attacked squares
697 ei.attackedBy[Us][0] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
698 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
699 | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
703 // evaluate_king<>() assigns bonuses and penalties to a king of a given color
705 template<Color Us, bool HasPopCnt>
706 void evaluate_king(const Position& pos, EvalInfo& ei) {
708 const Color Them = (Us == WHITE ? BLACK : WHITE);
710 Bitboard undefended, b, b1, b2, safe;
712 int attackUnits, shelter = 0;
713 const Square ksq = pos.king_square(Us);
716 if (relative_rank(Us, ksq) <= RANK_4)
718 shelter = ei.pi->get_king_shelter(pos, Us, ksq);
719 ei.value += Sign[Us] * make_score(shelter, 0);
722 // King safety. This is quite complicated, and is almost certainly far
723 // from optimally tuned.
724 if ( pos.piece_count(Them, QUEEN) >= 1
725 && ei.kingAttackersCount[Them] >= 2
726 && pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
727 && ei.kingAdjacentZoneAttacksCount[Them])
729 // Is it the attackers turn to move?
730 sente = (Them == pos.side_to_move());
732 // Find the attacked squares around the king which has no defenders
733 // apart from the king itself
734 undefended = ei.attacked_by(Them) & ei.attacked_by(Us, KING);
735 undefended &= ~( ei.attacked_by(Us, PAWN) | ei.attacked_by(Us, KNIGHT)
736 | ei.attacked_by(Us, BISHOP) | ei.attacked_by(Us, ROOK)
737 | ei.attacked_by(Us, QUEEN));
739 // Initialize the 'attackUnits' variable, which is used later on as an
740 // index to the KingDangerTable[] array. The initial value is based on
741 // the number and types of the enemy's attacking pieces, the number of
742 // attacked and undefended squares around our king, the square of the
743 // king, and the quality of the pawn shelter.
744 attackUnits = Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
745 + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended))
746 + InitKingDanger[relative_square(Us, ksq)]
749 // Analyse enemy's safe queen contact checks. First find undefended
750 // squares around the king attacked by enemy queen...
751 b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
754 // ...then remove squares not supported by another enemy piece
755 b &= ( ei.attacked_by(Them, PAWN) | ei.attacked_by(Them, KNIGHT)
756 | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK));
758 attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
761 // Analyse enemy's safe distance checks for sliders and knights
762 safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us));
764 b1 = pos.attacks_from<ROOK>(ksq) & safe;
765 b2 = pos.attacks_from<BISHOP>(ksq) & safe;
767 // Enemy queen safe checks
768 b = (b1 | b2) & ei.attacked_by(Them, QUEEN);
770 attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
772 // Enemy rooks safe checks
773 b = b1 & ei.attacked_by(Them, ROOK);
775 attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
777 // Enemy bishops safe checks
778 b = b2 & ei.attacked_by(Them, BISHOP);
780 attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
782 // Enemy knights safe checks
783 b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe;
785 attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
787 // To index KingDangerTable[] attackUnits must be in [0, 99] range
788 attackUnits = Min(99, Max(0, attackUnits));
790 // Finally, extract the king danger score from the KingDangerTable[]
791 // array and subtract the score from evaluation. Set also ei.kingDanger[]
792 // value that will be used for pruning because this value can sometimes
793 // be very big, and so capturing a single attacking piece can therefore
794 // result in a score change far bigger than the value of the captured piece.
795 ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
796 ei.kingDanger[Us] = mg_value(KingDangerTable[Us][attackUnits]);
801 // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
804 void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
806 const Color Them = (Us == WHITE ? BLACK : WHITE);
808 Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
809 Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(Us);
813 Square s = pop_1st_bit(&b);
815 assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
816 assert(pos.pawn_is_passed(Us, s));
818 int r = int(relative_rank(Us, s) - RANK_2);
819 int tr = r * (r - 1);
821 // Base bonus based on rank
822 Value mbonus = Value(20 * tr);
823 Value ebonus = Value(10 + r * r * 10);
827 Square blockSq = s + pawn_push(Us);
829 // Adjust bonus based on kings proximity
830 ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * tr);
831 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * 1 * tr);
832 ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * tr);
834 // If the pawn is free to advance, increase bonus
835 if (pos.square_is_empty(blockSq))
837 squaresToQueen = squares_in_front_of(Us, s);
838 defendedSquares = squaresToQueen & ei.attacked_by(Us);
840 // If there is an enemy rook or queen attacking the pawn from behind,
841 // add all X-ray attacks by the rook or queen. Otherwise consider only
842 // the squares in the pawn's path attacked or occupied by the enemy.
843 if ( (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
844 && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<QUEEN>(s)))
845 unsafeSquares = squaresToQueen;
847 unsafeSquares = squaresToQueen & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
849 // If there aren't enemy attacks or pieces along the path to queen give
850 // huge bonus. Even bigger if we protect the pawn's path.
852 ebonus += Value(tr * (squaresToQueen == defendedSquares ? 17 : 15));
854 // OK, there are enemy attacks or pieces (but not pawns). Are those
855 // squares which are attacked by the enemy also attacked by us ?
856 // If yes, big bonus (but smaller than when there are no enemy attacks),
857 // if no, somewhat smaller bonus.
858 ebonus += Value(tr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
860 // At last, add a small bonus when there are no *friendly* pieces
861 // in the pawn's path.
862 if (!(squaresToQueen & pos.pieces_of_color(Us)))
867 // Increase the bonus if the passed pawn is supported by a friendly pawn
868 // on the same rank and a bit smaller if it's on the previous rank.
869 supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
870 if (supportingPawns & rank_bb(s))
871 ebonus += Value(r * 20);
872 else if (supportingPawns & rank_bb(s - pawn_push(Us)))
873 ebonus += Value(r * 12);
875 // Rook pawns are a special case: They are sometimes worse, and
876 // sometimes better than other passed pawns. It is difficult to find
877 // good rules for determining whether they are good or bad. For now,
878 // we try the following: Increase the value for rook pawns if the
879 // other side has no pieces apart from a knight, and decrease the
880 // value if the other side has a rook or queen.
881 if (square_file(s) == FILE_A || square_file(s) == FILE_H)
883 if ( pos.non_pawn_material(Them) <= KnightValueMidgame
884 && pos.piece_count(Them, KNIGHT) <= 1)
885 ebonus += ebonus / 4;
886 else if (pos.pieces(ROOK, QUEEN, Them))
887 ebonus -= ebonus / 4;
890 // Add the scores for this pawn to the middle game and endgame eval
891 ei.value += Sign[Us] * apply_weight(make_score(mbonus, ebonus), Weights[PassedPawns]);
897 // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides
899 void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
901 int movesToGo[2] = {0, 0};
902 Square pawnToGo[2] = {SQ_NONE, SQ_NONE};
904 for (Color c = WHITE; c <= BLACK; c++)
906 // Skip evaluation if other side has non-pawn pieces
907 if (pos.non_pawn_material(opposite_color(c)))
910 Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(c);
914 Square s = pop_1st_bit(&b);
915 Square queeningSquare = relative_square(c, make_square(square_file(s), RANK_8));
916 int d = square_distance(s, queeningSquare)
917 - (relative_rank(c, s) == RANK_2) // Double pawn push
918 - square_distance(pos.king_square(opposite_color(c)), queeningSquare)
919 + int(c != pos.side_to_move());
923 int mtg = RANK_8 - relative_rank(c, s);
924 int blockerCount = count_1s_max_15(squares_in_front_of(c, s) & pos.occupied_squares());
927 if (d < 0 && (!movesToGo[c] || movesToGo[c] > mtg))
936 // Neither side has an unstoppable passed pawn?
937 if (!(movesToGo[WHITE] | movesToGo[BLACK]))
940 // Does only one side have an unstoppable passed pawn?
941 if (!movesToGo[WHITE] || !movesToGo[BLACK])
943 Color winnerSide = movesToGo[WHITE] ? WHITE : BLACK;
944 ei.value += make_score(0, Sign[winnerSide] * (UnstoppablePawnValue - Value(0x40 * movesToGo[winnerSide])));
947 { // Both sides have unstoppable pawns! Try to find out who queens
948 // first. We begin by transforming 'movesToGo' to the number of
949 // plies until the pawn queens for both sides.
950 movesToGo[WHITE] *= 2;
951 movesToGo[BLACK] *= 2;
952 movesToGo[pos.side_to_move()]--;
954 Color winnerSide = movesToGo[WHITE] < movesToGo[BLACK] ? WHITE : BLACK;
955 Color loserSide = opposite_color(winnerSide);
957 // If one side queens at least three plies before the other, that side wins
958 if (movesToGo[winnerSide] <= movesToGo[loserSide] - 3)
959 ei.value += Sign[winnerSide] * make_score(0, UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2)));
961 // If one side queens one ply before the other and checks the king or attacks
962 // the undefended opponent's queening square, that side wins. To avoid cases
963 // where the opponent's king could move somewhere before first pawn queens we
964 // consider only free paths to queen for both pawns.
965 else if ( !(squares_in_front_of(WHITE, pawnToGo[WHITE]) & pos.occupied_squares())
966 && !(squares_in_front_of(BLACK, pawnToGo[BLACK]) & pos.occupied_squares()))
968 assert(movesToGo[loserSide] - movesToGo[winnerSide] == 1);
970 Square winnerQSq = relative_square(winnerSide, make_square(square_file(pawnToGo[winnerSide]), RANK_8));
971 Square loserQSq = relative_square(loserSide, make_square(square_file(pawnToGo[loserSide]), RANK_8));
973 Bitboard b = pos.occupied_squares();
974 clear_bit(&b, pawnToGo[winnerSide]);
975 clear_bit(&b, pawnToGo[loserSide]);
976 b = queen_attacks_bb(winnerQSq, b);
978 if ( (b & pos.pieces(KING, loserSide))
979 ||(bit_is_set(b, loserQSq) && !bit_is_set(ei.attacked_by(loserSide), loserQSq)))
980 ei.value += Sign[winnerSide] * make_score(0, UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2)));
986 // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
987 // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
990 void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo &ei) {
992 assert(square_is_ok(s));
993 assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
995 Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
996 Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
998 if ( pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
999 && pos.see(s, b6) < 0
1000 && pos.see(s, b8) < 0)
1002 ei.value -= Sign[us] * TrappedBishopA7H7Penalty;
1007 // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1008 // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1009 // black), and assigns a penalty if it is. This pattern can obviously
1010 // only occur in Chess960 games.
1012 void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei) {
1014 Piece pawn = piece_of_color_and_type(us, PAWN);
1018 assert(square_is_ok(s));
1019 assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1021 if (square_file(s) == FILE_A)
1023 b2 = relative_square(us, SQ_B2);
1024 b3 = relative_square(us, SQ_B3);
1025 c3 = relative_square(us, SQ_C3);
1029 b2 = relative_square(us, SQ_G2);
1030 b3 = relative_square(us, SQ_G3);
1031 c3 = relative_square(us, SQ_F3);
1034 if (pos.piece_on(b2) == pawn)
1038 if (!pos.square_is_empty(b3))
1039 penalty = 2 * TrappedBishopA1H1Penalty;
1040 else if (pos.piece_on(c3) == pawn)
1041 penalty = TrappedBishopA1H1Penalty;
1043 penalty = TrappedBishopA1H1Penalty / 2;
1045 ei.value -= Sign[us] * penalty;
1050 // evaluate_space() computes the space evaluation for a given side. The
1051 // space evaluation is a simple bonus based on the number of safe squares
1052 // available for minor pieces on the central four files on ranks 2--4. Safe
1053 // squares one, two or three squares behind a friendly pawn are counted
1054 // twice. Finally, the space bonus is scaled by a weight taken from the
1055 // material hash table.
1056 template<Color Us, bool HasPopCnt>
1057 void evaluate_space(const Position& pos, EvalInfo& ei) {
1059 const Color Them = (Us == WHITE ? BLACK : WHITE);
1061 // Find the safe squares for our pieces inside the area defined by
1062 // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
1063 // pawn, or if it is undefended and attacked by an enemy piece.
1064 Bitboard safeSquares = SpaceMask[Us]
1065 & ~pos.pieces(PAWN, Us)
1066 & ~ei.attacked_by(Them, PAWN)
1067 & (ei.attacked_by(Us) | ~ei.attacked_by(Them));
1069 // Find all squares which are at most three squares behind some friendly pawn
1070 Bitboard behindFriendlyPawns = pos.pieces(PAWN, Us);
1071 behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >> 8 : behindFriendlyPawns << 8);
1072 behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >> 16 : behindFriendlyPawns << 16);
1074 int space = count_1s_max_15<HasPopCnt>(safeSquares)
1075 + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
1077 ei.value += Sign[Us] * apply_weight(make_score(space * ei.mi->space_weight(), 0), Weights[Space]);
1081 // apply_weight() applies an evaluation weight to a value trying to prevent overflow
1083 inline Score apply_weight(Score v, Score w) {
1084 return make_score((int(mg_value(v)) * mg_value(w)) / 0x100, (int(eg_value(v)) * eg_value(w)) / 0x100);
1088 // scale_by_game_phase() interpolates between a middle game and an endgame
1089 // score, based on game phase. It also scales the return value by a
1090 // ScaleFactor array.
1092 Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]) {
1094 assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
1095 assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
1096 assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1098 Value ev = apply_scale_factor(eg_value(v), sf[(eg_value(v) > Value(0) ? WHITE : BLACK)]);
1100 int result = (mg_value(v) * ph + ev * (128 - ph)) / 128;
1101 return Value(result & ~(GrainSize - 1));
1105 // weight_option() computes the value of an evaluation weight, by combining
1106 // two UCI-configurable weights (midgame and endgame) with an internal weight.
1108 Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
1110 // Scale option value from 100 to 256
1111 int mg = get_option_value_int(mgOpt) * 256 / 100;
1112 int eg = get_option_value_int(egOpt) * 256 / 100;
1114 return apply_weight(make_score(mg, eg), internalWeight);
1117 // init_safety() initizes the king safety evaluation, based on UCI
1118 // parameters. It is called from read_weights().
1120 void init_safety() {
1122 const Value MaxSlope = Value(30);
1123 const Value Peak = Value(1280);
1126 // First setup the base table
1127 for (int i = 0; i < 100; i++)
1129 t[i] = Value(int(0.4 * i * i));
1132 t[i] = Min(t[i], t[i - 1] + MaxSlope);
1134 t[i] = Min(t[i], Peak);
1137 // Then apply the weights and get the final KingDangerTable[] array
1138 for (Color c = WHITE; c <= BLACK; c++)
1139 for (int i = 0; i < 100; i++)
1140 KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);