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-2012 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/>.
30 #include "ucioption.h"
36 // Struct EvalInfo contains various information computed and collected
37 // by the evaluation functions.
40 // Pointers to material and pawn hash table entries
44 // attackedBy[color][piece type] is a bitboard representing all squares
45 // attacked by a given color and piece type, attackedBy[color][0] contains
46 // all squares attacked by the given color.
47 Bitboard attackedBy[2][8];
49 // kingRing[color] is the zone around the king which is considered
50 // by the king safety evaluation. This consists of the squares directly
51 // adjacent to the king, and the three (or two, for a king on an edge file)
52 // squares two ranks in front of the king. For instance, if black's king
53 // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
54 // f7, g7, h7, f6, g6 and h6.
57 // kingAttackersCount[color] is the number of pieces of the given color
58 // which attack a square in the kingRing of the enemy king.
59 int kingAttackersCount[2];
61 // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
62 // given color which attack a square in the kingRing of the enemy king. The
63 // weights of the individual piece types are given by the variables
64 // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
65 // KnightAttackWeight in evaluate.cpp
66 int kingAttackersWeight[2];
68 // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
69 // directly adjacent to the king of the given color. Pieces which attack
70 // more than one square are counted multiple times. For instance, if black's
71 // king is on g8 and there's a white knight on g5, this knight adds
72 // 2 to kingAdjacentZoneAttacksCount[BLACK].
73 int kingAdjacentZoneAttacksCount[2];
76 // Evaluation grain size, must be a power of 2
77 const int GrainSize = 8;
79 // Evaluation weights, initialized from UCI options
80 enum { Mobility, PassedPawns, Space, KingDangerUs, KingDangerThem };
84 #define S(mg, eg) make_score(mg, eg)
86 // Internal evaluation weights. These are applied on top of the evaluation
87 // weights read from UCI parameters. The purpose is to be able to change
88 // the evaluation weights while keeping the default values of the UCI
89 // parameters at 100, which looks prettier.
91 // Values modified by Joona Kiiski
92 const Score WeightsInternal[] = {
93 S(252, 344), S(216, 266), S(46, 0), S(247, 0), S(259, 0)
96 // MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
97 // end game, indexed by piece type and number of attacked squares not occupied
98 // by friendly pieces.
99 const Score MobilityBonus[][32] = {
101 { S(-38,-33), S(-25,-23), S(-12,-13), S( 0, -3), S(12, 7), S(25, 17), // Knights
102 S( 31, 22), S( 38, 27), S( 38, 27) },
103 { S(-25,-30), S(-11,-16), S( 3, -2), S(17, 12), S(31, 26), S(45, 40), // Bishops
104 S( 57, 52), S( 65, 60), S( 71, 65), S(74, 69), S(76, 71), S(78, 73),
105 S( 79, 74), S( 80, 75), S( 81, 76), S(81, 76) },
106 { S(-20,-36), S(-14,-19), S( -8, -3), S(-2, 13), S( 4, 29), S(10, 46), // Rooks
107 S( 14, 62), S( 19, 79), S( 23, 95), S(26,106), S(27,111), S(28,114),
108 S( 29,116), S( 30,117), S( 31,118), S(32,118) },
109 { S(-10,-18), S( -8,-13), S( -6, -7), S(-3, -2), S(-1, 3), S( 1, 8), // Queens
110 S( 3, 13), S( 5, 19), S( 8, 23), S(10, 27), S(12, 32), S(15, 34),
111 S( 16, 35), S( 17, 35), S( 18, 35), S(20, 35), S(20, 35), S(20, 35),
112 S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
113 S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
114 S( 20, 35), S( 20, 35) }
117 // OutpostBonus[PieceType][Square] contains outpost bonuses of knights and
118 // bishops, indexed by piece type and square (from white's point of view).
119 const Value OutpostBonus[][64] = {
122 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
123 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
124 V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
125 V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
126 V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
127 V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) },
129 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
130 V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
131 V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
132 V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
133 V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
134 V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
137 // ThreatBonus[attacking][attacked] contains threat bonuses according to
138 // which piece type attacks which one.
139 const Score ThreatBonus[][8] = {
141 { S(0, 0), S( 7, 39), S( 0, 0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
142 { S(0, 0), S( 7, 39), S(24, 49), S( 0, 0), S(41,100), S(41,100) }, // BISHOP
143 { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0, 0), S(24, 49) }, // ROOK
144 { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0, 0) } // QUEEN
147 // ThreatenedByPawnPenalty[PieceType] contains a penalty according to which
148 // piece type is attacked by an enemy pawn.
149 const Score ThreatenedByPawnPenalty[] = {
150 S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
155 // Rooks and queens on the 7th rank (modified by Joona Kiiski)
156 const Score RookOn7thBonus = make_score(47, 98);
157 const Score QueenOn7thBonus = make_score(27, 54);
159 // Rooks on open files (modified by Joona Kiiski)
160 const Score RookOpenFileBonus = make_score(43, 21);
161 const Score RookHalfOpenFileBonus = make_score(19, 10);
163 // Penalty for rooks trapped inside a friendly king which has lost the
165 const Value TrappedRookPenalty = Value(180);
167 // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
168 // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
169 // happen in Chess960 games.
170 const Score TrappedBishopA1H1Penalty = make_score(100, 100);
172 // The SpaceMask[Color] contains the area of the board which is considered
173 // by the space evaluation. In the middle game, each side is given a bonus
174 // based on how many squares inside this area are safe and available for
175 // friendly minor pieces.
176 const Bitboard SpaceMask[] = {
177 (1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
178 (1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
179 (1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
180 (1ULL << SQ_C7) | (1ULL << SQ_D7) | (1ULL << SQ_E7) | (1ULL << SQ_F7) |
181 (1ULL << SQ_C6) | (1ULL << SQ_D6) | (1ULL << SQ_E6) | (1ULL << SQ_F6) |
182 (1ULL << SQ_C5) | (1ULL << SQ_D5) | (1ULL << SQ_E5) | (1ULL << SQ_F5)
185 // King danger constants and variables. The king danger scores are taken
186 // from the KingDangerTable[]. Various little "meta-bonuses" measuring
187 // the strength of the enemy attack are added up into an integer, which
188 // is used as an index to KingDangerTable[].
190 // KingAttackWeights[PieceType] contains king attack weights by piece type
191 const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
193 // Bonuses for enemy's safe checks
194 const int QueenContactCheckBonus = 6;
195 const int RookContactCheckBonus = 4;
196 const int QueenCheckBonus = 3;
197 const int RookCheckBonus = 2;
198 const int BishopCheckBonus = 1;
199 const int KnightCheckBonus = 1;
201 // InitKingDanger[Square] contains penalties based on the position of the
202 // defending king, indexed by king's square (from white's point of view).
203 const int InitKingDanger[] = {
204 2, 0, 2, 5, 5, 2, 0, 2,
205 2, 2, 4, 8, 8, 4, 2, 2,
206 7, 10, 12, 12, 12, 12, 10, 7,
207 15, 15, 15, 15, 15, 15, 15, 15,
208 15, 15, 15, 15, 15, 15, 15, 15,
209 15, 15, 15, 15, 15, 15, 15, 15,
210 15, 15, 15, 15, 15, 15, 15, 15,
211 15, 15, 15, 15, 15, 15, 15, 15
214 // KingDangerTable[Color][attackUnits] contains the actual king danger
215 // weighted scores, indexed by color and by a calculated integer number.
216 Score KingDangerTable[2][128];
218 // TracedTerms[Color][PieceType || TracedType] contains a breakdown of the
219 // evaluation terms, used when tracing.
220 Score TracedScores[2][16];
221 std::stringstream TraceStream;
224 PST = 8, IMBALANCE = 9, MOBILITY = 10, THREAT = 11,
225 PASSED = 12, UNSTOPPABLE = 13, SPACE = 14, TOTAL = 15
228 // Function prototypes
230 Value do_evaluate(const Position& pos, Value& margin);
233 void init_eval_info(const Position& pos, EvalInfo& ei);
235 template<Color Us, bool Trace>
236 Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
238 template<Color Us, bool Trace>
239 Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
242 Score evaluate_threats(const Position& pos, EvalInfo& ei);
245 int evaluate_space(const Position& pos, EvalInfo& ei);
248 Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
250 Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
252 inline Score apply_weight(Score v, Score weight);
253 Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf);
254 Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
255 double to_cp(Value v);
256 void trace_add(int idx, Score term_w, Score term_b = SCORE_ZERO);
260 /// evaluate() is the main evaluation function. It always computes two
261 /// values, an endgame score and a middle game score, and interpolates
262 /// between them based on the remaining material.
263 Value evaluate(const Position& pos, Value& margin) { return do_evaluate<false>(pos, margin); }
268 Value do_evaluate(const Position& pos, Value& margin) {
272 Score score, mobilityWhite, mobilityBlack;
274 assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
275 assert(!pos.in_check());
277 // Initialize score by reading the incrementally updated scores included
278 // in the position object (material + piece square tables).
281 // margins[] store the uncertainty estimation of position's evaluation
282 // that typically is used by the search for pruning decisions.
283 margins[WHITE] = margins[BLACK] = VALUE_ZERO;
285 // Probe the material hash table
286 ei.mi = Threads[pos.thread()].materialTable.material_info(pos);
287 score += ei.mi->material_value();
289 // If we have a specialized evaluation function for the current material
290 // configuration, call it and return.
291 if (ei.mi->specialized_eval_exists())
294 return ei.mi->evaluate(pos);
297 // Probe the pawn hash table
298 ei.pi = Threads[pos.thread()].pawnTable.pawn_info(pos);
299 score += ei.pi->pawns_value();
301 // Initialize attack and king safety bitboards
302 init_eval_info<WHITE>(pos, ei);
303 init_eval_info<BLACK>(pos, ei);
305 // Evaluate pieces and mobility
306 score += evaluate_pieces_of_color<WHITE, Trace>(pos, ei, mobilityWhite)
307 - evaluate_pieces_of_color<BLACK, Trace>(pos, ei, mobilityBlack);
309 score += apply_weight(mobilityWhite - mobilityBlack, Weights[Mobility]);
311 // Evaluate kings after all other pieces because we need complete attack
312 // information when computing the king safety evaluation.
313 score += evaluate_king<WHITE, Trace>(pos, ei, margins)
314 - evaluate_king<BLACK, Trace>(pos, ei, margins);
316 // Evaluate tactical threats, we need full attack information including king
317 score += evaluate_threats<WHITE>(pos, ei)
318 - evaluate_threats<BLACK>(pos, ei);
320 // Evaluate passed pawns, we need full attack information including king
321 score += evaluate_passed_pawns<WHITE>(pos, ei)
322 - evaluate_passed_pawns<BLACK>(pos, ei);
324 // If one side has only a king, check whether exists any unstoppable passed pawn
325 if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
326 score += evaluate_unstoppable_pawns(pos, ei);
328 // Evaluate space for both sides, only in middle-game.
329 if (ei.mi->space_weight())
331 int s = evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei);
332 score += apply_weight(make_score(s * ei.mi->space_weight(), 0), Weights[Space]);
335 // Scale winning side if position is more drawish that what it appears
336 ScaleFactor sf = eg_value(score) > VALUE_DRAW ? ei.mi->scale_factor(pos, WHITE)
337 : ei.mi->scale_factor(pos, BLACK);
339 // If we don't already have an unusual scale factor, check for opposite
340 // colored bishop endgames, and use a lower scale for those.
341 if ( ei.mi->game_phase() < PHASE_MIDGAME
342 && pos.opposite_colored_bishops()
343 && sf == SCALE_FACTOR_NORMAL)
345 // Only the two bishops ?
346 if ( pos.non_pawn_material(WHITE) == BishopValueMidgame
347 && pos.non_pawn_material(BLACK) == BishopValueMidgame)
349 // Check for KBP vs KB with only a single pawn that is almost
350 // certainly a draw or at least two pawns.
351 bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
352 sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
355 // Endgame with opposite-colored bishops, but also other pieces. Still
356 // a bit drawish, but not as drawish as with only the two bishops.
357 sf = ScaleFactor(50);
360 // Interpolate between the middle game and the endgame score
361 margin = margins[pos.side_to_move()];
362 Value v = scale_by_game_phase(score, ei.mi->game_phase(), sf);
364 // In case of tracing add all single evaluation contributions for both white and black
367 trace_add(PST, pos.value());
368 trace_add(IMBALANCE, ei.mi->material_value());
369 trace_add(PAWN, ei.pi->pawns_value());
370 trace_add(MOBILITY, apply_weight(mobilityWhite, Weights[Mobility]), apply_weight(mobilityBlack, Weights[Mobility]));
371 trace_add(THREAT, evaluate_threats<WHITE>(pos, ei), evaluate_threats<BLACK>(pos, ei));
372 trace_add(PASSED, evaluate_passed_pawns<WHITE>(pos, ei), evaluate_passed_pawns<BLACK>(pos, ei));
373 trace_add(UNSTOPPABLE, evaluate_unstoppable_pawns(pos, ei));
374 Score w = make_score(ei.mi->space_weight() * evaluate_space<WHITE>(pos, ei), 0);
375 Score b = make_score(ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei), 0);
376 trace_add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
377 trace_add(TOTAL, score);
378 TraceStream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
379 << ", Black: " << to_cp(margins[BLACK])
380 << "\nScaling: " << std::noshowpos
381 << std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
382 << std::setw(6) << 100.0 * (1.0 - ei.mi->game_phase() / 128.0) << "% * "
383 << std::setw(6) << (100.0 * sf) / SCALE_FACTOR_NORMAL << "% EG.\n"
384 << "Total evaluation: " << to_cp(v);
387 return pos.side_to_move() == WHITE ? v : -v;
393 /// eval_init() reads evaluation weights from the corresponding UCI parameters
394 /// and setup weights and tables.
397 const Value MaxSlope = Value(30);
398 const Value Peak = Value(1280);
401 // King safety is asymmetrical. Our king danger level is weighted by
402 // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
403 Weights[Mobility] = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
404 Weights[PassedPawns] = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
405 Weights[Space] = weight_option("Space", "Space", WeightsInternal[Space]);
406 Weights[KingDangerUs] = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
407 Weights[KingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
409 // If running in analysis mode, make sure we use symmetrical king safety. We do this
410 // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
411 if (Options["UCI_AnalyseMode"])
412 Weights[KingDangerUs] = Weights[KingDangerThem] = (Weights[KingDangerUs] + Weights[KingDangerThem]) / 2;
414 // First setup the base table
415 for (int i = 0; i < 100; i++)
417 t[i] = Value(int(0.4 * i * i));
420 t[i] = std::min(t[i], t[i - 1] + MaxSlope);
422 t[i] = std::min(t[i], Peak);
425 // Then apply the weights and get the final KingDangerTable[] array
426 for (Color c = WHITE; c <= BLACK; c++)
427 for (int i = 0; i < 100; i++)
428 KingDangerTable[c == WHITE][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);
434 // init_eval_info() initializes king bitboards for given color adding
435 // pawn attacks. To be done at the beginning of the evaluation.
438 void init_eval_info(const Position& pos, EvalInfo& ei) {
440 const Color Them = (Us == WHITE ? BLACK : WHITE);
442 Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
443 ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
445 // Init king safety tables only if we are going to use them
446 if ( pos.piece_count(Us, QUEEN)
447 && pos.non_pawn_material(Us) >= QueenValueMidgame + RookValueMidgame)
449 ei.kingRing[Them] = (b | (Us == WHITE ? b >> 8 : b << 8));
450 b &= ei.attackedBy[Us][PAWN];
451 ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) / 2 : 0;
452 ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
454 ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
458 // evaluate_outposts() evaluates bishop and knight outposts squares
460 template<PieceType Piece, Color Us>
461 Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
463 const Color Them = (Us == WHITE ? BLACK : WHITE);
465 assert (Piece == BISHOP || Piece == KNIGHT);
467 // Initial bonus based on square
468 Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
470 // Increase bonus if supported by pawn, especially if the opponent has
471 // no minor piece which can exchange the outpost piece.
472 if (bonus && (ei.attackedBy[Us][PAWN] & s))
474 if ( !pos.pieces(KNIGHT, Them)
475 && !(same_color_squares(s) & pos.pieces(BISHOP, Them)))
476 bonus += bonus + bonus / 2;
480 return make_score(bonus, bonus);
484 // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
486 template<PieceType Piece, Color Us, bool Trace>
487 Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
493 Score score = SCORE_ZERO;
495 const Color Them = (Us == WHITE ? BLACK : WHITE);
496 const Square* pl = pos.piece_list(Us, Piece);
498 ei.attackedBy[Us][Piece] = 0;
500 while ((s = *pl++) != SQ_NONE)
502 // Find attacked squares, including x-ray attacks for bishops and rooks
503 if (Piece == KNIGHT || Piece == QUEEN)
504 b = pos.attacks_from<Piece>(s);
505 else if (Piece == BISHOP)
506 b = attacks_bb<BISHOP>(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
507 else if (Piece == ROOK)
508 b = attacks_bb<ROOK>(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
512 ei.attackedBy[Us][Piece] |= b;
514 if (b & ei.kingRing[Them])
516 ei.kingAttackersCount[Us]++;
517 ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
518 Bitboard bb = (b & ei.attackedBy[Them][KING]);
520 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
523 mob = (Piece != QUEEN ? popcount<Max15>(b & mobilityArea)
524 : popcount<Full >(b & mobilityArea));
526 mobility += MobilityBonus[Piece][mob];
528 // Add a bonus if a slider is pinning an enemy piece
529 if ( (Piece == BISHOP || Piece == ROOK || Piece == QUEEN)
530 && (PseudoAttacks[Piece][pos.king_square(Them)] & s))
532 b = BetweenBB[s][pos.king_square(Them)] & pos.occupied_squares();
536 if (single_bit(b) && (b & pos.pieces(Them)))
537 score += ThreatBonus[Piece][type_of(pos.piece_on(first_1(b)))];
540 // Decrease score if we are attacked by an enemy pawn. Remaining part
541 // of threat evaluation must be done later when we have full attack info.
542 if (ei.attackedBy[Them][PAWN] & s)
543 score -= ThreatenedByPawnPenalty[Piece];
545 // Bishop and knight outposts squares
546 if ( (Piece == BISHOP || Piece == KNIGHT)
547 && !(pos.pieces(PAWN, Them) & attack_span_mask(Us, s)))
548 score += evaluate_outposts<Piece, Us>(pos, ei, s);
550 // Queen or rook on 7th rank
551 if ( (Piece == ROOK || Piece == QUEEN)
552 && relative_rank(Us, s) == RANK_7
553 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
555 score += (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
558 // Special extra evaluation for bishops
559 if (Piece == BISHOP && pos.is_chess960())
561 // An important Chess960 pattern: A cornered bishop blocked by
562 // a friendly pawn diagonally in front of it is a very serious
563 // problem, especially when that pawn is also blocked.
564 if (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1))
566 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
567 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
569 if (!pos.square_is_empty(s + d + pawn_push(Us)))
570 score -= 2*TrappedBishopA1H1Penalty;
571 else if (pos.piece_on(s + 2*d) == make_piece(Us, PAWN))
572 score -= TrappedBishopA1H1Penalty;
574 score -= TrappedBishopA1H1Penalty / 2;
579 // Special extra evaluation for rooks
582 // Open and half-open files
584 if (ei.pi->file_is_half_open(Us, f))
586 if (ei.pi->file_is_half_open(Them, f))
587 score += RookOpenFileBonus;
589 score += RookHalfOpenFileBonus;
592 // Penalize rooks which are trapped inside a king. Penalize more if
593 // king has lost right to castle.
594 if (mob > 6 || ei.pi->file_is_half_open(Us, f))
597 ksq = pos.king_square(Us);
599 if ( file_of(ksq) >= FILE_E
600 && file_of(s) > file_of(ksq)
601 && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
603 // Is there a half-open file between the king and the edge of the board?
604 if (!ei.pi->has_open_file_to_right(Us, file_of(ksq)))
605 score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
606 : (TrappedRookPenalty - mob * 16), 0);
608 else if ( file_of(ksq) <= FILE_D
609 && file_of(s) < file_of(ksq)
610 && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
612 // Is there a half-open file between the king and the edge of the board?
613 if (!ei.pi->has_open_file_to_left(Us, file_of(ksq)))
614 score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
615 : (TrappedRookPenalty - mob * 16), 0);
621 TracedScores[Us][Piece] = score;
627 // evaluate_threats<>() assigns bonuses according to the type of attacking piece
628 // and the type of attacked one.
631 Score evaluate_threats(const Position& pos, EvalInfo& ei) {
633 const Color Them = (Us == WHITE ? BLACK : WHITE);
636 Score score = SCORE_ZERO;
638 // Enemy pieces not defended by a pawn and under our attack
639 Bitboard weakEnemies = pos.pieces(Them)
640 & ~ei.attackedBy[Them][PAWN]
641 & ei.attackedBy[Us][0];
645 // Add bonus according to type of attacked enemy piece and to the
646 // type of attacking piece, from knights to queens. Kings are not
647 // considered because are already handled in king evaluation.
648 for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
650 b = ei.attackedBy[Us][pt1] & weakEnemies;
652 for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
653 if (b & pos.pieces(pt2))
654 score += ThreatBonus[pt1][pt2];
660 // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
661 // pieces of a given color.
663 template<Color Us, bool Trace>
664 Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {
666 const Color Them = (Us == WHITE ? BLACK : WHITE);
668 Score score = mobility = SCORE_ZERO;
670 // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
671 const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us));
673 score += evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea);
674 score += evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea);
675 score += evaluate_pieces<ROOK, Us, Trace>(pos, ei, mobility, mobilityArea);
676 score += evaluate_pieces<QUEEN, Us, Trace>(pos, ei, mobility, mobilityArea);
678 // Sum up all attacked squares
679 ei.attackedBy[Us][0] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
680 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
681 | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
686 // evaluate_king<>() assigns bonuses and penalties to a king of a given color
688 template<Color Us, bool Trace>
689 Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
691 const Color Them = (Us == WHITE ? BLACK : WHITE);
693 Bitboard undefended, b, b1, b2, safe;
695 const Square ksq = pos.king_square(Us);
698 Score score = ei.pi->king_shelter<Us>(pos, ksq);
700 // King safety. This is quite complicated, and is almost certainly far
701 // from optimally tuned.
702 if ( ei.kingAttackersCount[Them] >= 2
703 && ei.kingAdjacentZoneAttacksCount[Them])
705 // Find the attacked squares around the king which has no defenders
706 // apart from the king itself
707 undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
708 undefended &= ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
709 | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
710 | ei.attackedBy[Us][QUEEN]);
712 // Initialize the 'attackUnits' variable, which is used later on as an
713 // index to the KingDangerTable[] array. The initial value is based on
714 // the number and types of the enemy's attacking pieces, the number of
715 // attacked and undefended squares around our king, the square of the
716 // king, and the quality of the pawn shelter.
717 attackUnits = std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
718 + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
719 + InitKingDanger[relative_square(Us, ksq)]
720 - mg_value(ei.pi->king_shelter<Us>(pos, ksq)) / 32;
722 // Analyse enemy's safe queen contact checks. First find undefended
723 // squares around the king attacked by enemy queen...
724 b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
727 // ...then remove squares not supported by another enemy piece
728 b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
729 | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
731 attackUnits += QueenContactCheckBonus
733 * (Them == pos.side_to_move() ? 2 : 1);
736 // Analyse enemy's safe rook contact checks. First find undefended
737 // squares around the king attacked by enemy rooks...
738 b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
740 // Consider only squares where the enemy rook gives check
741 b &= PseudoAttacks[ROOK][ksq];
745 // ...then remove squares not supported by another enemy piece
746 b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
747 | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
749 attackUnits += RookContactCheckBonus
751 * (Them == pos.side_to_move() ? 2 : 1);
754 // Analyse enemy's safe distance checks for sliders and knights
755 safe = ~(pos.pieces(Them) | ei.attackedBy[Us][0]);
757 b1 = pos.attacks_from<ROOK>(ksq) & safe;
758 b2 = pos.attacks_from<BISHOP>(ksq) & safe;
760 // Enemy queen safe checks
761 b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
763 attackUnits += QueenCheckBonus * popcount<Max15>(b);
765 // Enemy rooks safe checks
766 b = b1 & ei.attackedBy[Them][ROOK];
768 attackUnits += RookCheckBonus * popcount<Max15>(b);
770 // Enemy bishops safe checks
771 b = b2 & ei.attackedBy[Them][BISHOP];
773 attackUnits += BishopCheckBonus * popcount<Max15>(b);
775 // Enemy knights safe checks
776 b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
778 attackUnits += KnightCheckBonus * popcount<Max15>(b);
780 // To index KingDangerTable[] attackUnits must be in [0, 99] range
781 attackUnits = std::min(99, std::max(0, attackUnits));
783 // Finally, extract the king danger score from the KingDangerTable[]
784 // array and subtract the score from evaluation. Set also margins[]
785 // value that will be used for pruning because this value can sometimes
786 // be very big, and so capturing a single attacking piece can therefore
787 // result in a score change far bigger than the value of the captured piece.
788 score -= KingDangerTable[Us == EvalRootColor][attackUnits];
789 margins[Us] += mg_value(KingDangerTable[Us == EvalRootColor][attackUnits]);
793 TracedScores[Us][KING] = score;
799 // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
802 Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
804 const Color Them = (Us == WHITE ? BLACK : WHITE);
806 Bitboard b, squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
807 Score score = SCORE_ZERO;
809 b = ei.pi->passed_pawns(Us);
815 Square s = pop_1st_bit(&b);
817 assert(pos.pawn_is_passed(Us, s));
819 int r = int(relative_rank(Us, s) - RANK_2);
820 int rr = r * (r - 1);
822 // Base bonus based on rank
823 Value mbonus = Value(20 * rr);
824 Value ebonus = Value(10 * (rr + r + 1));
828 Square blockSq = s + pawn_push(Us);
830 // Adjust bonus based on kings proximity
831 ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr);
832 ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 2 * rr);
834 // If blockSq is not the queening square then consider also a second push
835 if (rank_of(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
836 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
838 // If the pawn is free to advance, increase bonus
839 if (pos.square_is_empty(blockSq))
841 squaresToQueen = squares_in_front_of(Us, s);
842 defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
844 // If there is an enemy rook or queen attacking the pawn from behind,
845 // add all X-ray attacks by the rook or queen. Otherwise consider only
846 // the squares in the pawn's path attacked or occupied by the enemy.
847 if ( (squares_in_front_of(Them, s) & pos.pieces(ROOK, QUEEN, Them))
848 && (squares_in_front_of(Them, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
849 unsafeSquares = squaresToQueen;
851 unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces(Them));
853 // If there aren't enemy attacks or pieces along the path to queen give
854 // huge bonus. Even bigger if we protect the pawn's path.
856 ebonus += Value(rr * (squaresToQueen == defendedSquares ? 17 : 15));
858 // OK, there are enemy attacks or pieces (but not pawns). Are those
859 // squares which are attacked by the enemy also attacked by us ?
860 // If yes, big bonus (but smaller than when there are no enemy attacks),
861 // if no, somewhat smaller bonus.
862 ebonus += Value(rr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
866 // Increase the bonus if the passed pawn is supported by a friendly pawn
867 // on the same rank and a bit smaller if it's on the previous rank.
868 supportingPawns = pos.pieces(PAWN, Us) & adjacent_files_bb(file_of(s));
869 if (supportingPawns & rank_bb(s))
870 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 (file_of(s) == FILE_A || file_of(s) == FILE_H)
883 if (pos.non_pawn_material(Them) <= KnightValueMidgame)
884 ebonus += ebonus / 4;
885 else if (pos.pieces(ROOK, QUEEN, Them))
886 ebonus -= ebonus / 4;
888 score += make_score(mbonus, ebonus);
892 // Add the scores to the middle game and endgame eval
893 return apply_weight(score, Weights[PassedPawns]);
897 // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides, this is quite
898 // conservative and returns a winning score only when we are very sure that the pawn is winning.
900 Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
902 Bitboard b, b2, blockers, supporters, queeningPath, candidates;
903 Square s, blockSq, queeningSquare;
904 Color c, winnerSide, loserSide;
905 bool pathDefended, opposed;
906 int pliesToGo, movesToGo, oppMovesToGo, sacptg, blockersCount, minKingDist, kingptg, d;
907 int pliesToQueen[] = { 256, 256 };
909 // Step 1. Hunt for unstoppable passed pawns. If we find at least one,
910 // record how many plies are required for promotion.
911 for (c = WHITE; c <= BLACK; c++)
913 // Skip if other side has non-pawn pieces
914 if (pos.non_pawn_material(~c))
917 b = ei.pi->passed_pawns(c);
922 queeningSquare = relative_square(c, make_square(file_of(s), RANK_8));
923 queeningPath = squares_in_front_of(c, s);
925 // Compute plies to queening and check direct advancement
926 movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
927 oppMovesToGo = square_distance(pos.king_square(~c), queeningSquare) - int(c != pos.side_to_move());
928 pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
930 if (movesToGo >= oppMovesToGo && !pathDefended)
933 // Opponent king cannot block because path is defended and position
934 // is not in check. So only friendly pieces can be blockers.
935 assert(!pos.in_check());
936 assert((queeningPath & pos.occupied_squares()) == (queeningPath & pos.pieces(c)));
938 // Add moves needed to free the path from friendly pieces and retest condition
939 movesToGo += popcount<Max15>(queeningPath & pos.pieces(c));
941 if (movesToGo >= oppMovesToGo && !pathDefended)
944 pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
945 pliesToQueen[c] = std::min(pliesToQueen[c], pliesToGo);
949 // Step 2. If either side cannot promote at least three plies before the other side then situation
950 // becomes too complex and we give up. Otherwise we determine the possibly "winning side"
951 if (abs(pliesToQueen[WHITE] - pliesToQueen[BLACK]) < 3)
954 winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
955 loserSide = ~winnerSide;
957 // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
958 b = candidates = pos.pieces(PAWN, loserSide);
964 // Compute plies from queening
965 queeningSquare = relative_square(loserSide, make_square(file_of(s), RANK_8));
966 movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
967 pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
969 // Check if (without even considering any obstacles) we're too far away or doubled
970 if ( pliesToQueen[winnerSide] + 3 <= pliesToGo
971 || (squares_in_front_of(loserSide, s) & pos.pieces(PAWN, loserSide)))
975 // If any candidate is already a passed pawn it _may_ promote in time. We give up.
976 if (candidates & ei.pi->passed_pawns(loserSide))
979 // Step 4. Check new passed pawn creation through king capturing and pawn sacrifices
985 sacptg = blockersCount = 0;
986 minKingDist = kingptg = 256;
988 // Compute plies from queening
989 queeningSquare = relative_square(loserSide, make_square(file_of(s), RANK_8));
990 movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
991 pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
993 // Generate list of blocking pawns and supporters
994 supporters = adjacent_files_bb(file_of(s)) & candidates;
995 opposed = squares_in_front_of(loserSide, s) & pos.pieces(PAWN, winnerSide);
996 blockers = passed_pawn_mask(loserSide, s) & pos.pieces(PAWN, winnerSide);
1000 // How many plies does it take to remove all the blocking pawns?
1003 blockSq = pop_1st_bit(&blockers);
1006 // Check pawns that can give support to overcome obstacle, for instance
1007 // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
1010 b2 = supporters & in_front_bb(winnerSide, blockSq + pawn_push(winnerSide));
1012 while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
1014 d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
1015 movesToGo = std::min(movesToGo, d);
1019 // Check pawns that can be sacrificed against the blocking pawn
1020 b2 = attack_span_mask(winnerSide, blockSq) & candidates & ~(1ULL << s);
1022 while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
1024 d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
1025 movesToGo = std::min(movesToGo, d);
1028 // If obstacle can be destroyed with an immediate pawn exchange / sacrifice,
1029 // it's not a real obstacle and we have nothing to add to pliesToGo.
1033 // Plies needed to sacrifice against all the blocking pawns
1034 sacptg += movesToGo * 2;
1037 // Plies needed for the king to capture all the blocking pawns
1038 d = square_distance(pos.king_square(loserSide), blockSq);
1039 minKingDist = std::min(minKingDist, d);
1040 kingptg = (minKingDist + blockersCount) * 2;
1043 // Check if pawn sacrifice plan _may_ save the day
1044 if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
1047 // Check if king capture plan _may_ save the day (contains some false positives)
1048 if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
1052 // Winning pawn is unstoppable and will promote as first, return big score
1053 Score score = make_score(0, (Value) 0x500 - 0x20 * pliesToQueen[winnerSide]);
1054 return winnerSide == WHITE ? score : -score;
1058 // evaluate_space() computes the space evaluation for a given side. The
1059 // space evaluation is a simple bonus based on the number of safe squares
1060 // available for minor pieces on the central four files on ranks 2--4. Safe
1061 // squares one, two or three squares behind a friendly pawn are counted
1062 // twice. Finally, the space bonus is scaled by a weight taken from the
1063 // material hash table. The aim is to improve play on game opening.
1065 int evaluate_space(const Position& pos, EvalInfo& ei) {
1067 const Color Them = (Us == WHITE ? BLACK : WHITE);
1069 // Find the safe squares for our pieces inside the area defined by
1070 // SpaceMask[]. A square is unsafe if it is attacked by an enemy
1071 // pawn, or if it is undefended and attacked by an enemy piece.
1072 Bitboard safe = SpaceMask[Us]
1073 & ~pos.pieces(PAWN, Us)
1074 & ~ei.attackedBy[Them][PAWN]
1075 & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
1077 // Find all squares which are at most three squares behind some friendly pawn
1078 Bitboard behind = pos.pieces(PAWN, Us);
1079 behind |= (Us == WHITE ? behind >> 8 : behind << 8);
1080 behind |= (Us == WHITE ? behind >> 16 : behind << 16);
1082 return popcount<Max15>(safe) + popcount<Max15>(behind & safe);
1086 // apply_weight() applies an evaluation weight to a value trying to prevent overflow
1088 inline Score apply_weight(Score v, Score w) {
1089 return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
1090 (int(eg_value(v)) * eg_value(w)) / 0x100);
1094 // scale_by_game_phase() interpolates between a middle game and an endgame score,
1095 // based on game phase. It also scales the return value by a ScaleFactor array.
1097 Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf) {
1099 assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
1100 assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
1101 assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1103 int ev = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
1104 int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
1105 return Value((result + GrainSize / 2) & ~(GrainSize - 1));
1109 // weight_option() computes the value of an evaluation weight, by combining
1110 // two UCI-configurable weights (midgame and endgame) with an internal weight.
1112 Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
1114 // Scale option value from 100 to 256
1115 int mg = Options[mgOpt] * 256 / 100;
1116 int eg = Options[egOpt] * 256 / 100;
1118 return apply_weight(make_score(mg, eg), internalWeight);
1122 // A couple of little helpers used by tracing code, to_cp() converts a value to
1123 // a double in centipawns scale, trace_add() stores white and black scores.
1125 double to_cp(Value v) { return double(v) / double(PawnValueMidgame); }
1127 void trace_add(int idx, Score wScore, Score bScore) {
1129 TracedScores[WHITE][idx] = wScore;
1130 TracedScores[BLACK][idx] = bScore;
1133 // trace_row() is an helper function used by tracing code to register the
1134 // values of a single evaluation term.
1136 void trace_row(const char *name, int idx) {
1138 Score wScore = TracedScores[WHITE][idx];
1139 Score bScore = TracedScores[BLACK][idx];
1142 case PST: case IMBALANCE: case PAWN: case UNSTOPPABLE: case TOTAL:
1143 TraceStream << std::setw(20) << name << " | --- --- | --- --- | "
1144 << std::setw(6) << to_cp(mg_value(wScore)) << " "
1145 << std::setw(6) << to_cp(eg_value(wScore)) << " \n";
1148 TraceStream << std::setw(20) << name << " | " << std::noshowpos
1149 << std::setw(5) << to_cp(mg_value(wScore)) << " "
1150 << std::setw(5) << to_cp(eg_value(wScore)) << " | "
1151 << std::setw(5) << to_cp(mg_value(bScore)) << " "
1152 << std::setw(5) << to_cp(eg_value(bScore)) << " | "
1154 << std::setw(6) << to_cp(mg_value(wScore - bScore)) << " "
1155 << std::setw(6) << to_cp(eg_value(wScore - bScore)) << " \n";
1161 /// trace_evaluate() is like evaluate() but instead of a value returns a string
1162 /// suitable to be print on stdout with the detailed descriptions and values of
1163 /// each evaluation term. Used mainly for debugging.
1165 std::string trace_evaluate(const Position& pos) {
1170 TraceStream.str("");
1171 TraceStream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
1172 memset(TracedScores, 0, 2 * 16 * sizeof(Score));
1174 do_evaluate<true>(pos, margin);
1176 totals = TraceStream.str();
1177 TraceStream.str("");
1179 TraceStream << std::setw(21) << "Eval term " << "| White | Black | Total \n"
1180 << " | MG EG | MG EG | MG EG \n"
1181 << "---------------------+-------------+-------------+---------------\n";
1183 trace_row("Material, PST, Tempo", PST);
1184 trace_row("Material imbalance", IMBALANCE);
1185 trace_row("Pawns", PAWN);
1186 trace_row("Knights", KNIGHT);
1187 trace_row("Bishops", BISHOP);
1188 trace_row("Rooks", ROOK);
1189 trace_row("Queens", QUEEN);
1190 trace_row("Mobility", MOBILITY);
1191 trace_row("King safety", KING);
1192 trace_row("Threats", THREAT);
1193 trace_row("Passed pawns", PASSED);
1194 trace_row("Unstoppable pawns", UNSTOPPABLE);
1195 trace_row("Space", SPACE);
1197 TraceStream << "---------------------+-------------+-------------+---------------\n";
1198 trace_row("Total", TOTAL);
1199 TraceStream << totals;
1201 return TraceStream.str();