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-2009 Marco Costalba
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 = 4;
48 // Evaluation weights, initialized from UCI options
49 int WeightMobilityMidgame, WeightMobilityEndgame;
50 int WeightPawnStructureMidgame, WeightPawnStructureEndgame;
51 int WeightPassedPawnsMidgame, WeightPassedPawnsEndgame;
52 int WeightKingSafety[2];
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 int WeightMobilityMidgameInternal = 0x0FA;
62 const int WeightMobilityEndgameInternal = 0x10A;
63 const int WeightPawnStructureMidgameInternal = 0x0EC;
64 const int WeightPawnStructureEndgameInternal = 0x0CD;
65 const int WeightPassedPawnsMidgameInternal = 0x108;
66 const int WeightPassedPawnsEndgameInternal = 0x109;
67 const int WeightKingSafetyInternal = 0x0F7;
68 const int WeightKingOppSafetyInternal = 0x101;
69 const int WeightSpaceInternal = 0x02F;
71 // Visually better to define tables constants
74 // Knight mobility bonus in middle game and endgame, indexed by the number
75 // of attacked squares not occupied by friendly piecess.
76 const Value MidgameKnightMobilityBonus[] = {
78 V(-30), V(-20),V(-10), V(0), V(10), V(20), V(25), V(30), V(30)
81 const Value EndgameKnightMobilityBonus[] = {
83 V(-30), V(-20),V(-10), V(0), V(10), V(20), V(25), V(30), V(30)
86 // Bishop mobility bonus in middle game and endgame, indexed by the number
87 // of attacked squares not occupied by friendly pieces. X-ray attacks through
88 // queens are also included.
89 const Value MidgameBishopMobilityBonus[] = {
91 V(-30), V(-15), V(0), V(15), V(30), V(45), V(58), V(66),
92 // 8 9 10 11 12 13 14 15
93 V( 72), V( 76), V(78), V(80), V(81), V(82), V(83), V(83)
96 const Value EndgameBishopMobilityBonus[] = {
98 V(-30), V(-15), V(0), V(15), V(30), V(45), V(58), V(66),
99 // 8 9 10 11 12 13 14 15
100 V( 72), V( 76), V(78), V(80), V(81), V(82), V(83), V(83)
103 // Rook mobility bonus in middle game and endgame, indexed by the number
104 // of attacked squares not occupied by friendly pieces. X-ray attacks through
105 // queens and rooks are also included.
106 const Value MidgameRookMobilityBonus[] = {
108 V(-18), V(-12), V(-6), V(0), V(6), V(12), V(16), V(21),
109 // 8 9 10 11 12 13 14 15
110 V( 24), V( 27), V(28), V(29), V(30), V(31), V(32), V(33)
113 const Value EndgameRookMobilityBonus[] = {
115 V(-30), V(-18), V(-6), V(6), V(18), V(30), V(42), V(54),
116 // 8 9 10 11 12 13 14 15
117 V( 66), V( 74), V(78), V(80), V(81), V(82), V(83), V(83)
120 // Queen mobility bonus in middle game and endgame, indexed by the number
121 // of attacked squares not occupied by friendly pieces.
122 const Value MidgameQueenMobilityBonus[] = {
124 V(-10), V(-8), V(-6), V(-4), V(-2), V( 0), V( 2), V( 4),
125 // 8 9 10 11 12 13 14 15
126 V( 6), V( 8), V(10), V(12), V(13), V(14), V(15), V(16),
127 // 16 17 18 19 20 21 22 23
128 V( 16), V(16), V(16), V(16), V(16), V(16), V(16), V(16),
129 // 24 25 26 27 28 29 30 31
130 V( 16), V(16), V(16), V(16), V(16), V(16), V(16), V(16)
133 const Value EndgameQueenMobilityBonus[] = {
135 V(-20),V(-15),V(-10), V(-5), V( 0), V( 5), V(10), V(15),
136 // 8 9 10 11 12 13 14 15
137 V( 19), V(23), V(27), V(29), V(30), V(30), V(30), V(30),
138 // 16 17 18 19 20 21 22 23
139 V( 30), V(30), V(30), V(30), V(30), V(30), V(30), V(30),
140 // 24 25 26 27 28 29 30 31
141 V( 30), V(30), V(30), V(30), V(30), V(30), V(30), V(30)
144 // Outpost bonuses for knights and bishops, indexed by square (from white's
146 const Value KnightOutpostBonus[64] = {
148 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
149 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
150 V(0), V(0), V(5),V(10),V(10), V(5), V(0), V(0), // 3
151 V(0), V(5),V(20),V(30),V(30),V(20), V(5), V(0), // 4
152 V(0),V(10),V(30),V(40),V(40),V(30),V(10), V(0), // 5
153 V(0), V(5),V(20),V(20),V(20),V(20), V(5), V(0), // 6
154 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
155 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) // 8
158 const Value BishopOutpostBonus[64] = {
160 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
161 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
162 V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), // 3
163 V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), // 4
164 V(0),V(10),V(20),V(20),V(20),V(20),V(10), V(0), // 5
165 V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0), // 6
166 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
167 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) // 8
170 // Bonus for unstoppable passed pawns
171 const Value UnstoppablePawnValue = Value(0x500);
173 // Rooks and queens on the 7th rank
174 const Value MidgameRookOn7thBonus = Value(47);
175 const Value EndgameRookOn7thBonus = Value(98);
176 const Value MidgameQueenOn7thBonus = Value(27);
177 const Value EndgameQueenOn7thBonus = Value(54);
179 // Rooks on open files
180 const Value RookOpenFileBonus = Value(43);
181 const Value RookHalfOpenFileBonus = Value(19);
183 // Penalty for rooks trapped inside a friendly king which has lost the
185 const Value TrappedRookPenalty = Value(180);
187 // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
189 const Value TrappedBishopA7H7Penalty = Value(300);
191 // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
192 const Bitboard MaskA7H7[2] = {
193 ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
194 ((1ULL << SQ_A2) | (1ULL << SQ_H2))
197 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
198 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
199 // happen in Chess960 games.
200 const Value TrappedBishopA1H1Penalty = Value(100);
202 // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
203 const Bitboard MaskA1H1[2] = {
204 ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
205 ((1ULL << SQ_A8) | (1ULL << SQ_H8))
208 // The SpaceMask[color] contains area of the board which is consdered by
209 // the space evaluation. In the middle game, each side is given a bonus
210 // based on how many squares inside this area are safe and available for
211 // friendly minor pieces.
212 const Bitboard SpaceMask[2] = {
213 (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
214 (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
215 (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
216 (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
217 (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
218 (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
221 /// King safety constants and variables. The king safety scores are taken
222 /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
223 /// the strength of the attack are added up into an integer, which is used
224 /// as an index to SafetyTable[].
226 // Attack weights for each piece type
227 const int QueenAttackWeight = 5;
228 const int RookAttackWeight = 3;
229 const int BishopAttackWeight = 2;
230 const int KnightAttackWeight = 2;
232 // Bonuses for safe checks, initialized from UCI options
233 int QueenContactCheckBonus, DiscoveredCheckBonus;
234 int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
236 // Scan for queen contact mates?
237 const bool QueenContactMates = true;
239 // Bonus for having a mate threat, initialized from UCI options
242 // InitKingDanger[] contains bonuses based on the position of the defending
244 const int InitKingDanger[64] = {
245 2, 0, 2, 5, 5, 2, 0, 2,
246 2, 2, 4, 8, 8, 4, 2, 2,
247 7, 10, 12, 12, 12, 12, 10, 7,
248 15, 15, 15, 15, 15, 15, 15, 15,
249 15, 15, 15, 15, 15, 15, 15, 15,
250 15, 15, 15, 15, 15, 15, 15, 15,
251 15, 15, 15, 15, 15, 15, 15, 15,
252 15, 15, 15, 15, 15, 15, 15, 15
255 // SafetyTable[] contains the actual king safety scores. It is initialized
257 Value SafetyTable[100];
259 // Pawn and material hash tables, indexed by the current thread id
260 PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
261 MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
263 // Sizes of pawn and material hash tables
264 const int PawnTableSize = 16384;
265 const int MaterialTableSize = 1024;
267 // Array which gives the number of nonzero bits in an 8-bit integer
268 uint8_t BitCount8Bit[256];
270 // Function prototypes
271 template<PieceType Piece>
272 void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
275 void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo &ei);
277 void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
278 void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
280 void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
283 void evaluate_space(const Position &p, Color us, EvalInfo &ei);
284 inline Value apply_weight(Value v, int w);
285 Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
287 int compute_weight(int uciWeight, int internalWeight);
288 int weight_option(const std::string& opt, int weight);
298 /// evaluate() is the main evaluation function. It always computes two
299 /// values, an endgame score and a middle game score, and interpolates
300 /// between them based on the remaining material.
302 Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
305 assert(threadID >= 0 && threadID < THREAD_MAX);
307 memset(&ei, 0, sizeof(EvalInfo));
309 // Initialize by reading the incrementally updated scores included in the
310 // position object (material + piece square tables)
311 ei.mgValue = pos.mg_value();
312 ei.egValue = pos.eg_value();
314 // Probe the material hash table
315 ei.mi = MaterialTable[threadID]->get_material_info(pos);
316 ei.mgValue += ei.mi->mg_value();
317 ei.egValue += ei.mi->eg_value();
319 // If we have a specialized evaluation function for the current material
320 // configuration, call it and return
321 if (ei.mi->specialized_eval_exists())
322 return ei.mi->evaluate(pos);
324 // After get_material_info() call that modifies them
325 ScaleFactor factor[2];
326 factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
327 factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
329 // Probe the pawn hash table
330 ei.pi = PawnTable[threadID]->get_pawn_info(pos);
331 ei.mgValue += apply_weight(ei.pi->mg_value(), WeightPawnStructureMidgame);
332 ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
334 // Initialize king attack bitboards and king attack zones for both sides
335 ei.attackedBy[WHITE][KING] = pos.piece_attacks<KING>(pos.king_square(WHITE));
336 ei.attackedBy[BLACK][KING] = pos.piece_attacks<KING>(pos.king_square(BLACK));
337 ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
338 ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
340 // Initialize pawn attack bitboards for both sides
341 ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
342 ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
343 ei.kingAttackersCount[WHITE] = count_1s_max_15<false>(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
344 ei.kingAttackersCount[BLACK] = count_1s_max_15<false>(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
347 for (Color c = WHITE; c <= BLACK; c++)
349 evaluate_pieces<KNIGHT>(pos, c, ei);
350 evaluate_pieces<BISHOP>(pos, c, ei);
351 evaluate_pieces<ROOK>(pos, c, ei);
352 evaluate_pieces<QUEEN>(pos, c, ei);
354 // Sum up all attacked squares
355 ei.attackedBy[c][0] = ei.attackedBy[c][PAWN] | ei.attackedBy[c][KNIGHT]
356 | ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
357 | ei.attackedBy[c][QUEEN] | ei.attackedBy[c][KING];
360 // Kings. Kings are evaluated after all other pieces for both sides,
361 // because we need complete attack information for all pieces when computing
362 // the king safety evaluation.
363 for (Color c = WHITE; c <= BLACK; c++)
364 evaluate_pieces<KING>(pos, c, ei);
366 // Evaluate passed pawns. We evaluate passed pawns for both sides at once,
367 // because we need to know which side promotes first in positions where
368 // both sides have an unstoppable passed pawn.
369 if (ei.pi->passed_pawns())
370 evaluate_passed_pawns(pos, ei);
372 Phase phase = pos.game_phase();
374 // Middle-game specific evaluation terms
375 if (phase > PHASE_ENDGAME)
377 // Pawn storms in positions with opposite castling.
378 if ( square_file(pos.king_square(WHITE)) >= FILE_E
379 && square_file(pos.king_square(BLACK)) <= FILE_D)
381 ei.mgValue += ei.pi->queenside_storm_value(WHITE)
382 - ei.pi->kingside_storm_value(BLACK);
384 else if ( square_file(pos.king_square(WHITE)) <= FILE_D
385 && square_file(pos.king_square(BLACK)) >= FILE_E)
387 ei.mgValue += ei.pi->kingside_storm_value(WHITE)
388 - ei.pi->queenside_storm_value(BLACK);
390 // Evaluate space for both sides
391 if (ei.mi->space_weight() > 0)
393 evaluate_space(pos, WHITE, ei);
394 evaluate_space(pos, BLACK, ei);
399 ei.mgValue += apply_weight(ei.mgMobility, WeightMobilityMidgame);
400 ei.egValue += apply_weight(ei.egMobility, WeightMobilityEndgame);
402 // If we don't already have an unusual scale factor, check for opposite
403 // colored bishop endgames, and use a lower scale for those
404 if ( phase < PHASE_MIDGAME
405 && pos.opposite_colored_bishops()
406 && ( (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
407 || (factor[BLACK] == SCALE_FACTOR_NORMAL && ei.egValue < Value(0))))
411 // Only the two bishops ?
412 if ( pos.non_pawn_material(WHITE) == BishopValueMidgame
413 && pos.non_pawn_material(BLACK) == BishopValueMidgame)
415 // Check for KBP vs KB with only a single pawn that is almost
416 // certainly a draw or at least two pawns.
417 bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
418 sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
421 // Endgame with opposite-colored bishops, but also other pieces. Still
422 // a bit drawish, but not as drawish as with only the two bishops.
423 sf = ScaleFactor(50);
425 if (factor[WHITE] == SCALE_FACTOR_NORMAL)
427 if (factor[BLACK] == SCALE_FACTOR_NORMAL)
431 // Interpolate between the middle game and the endgame score, and
433 Color stm = pos.side_to_move();
435 Value v = Sign[stm] * scale_by_game_phase(ei.mgValue, ei.egValue, phase, factor);
437 return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
441 /// quick_evaluate() does a very approximate evaluation of the current position.
442 /// It currently considers only material and piece square table scores. Perhaps
443 /// we should add scores from the pawn and material hash tables?
445 Value quick_evaluate(const Position &pos) {
450 ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
452 Value mgv = pos.mg_value();
453 Value egv = pos.eg_value();
454 Phase ph = pos.game_phase();
455 Color stm = pos.side_to_move();
457 return Sign[stm] * scale_by_game_phase(mgv, egv, ph, sf);
461 /// init_eval() initializes various tables used by the evaluation function.
463 void init_eval(int threads) {
465 assert(threads <= THREAD_MAX);
467 for (int i = 0; i < THREAD_MAX; i++)
472 delete MaterialTable[i];
474 MaterialTable[i] = NULL;
478 PawnTable[i] = new PawnInfoTable(PawnTableSize);
479 if (!MaterialTable[i])
480 MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
483 for (Bitboard b = 0ULL; b < 256ULL; b++)
485 assert(count_1s<false>(b) == int(uint8_t(count_1s<false>(b))));
486 BitCount8Bit[b] = (uint8_t)count_1s<false>(b);
491 /// quit_eval() releases heap-allocated memory at program termination.
495 for (int i = 0; i < THREAD_MAX; i++)
498 delete MaterialTable[i];
500 MaterialTable[i] = NULL;
505 /// read_weights() reads evaluation weights from the corresponding UCI
508 void read_weights(Color us) {
510 WeightMobilityMidgame = weight_option("Mobility (Middle Game)", WeightMobilityMidgameInternal);
511 WeightMobilityEndgame = weight_option("Mobility (Endgame)", WeightMobilityEndgameInternal);
512 WeightPawnStructureMidgame = weight_option("Pawn Structure (Middle Game)", WeightPawnStructureMidgameInternal);
513 WeightPawnStructureEndgame = weight_option("Pawn Structure (Endgame)", WeightPawnStructureEndgameInternal);
514 WeightPassedPawnsMidgame = weight_option("Passed Pawns (Middle Game)", WeightPassedPawnsMidgameInternal);
515 WeightPassedPawnsEndgame = weight_option("Passed Pawns (Endgame)", WeightPassedPawnsEndgameInternal);
517 Color them = opposite_color(us);
519 WeightKingSafety[us] = weight_option("Cowardice", WeightKingSafetyInternal);
520 WeightKingSafety[them] = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
521 WeightSpace = weight_option("Space", WeightSpaceInternal);
529 // evaluate_common() computes terms common to all pieces attack
531 template<PieceType Piece>
532 int evaluate_common(const Position& p, const Bitboard& b, Color us, EvalInfo& ei, Square s = SQ_NONE) {
534 static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
535 static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
536 static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
537 static const Value* OutpostBonus[] = { 0, 0, KnightOutpostBonus, BishopOutpostBonus, 0, 0 };
539 Color them = opposite_color(us);
541 // Update attack info
542 ei.attackedBy[us][Piece] |= b;
545 if (b & ei.kingZone[us])
547 ei.kingAttackersCount[us]++;
548 ei.kingAttackersWeight[us] += AttackWeight[Piece];
549 Bitboard bb = (b & ei.attackedBy[them][KING]);
551 ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<false>(bb);
554 // Remove squares protected by enemy pawns
555 Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
558 int mob = (Piece != QUEEN ? count_1s_max_15<false>(bb & ~p.pieces_of_color(us))
559 : count_1s<false>(bb & ~p.pieces_of_color(us)));
561 ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
562 ei.egMobility += Sign[us] * EgBonus[Piece][mob];
564 // Bishop and Knight outposts
565 if ( (Piece == BISHOP || Piece == KNIGHT) // compile time condition
566 && p.square_is_weak(s, them))
568 // Initial bonus based on square
570 v = bonus = OutpostBonus[Piece][relative_square(us, s)];
572 // Increase bonus if supported by pawn, especially if the opponent has
573 // no minor piece which can exchange the outpost piece
574 if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
577 if ( p.piece_count(them, KNIGHT) == 0
578 && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
581 ei.mgValue += Sign[us] * bonus;
582 ei.egValue += Sign[us] * bonus;
588 // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
591 template<PieceType Piece>
592 void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
600 for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
602 s = pos.piece_list(us, Piece, i);
604 if (Piece == KNIGHT || Piece == QUEEN)
605 b = pos.piece_attacks<Piece>(s);
606 else if (Piece == BISHOP)
607 b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.queens(us));
608 else if (Piece == ROOK)
609 b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
611 // Attacks, mobility and outposts
612 mob = evaluate_common<Piece>(pos, b, us, ei, s);
614 // Special patterns: trapped bishops on a7/h7/a2/h2
615 // and trapped bishops on a1/h1/a8/h8 in Chess960.
618 if (bit_is_set(MaskA7H7[us], s))
619 evaluate_trapped_bishop_a7h7(pos, s, us, ei);
621 if (Chess960 && bit_is_set(MaskA1H1[us], s))
622 evaluate_trapped_bishop_a1h1(pos, s, us, ei);
625 if (Piece == ROOK || Piece == QUEEN)
627 // Queen or rook on 7th rank
628 them = opposite_color(us);
630 if ( relative_rank(us, s) == RANK_7
631 && relative_rank(us, pos.king_square(them)) == RANK_8)
633 ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
634 ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
638 // Special extra evaluation for rooks
641 // Open and half-open files
643 if (ei.pi->file_is_half_open(us, f))
645 if (ei.pi->file_is_half_open(them, f))
647 ei.mgValue += Sign[us] * RookOpenFileBonus;
648 ei.egValue += Sign[us] * RookOpenFileBonus;
652 ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
653 ei.egValue += Sign[us] * RookHalfOpenFileBonus;
657 // Penalize rooks which are trapped inside a king. Penalize more if
658 // king has lost right to castle.
659 if (mob > 6 || ei.pi->file_is_half_open(us, f))
662 ksq = pos.king_square(us);
664 if ( square_file(ksq) >= FILE_E
665 && square_file(s) > square_file(ksq)
666 && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
668 // Is there a half-open file between the king and the edge of the board?
669 if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
670 ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
671 : Sign[us] * (TrappedRookPenalty - mob * 16);
673 else if ( square_file(ksq) <= FILE_D
674 && square_file(s) < square_file(ksq)
675 && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
677 // Is there a half-open file between the king and the edge of the board?
678 if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
679 ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
680 : Sign[us] * (TrappedRookPenalty - mob * 16);
686 inline Bitboard shiftRowsDown(const Bitboard& b, int num) {
688 return b >> (num << 3);
691 // evaluate_pieces<KING>() assigns bonuses and penalties to a king of a given
695 void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo& ei) {
697 int shelter = 0, sign = Sign[us];
698 Square s = p.king_square(us);
701 if (relative_rank(us, s) <= RANK_4)
703 // Shelter cache lookup
704 shelter = ei.pi->kingShelter(us, s);
708 Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
709 Rank r = square_rank(s);
710 for (int i = 1; i < 4; i++)
711 shelter += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
713 // Cache shelter value in pawn info
714 ei.pi->setKingShelter(us, s, shelter);
716 ei.mgValue += sign * Value(shelter);
719 // King safety. This is quite complicated, and is almost certainly far
720 // from optimally tuned.
721 Color them = opposite_color(us);
723 if ( p.piece_count(them, QUEEN) >= 1
724 && ei.kingAttackersCount[them] >= 2
725 && p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
726 && ei.kingAdjacentZoneAttacksCount[them])
728 // Is it the attackers turn to move?
729 bool sente = (them == p.side_to_move());
731 // Find the attacked squares around the king which has no defenders
732 // apart from the king itself
733 Bitboard undefended =
734 ei.attacked_by(them) & ~ei.attacked_by(us, PAWN)
735 & ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP)
736 & ~ei.attacked_by(us, ROOK) & ~ei.attacked_by(us, QUEEN)
737 & ei.attacked_by(us, KING);
739 Bitboard occ = p.occupied_squares(), b, b2;
741 // Initialize the 'attackUnits' variable, which is used later on as an
742 // index to the SafetyTable[] array. The initial value is based on the
743 // number and types of the attacking pieces, the number of attacked and
744 // undefended squares around the king, the square of the king, and the
745 // quality of the pawn shelter.
747 Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
748 + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<false>(undefended)) * 3
749 + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
751 // Analyse safe queen contact checks
752 b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them);
755 Bitboard attackedByOthers =
756 ei.attacked_by(them, PAWN) | ei.attacked_by(them, KNIGHT)
757 | ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK);
759 b &= attackedByOthers;
762 // The bitboard b now contains the squares available for safe queen
764 int count = count_1s_max_15<false>(b);
765 attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
767 // Is there a mate threat?
768 if (QueenContactMates && !p.is_check())
770 Bitboard escapeSquares =
771 p.piece_attacks<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
775 Square from, to = pop_1st_bit(&b);
776 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
778 // We have a mate, unless the queen is pinned or there
779 // is an X-ray attack through the queen.
780 for (int i = 0; i < p.piece_count(them, QUEEN); i++)
782 from = p.piece_list(them, QUEEN, i);
783 if ( bit_is_set(p.piece_attacks<QUEEN>(from), to)
784 && !bit_is_set(p.pinned_pieces(them), from)
785 && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
786 && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.bishops_and_queens(us)))
788 ei.mateThreat[them] = make_move(from, to);
796 // Analyse safe distance checks
797 if (QueenCheckBonus > 0 || RookCheckBonus > 0)
799 b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
802 b2 = b & ei.attacked_by(them, QUEEN);
804 attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
807 b2 = b & ei.attacked_by(them, ROOK);
809 attackUnits += RookCheckBonus * count_1s_max_15<false>(b2);
811 if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
813 b = p.piece_attacks<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
816 b2 = b & ei.attacked_by(them, QUEEN);
818 attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
821 b2 = b & ei.attacked_by(them, BISHOP);
823 attackUnits += BishopCheckBonus * count_1s_max_15<false>(b2);
825 if (KnightCheckBonus > 0)
827 b = p.piece_attacks<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
830 b2 = b & ei.attacked_by(them, KNIGHT);
832 attackUnits += KnightCheckBonus * count_1s_max_15<false>(b2);
835 // Analyse discovered checks (only for non-pawns right now, consider
836 // adding pawns later).
837 if (DiscoveredCheckBonus)
839 b = p.discovered_check_candidates(them) & ~p.pawns();
841 attackUnits += DiscoveredCheckBonus * count_1s_max_15<false>(b) * (sente? 2 : 1);
844 // Has a mate threat been found? We don't do anything here if the
845 // side with the mating move is the side to move, because in that
846 // case the mating side will get a huge bonus at the end of the main
847 // evaluation function instead.
848 if (ei.mateThreat[them] != MOVE_NONE)
849 attackUnits += MateThreatBonus;
851 // Ensure that attackUnits is between 0 and 99, in order to avoid array
852 // out of bounds errors:
856 if (attackUnits >= 100)
859 // Finally, extract the king safety score from the SafetyTable[] array.
860 // Add the score to the evaluation, and also to ei.futilityMargin. The
861 // reason for adding the king safety score to the futility margin is
862 // that the king safety scores can sometimes be very big, and that
863 // capturing a single attacking piece can therefore result in a score
864 // change far bigger than the value of the captured piece.
865 Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]);
867 ei.mgValue -= sign * v;
869 if (us == p.side_to_move())
870 ei.futilityMargin += v;
875 // evaluate_passed_pawns() evaluates the passed pawns for both sides.
877 void evaluate_passed_pawns(const Position &pos, EvalInfo &ei) {
879 bool hasUnstoppable[2] = {false, false};
880 int movesToGo[2] = {100, 100};
882 for (Color us = WHITE; us <= BLACK; us++)
884 Color them = opposite_color(us);
885 Square ourKingSq = pos.king_square(us);
886 Square theirKingSq = pos.king_square(them);
887 Bitboard b = ei.pi->passed_pawns() & pos.pawns(us), b2, b3, b4;
891 Square s = pop_1st_bit(&b);
893 assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
894 assert(pos.pawn_is_passed(us, s));
896 int r = int(relative_rank(us, s) - RANK_2);
897 int tr = Max(0, r * (r - 1));
898 Square blockSq = s + pawn_push(us);
900 // Base bonus based on rank
901 Value mbonus = Value(20 * tr);
902 Value ebonus = Value(10 + r * r * 10);
904 // Adjust bonus based on king proximity
907 ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
908 ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
909 ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
911 // If the pawn is free to advance, increase bonus
912 if (pos.square_is_empty(blockSq))
914 b2 = squares_in_front_of(us, s);
915 b3 = b2 & ei.attacked_by(them);
916 b4 = b2 & ei.attacked_by(us);
918 // If there is an enemy rook or queen attacking the pawn from behind,
919 // add all X-ray attacks by the rook or queen.
920 if ( bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
921 && (squares_behind(us, s) & pos.rooks_and_queens(them)))
924 if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
926 // There are no enemy pieces in the pawn's path! Are any of the
927 // squares in the pawn's path attacked by the enemy?
928 if (b3 == EmptyBoardBB)
929 // No enemy attacks, huge bonus!
930 ebonus += Value(tr * (b2 == b4 ? 17 : 15));
932 // OK, there are enemy attacks. Are those squares which are
933 // attacked by the enemy also attacked by us? If yes, big bonus
934 // (but smaller than when there are no enemy attacks), if no,
935 // somewhat smaller bonus.
936 ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
940 // There are some enemy pieces in the pawn's path. While this is
941 // sad, we still assign a moderate bonus if all squares in the path
942 // which are either occupied by or attacked by enemy pieces are
943 // also attacked by us.
944 if (((b3 | (b2 & pos.pieces_of_color(them))) & ~b4) == EmptyBoardBB)
945 ebonus += Value(tr * 6);
947 // At last, add a small bonus when there are no *friendly* pieces
948 // in the pawn's path.
949 if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
954 // If the pawn is supported by a friendly pawn, increase bonus
955 b2 = pos.pawns(us) & neighboring_files_bb(s);
957 ebonus += Value(r * 20);
958 else if (pos.pawn_attacks(them, s) & b2)
959 ebonus += Value(r * 12);
961 // If the other side has only a king, check whether the pawn is
963 if (pos.non_pawn_material(them) == Value(0))
968 qsq = relative_square(us, make_square(square_file(s), RANK_8));
969 d = square_distance(s, qsq)
970 - square_distance(theirKingSq, qsq)
971 + (us != pos.side_to_move());
975 int mtg = RANK_8 - relative_rank(us, s);
976 int blockerCount = count_1s_max_15<false>(squares_in_front_of(us,s) & pos.occupied_squares());
981 hasUnstoppable[us] = true;
982 movesToGo[us] = Min(movesToGo[us], mtg);
986 // Rook pawns are a special case: They are sometimes worse, and
987 // sometimes better than other passed pawns. It is difficult to find
988 // good rules for determining whether they are good or bad. For now,
989 // we try the following: Increase the value for rook pawns if the
990 // other side has no pieces apart from a knight, and decrease the
991 // value if the other side has a rook or queen.
992 if (square_file(s) == FILE_A || square_file(s) == FILE_H)
994 if( pos.non_pawn_material(them) <= KnightValueMidgame
995 && pos.piece_count(them, KNIGHT) <= 1)
996 ebonus += ebonus / 4;
997 else if(pos.rooks_and_queens(them))
998 ebonus -= ebonus / 4;
1001 // Add the scores for this pawn to the middle game and endgame eval.
1002 ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
1003 ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
1007 // Does either side have an unstoppable passed pawn?
1008 if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
1009 ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
1010 else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
1011 ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
1012 else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
1014 // Both sides have unstoppable pawns! Try to find out who queens
1015 // first. We begin by transforming 'movesToGo' to the number of
1016 // plies until the pawn queens for both sides.
1017 movesToGo[WHITE] *= 2;
1018 movesToGo[BLACK] *= 2;
1019 movesToGo[pos.side_to_move()]--;
1021 // If one side queens at least three plies before the other, that
1023 if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
1024 ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
1025 else if(movesToGo[BLACK] <= movesToGo[WHITE] - 3)
1026 ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));
1028 // We could also add some rules about the situation when one side
1029 // queens exactly one ply before the other: Does the first queen
1030 // check the opponent's king, or attack the opponent's queening square?
1031 // This is slightly tricky to get right, because it is possible that
1032 // the opponent's king has moved somewhere before the first pawn queens.
1037 // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1038 // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1041 void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
1043 assert(square_is_ok(s));
1044 assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1046 Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1047 Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1049 if ( pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1050 && pos.see(s, b6) < 0
1051 && pos.see(s, b8) < 0)
1053 ei.mgValue -= Sign[us] * TrappedBishopA7H7Penalty;
1054 ei.egValue -= Sign[us] * TrappedBishopA7H7Penalty;
1059 // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1060 // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1061 // black), and assigns a penalty if it is. This pattern can obviously
1062 // only occur in Chess960 games.
1064 void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
1066 Piece pawn = piece_of_color_and_type(us, PAWN);
1070 assert(square_is_ok(s));
1071 assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1073 if (square_file(s) == FILE_A)
1075 b2 = relative_square(us, SQ_B2);
1076 b3 = relative_square(us, SQ_B3);
1077 c3 = relative_square(us, SQ_C3);
1081 b2 = relative_square(us, SQ_G2);
1082 b3 = relative_square(us, SQ_G3);
1083 c3 = relative_square(us, SQ_F3);
1086 if (pos.piece_on(b2) == pawn)
1090 if (!pos.square_is_empty(b3))
1091 penalty = 2*TrappedBishopA1H1Penalty;
1092 else if (pos.piece_on(c3) == pawn)
1093 penalty = TrappedBishopA1H1Penalty;
1095 penalty = TrappedBishopA1H1Penalty / 2;
1097 ei.mgValue -= Sign[us] * penalty;
1098 ei.egValue -= Sign[us] * penalty;
1103 // evaluate_space() computes the space evaluation for a given side. The
1104 // space evaluation is a simple bonus based on the number of safe squares
1105 // available for minor pieces on the central four files on ranks 2--4. Safe
1106 // squares one, two or three squares behind a friendly pawn are counted
1107 // twice. Finally, the space bonus is scaled by a weight taken from the
1108 // material hash table.
1110 void evaluate_space(const Position &pos, Color us, EvalInfo &ei) {
1112 Color them = opposite_color(us);
1114 // Find the safe squares for our pieces inside the area defined by
1115 // SpaceMask[us]. A square is unsafe it is attacked by an enemy
1116 // pawn, or if it is undefended and attacked by an enemy piece.
1118 Bitboard safeSquares = SpaceMask[us]
1120 & ~ei.attacked_by(them, PAWN)
1121 & ~(~ei.attacked_by(us) & ei.attacked_by(them));
1123 // Find all squares which are at most three squares behind some friendly
1125 Bitboard behindFriendlyPawns = pos.pawns(us);
1128 behindFriendlyPawns |= (behindFriendlyPawns >> 8);
1129 behindFriendlyPawns |= (behindFriendlyPawns >> 16);
1133 behindFriendlyPawns |= (behindFriendlyPawns << 8);
1134 behindFriendlyPawns |= (behindFriendlyPawns << 16);
1137 int space = count_1s_max_15<false>(safeSquares)
1138 + count_1s_max_15<false>(behindFriendlyPawns & safeSquares);
1140 ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
1144 // apply_weight() applies an evaluation weight to a value
1146 inline Value apply_weight(Value v, int w) {
1147 return (v*w) / 0x100;
1151 // scale_by_game_phase() interpolates between a middle game and an endgame
1152 // score, based on game phase. It also scales the return value by a
1153 // ScaleFactor array.
1155 Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
1157 assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
1158 assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);
1159 assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1161 ev = apply_scale_factor(ev, sf[(ev > Value(0) ? WHITE : BLACK)]);
1163 Value result = Value(int((mv * ph + ev * (128 - ph)) / 128));
1164 return Value(int(result) & ~(GrainSize - 1));
1168 // compute_weight() computes the value of an evaluation weight, by combining
1169 // an UCI-configurable weight with an internal weight.
1171 int compute_weight(int uciWeight, int internalWeight) {
1173 uciWeight = (uciWeight * 0x100) / 100;
1174 return (uciWeight * internalWeight) / 0x100;
1178 // helper used in read_weights()
1179 int weight_option(const std::string& opt, int weight) {
1181 return compute_weight(get_option_value_int(opt), weight);
1185 // init_safety() initizes the king safety evaluation, based on UCI
1186 // parameters. It is called from read_weights().
1188 void init_safety() {
1190 QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1191 QueenCheckBonus = get_option_value_int("Queen Check Bonus");
1192 RookCheckBonus = get_option_value_int("Rook Check Bonus");
1193 BishopCheckBonus = get_option_value_int("Bishop Check Bonus");
1194 KnightCheckBonus = get_option_value_int("Knight Check Bonus");
1195 DiscoveredCheckBonus = get_option_value_int("Discovered Check Bonus");
1196 MateThreatBonus = get_option_value_int("Mate Threat Bonus");
1198 int maxSlope = get_option_value_int("King Safety Max Slope");
1199 int peak = get_option_value_int("King Safety Max Value") * 256 / 100;
1200 double a = get_option_value_int("King Safety Coefficient") / 100.0;
1201 double b = get_option_value_int("King Safety X Intercept");
1202 bool quad = (get_option_value_string("King Safety Curve") == "Quadratic");
1203 bool linear = (get_option_value_string("King Safety Curve") == "Linear");
1205 for (int i = 0; i < 100; i++)
1208 SafetyTable[i] = Value(0);
1210 SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1212 SafetyTable[i] = Value((int)(100 * a * (i - b)));
1215 for (int i = 0; i < 100; i++)
1217 if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1218 for (int j = i + 1; j < 100; j++)
1219 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1221 if (SafetyTable[i] > Value(peak))
1222 SafetyTable[i] = Value(peak);