git.sesse.net Git - stockfish/blob - src/evaluate.cpp

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
   4   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
   5   Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
   6
   7   Stockfish is free software: you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation, either version 3 of the License, or
  10   (at your option) any later version.
  11
  12   Stockfish is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <algorithm>
  22 #include <cassert>
  23 #include <cstring>   // For std::memset
  24 #include <iomanip>
  25 #include <sstream>
  26
  27 #include "bitboard.h"
  28 #include "evaluate.h"
  29 #include "material.h"
  30 #include "pawns.h"
  31
  32 namespace {
  33
  34   namespace Trace {
  35
  36     enum Term { // The first 8 entries are for PieceType
  37       MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
  38     };
  39
  40     double scores[TERM_NB][COLOR_NB][PHASE_NB];
  41
  42     double to_cp(Value v) { return double(v) / PawnValueEg; }
  43
  44     void add(int idx, Color c, Score s) {
  45       scores[idx][c][MG] = to_cp(mg_value(s));
  46       scores[idx][c][EG] = to_cp(eg_value(s));
  47     }
  48
  49     void add(int idx, Score w, Score b = SCORE_ZERO) {
  50       add(idx, WHITE, w); add(idx, BLACK, b);
  51     }
  52
  53     std::ostream& operator<<(std::ostream& os, Term t) {
  54
  55       if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL)
  56           os << "  ---   --- |   ---   --- | ";
  57       else
  58           os << std::setw(5) << scores[t][WHITE][MG] << " "
  59              << std::setw(5) << scores[t][WHITE][EG] << " | "
  60              << std::setw(5) << scores[t][BLACK][MG] << " "
  61              << std::setw(5) << scores[t][BLACK][EG] << " | ";
  62
  63       os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
  64          << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
  65
  66       return os;
  67     }
  68   }
  69
  70   using namespace Trace;
  71
  72   // Struct EvalInfo contains various information computed and collected
  73   // by the evaluation functions.
  74   struct EvalInfo {
  75
  76     Material::Entry* me;
  77     Pawns::Entry* pe;
  78     Bitboard mobilityArea[COLOR_NB];
  79
  80     // attackedBy[color][piece type] is a bitboard representing all squares
  81     // attacked by a given color and piece type (can be also ALL_PIECES).
  82     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
  83
  84     // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
  85     // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
  86     // pawn or squares attacked by 2 pawns are not explicitly added.
  87     Bitboard attackedBy2[COLOR_NB];
  88
  89     // kingRing[color] is the zone around the king which is considered
  90     // by the king safety evaluation. This consists of the squares directly
  91     // adjacent to the king, and the three (or two, for a king on an edge file)
  92     // squares two ranks in front of the king. For instance, if black's king
  93     // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
  94     // f7, g7, h7, f6, g6 and h6.
  95     Bitboard kingRing[COLOR_NB];
  96
  97     // kingAttackersCount[color] is the number of pieces of the given color
  98     // which attack a square in the kingRing of the enemy king.
  99     int kingAttackersCount[COLOR_NB];
 100
 101     // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
 102     // given color which attack a square in the kingRing of the enemy king. The
 103     // weights of the individual piece types are given by the elements in the
 104     // KingAttackWeights array.
 105     int kingAttackersWeight[COLOR_NB];
 106
 107     // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
 108     // color to squares directly adjacent to the enemy king. Pieces which attack
 109     // more than one square are counted multiple times. For instance, if there is
 110     // a white knight on g5 and black's king is on g8, this white knight adds 2
 111     // to kingAdjacentZoneAttacksCount[WHITE].
 112     int kingAdjacentZoneAttacksCount[COLOR_NB];
 113   };
 114
 115   #define V(v) Value(v)
 116   #define S(mg, eg) make_score(mg, eg)
 117
 118   // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
 119   // indexed by piece type and number of attacked squares in the mobility area.
 120   const Score MobilityBonus[][32] = {
 121     { S(-75,-76), S(-57,-54), S( -9,-28), S( -2,-10), S(  6,  5), S( 14, 12), // Knights
 122       S( 22, 26), S( 29, 29), S( 36, 29) },
 123     { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
 124       S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
 125       S( 91, 88), S( 98, 97) },
 126     { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
 127       S(  9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
 128       S( 46,166), S( 48,169), S( 58,171) },
 129     { S(-39,-36), S(-21,-15), S(  3,  8), S(  3, 18), S( 14, 34), S( 22, 54), // Queens
 130       S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
 131       S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
 132       S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
 133       S(106,184), S(109,191), S(113,206), S(116,212) }
 134   };
 135
 136   // Outpost[knight/bishop][supported by pawn] contains bonuses for minor
 137   // pieces if they can reach an outpost square, bigger if that square is
 138   // supported by a pawn. If the minor piece occupies an outpost square
 139   // then score is doubled.
 140   const Score Outpost[][2] = {
 141     { S(22, 6), S(33, 9) }, // Knight
 142     { S( 9, 2), S(14, 4) }  // Bishop
 143   };
 144
 145   // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
 146   // friendly pawn on the rook file.
 147   const Score RookOnFile[] = { S(20, 7), S(45, 20) };
 148
 149   // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
 150   // which piece type attacks which one. Attacks on lesser pieces which are
 151   // pawn-defended are not considered.
 152   const Score ThreatByMinor[PIECE_TYPE_NB] = {
 153     S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
 154   };
 155
 156   const Score ThreatByRook[PIECE_TYPE_NB] = {
 157     S(0, 0), S(0, 25), S(40, 62), S(40, 59), S( 0, 34), S(35, 48)
 158   };
 159
 160   // ThreatByKing[on one/on many] contains bonuses for king attacks on
 161   // pawns or pieces which are not pawn-defended.
 162   const Score ThreatByKing[] = { S(3, 62), S(9, 138) };
 163
 164   // Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
 165   // We don't use a Score because we process the two components independently.
 166   const Value Passed[][RANK_NB] = {
 167     { V(5), V( 5), V(31), V(73), V(166), V(252) },
 168     { V(7), V(14), V(38), V(73), V(166), V(252) }
 169   };
 170
 171   // PassedFile[File] contains a bonus according to the file of a passed pawn
 172   const Score PassedFile[FILE_NB] = {
 173     S(  9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
 174     S(-20,-12), S( 1, -8), S( 2, 10), S(  9, 10)
 175   };
 176
 177   // Protector[PieceType-2][distance] contains a protecting bonus for our king,
 178   // indexed by piece type and distance between the piece and the king.
 179   const Score Protector[][8] = {
 180     { S(0, 0), S( 7, 9), S( 7, 1), S( 1, 5), S(-10,-4), S( -1,-4), S( -7,-3), S(-16,-10) }, // Knight
 181     { S(0, 0), S(11, 8), S(-7,-1), S(-1,-2), S( -1,-7), S(-11,-3), S( -9,-1), S(-16, -1) }, // Bishop
 182     { S(0, 0), S(10, 0), S(-2, 2), S(-5, 4), S( -6, 2), S(-14,-3), S( -2,-9), S(-12, -7) }, // Rook
 183     { S(0, 0), S( 3,-5), S( 2,-5), S(-4, 0), S( -9,-6), S( -4, 7), S(-13,-7), S(-10, -7) }  // Queen
 184   };
 185
 186   // Assorted bonuses and penalties used by evaluation
 187   const Score MinorBehindPawn     = S( 16,  0);
 188   const Score BishopPawns         = S(  8, 12);
 189   const Score RookOnPawn          = S(  8, 24);
 190   const Score TrappedRook         = S( 92,  0);
 191   const Score WeakQueen           = S( 50, 10);
 192   const Score OtherCheck          = S( 10, 10);
 193   const Score CloseEnemies        = S(  7,  0);
 194   const Score PawnlessFlank       = S( 20, 80);
 195   const Score ThreatByHangingPawn = S( 71, 61);
 196   const Score ThreatBySafePawn    = S(182,175);
 197   const Score ThreatByRank        = S( 16,  3);
 198   const Score Hanging             = S( 48, 27);
 199   const Score ThreatByPawnPush    = S( 38, 22);
 200   const Score HinderPassedPawn    = S(  7,  0);
 201
 202   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
 203   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
 204   // happen in Chess960 games.
 205   const Score TrappedBishopA1H1 = S(50, 50);
 206
 207   #undef S
 208   #undef V
 209
 210   // KingAttackWeights[PieceType] contains king attack weights by piece type
 211   const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
 212
 213   // Penalties for enemy's safe checks
 214   const int QueenCheck  = 780;
 215   const int RookCheck   = 880;
 216   const int BishopCheck = 435;
 217   const int KnightCheck = 790;
 218
 219   // Threshold for lazy and space evaluation
 220   const Value LazyThreshold  = Value(1500);
 221   const Value SpaceThreshold = Value(12222);
 222
 223   // eval_init() initializes king and attack bitboards for a given color
 224   // adding pawn attacks. To be done at the beginning of the evaluation.
 225
 226   template<Color Us>
 227   void eval_init(const Position& pos, EvalInfo& ei) {
 228
 229     const Color  Them = (Us == WHITE ? BLACK : WHITE);
 230     const Square Up   = (Us == WHITE ? NORTH : SOUTH);
 231     const Square Down = (Us == WHITE ? SOUTH : NORTH);
 232     const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
 233
 234     // Find our pawns on the first two ranks, and those which are blocked
 235     Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
 236
 237     // Squares occupied by those pawns, by our king, or controlled by enemy pawns
 238     // are excluded from the mobility area.
 239     ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them));
 240
 241     // Initialise the attack bitboards with the king and pawn information
 242     b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
 243     ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us);
 244
 245     ei.attackedBy2[Us]            = b & ei.attackedBy[Us][PAWN];
 246     ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN];
 247
 248     // Init our king safety tables only if we are going to use them
 249     if (pos.non_pawn_material(Them) >= QueenValueMg)
 250     {
 251         ei.kingRing[Us] = b | shift<Up>(b);
 252         ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them));
 253         ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0;
 254     }
 255     else
 256         ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0;
 257   }
 258
 259
 260   // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
 261   // color and type.
 262
 263   template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT>
 264   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
 265
 266     const Color Them = (Us == WHITE ? BLACK : WHITE);
 267     const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
 268     const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
 269                                                : Rank5BB | Rank4BB | Rank3BB);
 270     const Square* pl = pos.squares<Pt>(Us);
 271
 272     Bitboard b, bb;
 273     Square s;
 274     Score score = SCORE_ZERO;
 275
 276     ei.attackedBy[Us][Pt] = 0;
 277
 278     while ((s = *pl++) != SQ_NONE)
 279     {
 280         // Find attacked squares, including x-ray attacks for bishops and rooks
 281         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
 282           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
 283                          : pos.attacks_from<Pt>(s);
 284
 285         if (pos.pinned_pieces(Us) & s)
 286             b &= LineBB[pos.square<KING>(Us)][s];
 287
 288         ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
 289         ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
 290
 291         if (b & ei.kingRing[Them])
 292         {
 293             ei.kingAttackersCount[Us]++;
 294             ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
 295             ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]);
 296         }
 297
 298         int mob = popcount(b & ei.mobilityArea[Us]);
 299
 300         mobility[Us] += MobilityBonus[Pt-2][mob];
 301
 302         // Bonus for this piece as a king protector
 303         score += Protector[Pt-2][distance(s, pos.square<KING>(Us))];
 304
 305         if (Pt == BISHOP || Pt == KNIGHT)
 306         {
 307             // Bonus for outpost squares
 308             bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them);
 309             if (bb & s)
 310                 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2;
 311             else
 312             {
 313                 bb &= b & ~pos.pieces(Us);
 314                 if (bb)
 315                    score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)];
 316             }
 317
 318             // Bonus when behind a pawn
 319             if (    relative_rank(Us, s) < RANK_5
 320                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
 321                 score += MinorBehindPawn;
 322
 323             // Penalty for pawns on the same color square as the bishop
 324             if (Pt == BISHOP)
 325                 score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s);
 326
 327             // An important Chess960 pattern: A cornered bishop blocked by a friendly
 328             // pawn diagonally in front of it is a very serious problem, especially
 329             // when that pawn is also blocked.
 330             if (   Pt == BISHOP
 331                 && pos.is_chess960()
 332                 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
 333             {
 334                 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
 335                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
 336                     score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
 337                             : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
 338                                                                               : TrappedBishopA1H1;
 339             }
 340         }
 341
 342         if (Pt == ROOK)
 343         {
 344             // Bonus for aligning with enemy pawns on the same rank/file
 345             if (relative_rank(Us, s) >= RANK_5)
 346                 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
 347
 348             // Bonus when on an open or semi-open file
 349             if (ei.pe->semiopen_file(Us, file_of(s)))
 350                 score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))];
 351
 352             // Penalty when trapped by the king, even more if the king cannot castle
 353             else if (mob <= 3)
 354             {
 355                 Square ksq = pos.square<KING>(Us);
 356
 357                 if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
 358                     && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
 359                     score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
 360             }
 361         }
 362
 363         if (Pt == QUEEN)
 364         {
 365             // Penalty if any relative pin or discovered attack against the queen
 366             Bitboard pinners;
 367             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
 368                 score -= WeakQueen;
 369         }
 370     }
 371
 372     if (DoTrace)
 373         Trace::add(Pt, Us, score);
 374
 375     // Recursively call evaluate_pieces() of next piece type until KING is excluded
 376     return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
 377   }
 378
 379   template<>
 380   Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
 381   template<>
 382   Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
 383
 384
 385   // evaluate_king() assigns bonuses and penalties to a king of a given color
 386
 387   const Bitboard QueenSide   = FileABB | FileBBB | FileCBB | FileDBB;
 388   const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
 389   const Bitboard KingSide    = FileEBB | FileFBB | FileGBB | FileHBB;
 390
 391   const Bitboard KingFlank[FILE_NB] = {
 392     QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide
 393   };
 394
 395   template<Color Us, bool DoTrace>
 396   Score evaluate_king(const Position& pos, const EvalInfo& ei) {
 397
 398     const Color Them    = (Us == WHITE ? BLACK : WHITE);
 399     const Square Up     = (Us == WHITE ? NORTH : SOUTH);
 400     const Bitboard Camp = (Us == WHITE ? ~Bitboard(0) ^ Rank6BB ^ Rank7BB ^ Rank8BB
 401                                        : ~Bitboard(0) ^ Rank1BB ^ Rank2BB ^ Rank3BB);
 402
 403     const Square ksq = pos.square<KING>(Us);
 404     Bitboard undefended, b, b1, b2, safe, other;
 405     int kingDanger;
 406
 407     // King shelter and enemy pawns storm
 408     Score score = ei.pe->king_safety<Us>(pos, ksq);
 409
 410     // Main king safety evaluation
 411     if (ei.kingAttackersCount[Them])
 412     {
 413         // Find the attacked squares which are defended only by our king...
 414         undefended =   ei.attackedBy[Them][ALL_PIECES]
 415                     &  ei.attackedBy[Us][KING]
 416                     & ~ei.attackedBy2[Us];
 417
 418         // ... and those which are not defended at all in the larger king ring
 419         b =  ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
 420            & ei.kingRing[Us] & ~pos.pieces(Them);
 421
 422         // Initialize the 'kingDanger' variable, which will be transformed
 423         // later into a king danger score. The initial value is based on the
 424         // number and types of the enemy's attacking pieces, the number of
 425         // attacked and undefended squares around our king and the quality of
 426         // the pawn shelter (current 'score' value).
 427         kingDanger =        ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]
 428                     + 102 * ei.kingAdjacentZoneAttacksCount[Them]
 429                     + 201 * popcount(undefended)
 430                     + 143 * (popcount(b) + !!pos.pinned_pieces(Us))
 431                     - 848 * !pos.count<QUEEN>(Them)
 432                     -  28 * mg_value(score) / 25 - 5;
 433
 434         // Analyse the safe enemy's checks which are possible on next move
 435         safe  = ~pos.pieces(Them);
 436         safe &= ~ei.attackedBy[Us][ALL_PIECES] | (undefended & ei.attackedBy2[Them]);
 437
 438         b1 = pos.attacks_from<ROOK  >(ksq);
 439         b2 = pos.attacks_from<BISHOP>(ksq);
 440
 441         // Enemy queen safe checks
 442         if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
 443             kingDanger += QueenCheck;
 444
 445         // For minors and rooks, also consider the square safe if attacked twice,
 446         // and only defended by our queen.
 447         safe |=  ei.attackedBy2[Them]
 448                & ~(ei.attackedBy2[Us] | pos.pieces(Them))
 449                & ei.attackedBy[Us][QUEEN];
 450
 451         // Some other potential checks are also analysed, even from squares
 452         // currently occupied by the opponent own pieces, as long as the square
 453         // is not attacked by our pawns, and is not occupied by a blocked pawn.
 454         other = ~(   ei.attackedBy[Us][PAWN]
 455                   | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
 456
 457         // Enemy rooks safe and other checks
 458         if (b1 & ei.attackedBy[Them][ROOK] & safe)
 459             kingDanger += RookCheck;
 460
 461         else if (b1 & ei.attackedBy[Them][ROOK] & other)
 462             score -= OtherCheck;
 463
 464         // Enemy bishops safe and other checks
 465         if (b2 & ei.attackedBy[Them][BISHOP] & safe)
 466             kingDanger += BishopCheck;
 467
 468         else if (b2 & ei.attackedBy[Them][BISHOP] & other)
 469             score -= OtherCheck;
 470
 471         // Enemy knights safe and other checks
 472         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT];
 473         if (b & safe)
 474             kingDanger += KnightCheck;
 475
 476         else if (b & other)
 477             score -= OtherCheck;
 478
 479         // Transform the kingDanger units into a Score, and substract it from the evaluation
 480         if (kingDanger > 0)
 481             score -= make_score(kingDanger * kingDanger / 4096, 0);
 482     }
 483
 484     // King tropism: firstly, find squares that opponent attacks in our king flank
 485     File kf = file_of(ksq);
 486     b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
 487
 488     assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
 489     assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
 490
 491     // Secondly, add the squares which are attacked twice in that flank and
 492     // which are not defended by our pawns.
 493     b =  (Us == WHITE ? b << 4 : b >> 4)
 494        | (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]);
 495
 496     score -= CloseEnemies * popcount(b);
 497
 498     // Penalty when our king is on a pawnless flank
 499     if (!(pos.pieces(PAWN) & KingFlank[kf]))
 500         score -= PawnlessFlank;
 501
 502     if (DoTrace)
 503         Trace::add(KING, Us, score);
 504
 505     return score;
 506   }
 507
 508
 509   // evaluate_threats() assigns bonuses according to the types of the attacking
 510   // and the attacked pieces.
 511
 512   template<Color Us, bool DoTrace>
 513   Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
 514
 515     const Color Them        = (Us == WHITE ? BLACK      : WHITE);
 516     const Square Up         = (Us == WHITE ? NORTH      : SOUTH);
 517     const Square Left       = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
 518     const Square Right      = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
 519     const Bitboard TRank2BB = (Us == WHITE ? Rank2BB    : Rank7BB);
 520     const Bitboard TRank7BB = (Us == WHITE ? Rank7BB    : Rank2BB);
 521
 522     Bitboard b, weak, defended, stronglyProtected, safeThreats;
 523     Score score = SCORE_ZERO;
 524
 525     // Non-pawn enemies attacked by a pawn
 526     weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
 527
 528     if (weak)
 529     {
 530         b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
 531                                     | ei.attackedBy[Us][ALL_PIECES]);
 532
 533         safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
 534
 535         score += ThreatBySafePawn * popcount(safeThreats);
 536
 537         if (weak ^ safeThreats)
 538             score += ThreatByHangingPawn;
 539     }
 540
 541     // Squares strongly protected by the opponent, either because they attack the
 542     // square with a pawn, or because they attack the square twice and we don't.
 543     stronglyProtected =  ei.attackedBy[Them][PAWN]
 544                        | (ei.attackedBy2[Them] & ~ei.attackedBy2[Us]);
 545
 546     // Non-pawn enemies, strongly protected
 547     defended =  (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
 548               & stronglyProtected;
 549
 550     // Enemies not strongly protected and under our attack
 551     weak =   pos.pieces(Them)
 552           & ~stronglyProtected
 553           &  ei.attackedBy[Us][ALL_PIECES];
 554
 555     // Add a bonus according to the kind of attacking pieces
 556     if (defended | weak)
 557     {
 558         b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
 559         while (b)
 560         {
 561             Square s = pop_lsb(&b);
 562             score += ThreatByMinor[type_of(pos.piece_on(s))];
 563             if (type_of(pos.piece_on(s)) != PAWN)
 564                 score += ThreatByRank * (int)relative_rank(Them, s);
 565         }
 566
 567         b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
 568         while (b)
 569         {
 570             Square s = pop_lsb(&b);
 571             score += ThreatByRook[type_of(pos.piece_on(s))];
 572             if (type_of(pos.piece_on(s)) != PAWN)
 573                 score += ThreatByRank * (int)relative_rank(Them, s);
 574         }
 575
 576         score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
 577
 578         b = weak & ei.attackedBy[Us][KING];
 579         if (b)
 580             score += ThreatByKing[more_than_one(b)];
 581     }
 582
 583     // Bonus if some pawns can safely push and attack an enemy piece
 584     b = pos.pieces(Us, PAWN) & ~TRank7BB;
 585     b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
 586
 587     b &=  ~pos.pieces()
 588         & ~ei.attackedBy[Them][PAWN]
 589         & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
 590
 591     b =  (shift<Left>(b) | shift<Right>(b))
 592        &  pos.pieces(Them)
 593        & ~ei.attackedBy[Us][PAWN];
 594
 595     score += ThreatByPawnPush * popcount(b);
 596
 597     if (DoTrace)
 598         Trace::add(THREAT, Us, score);
 599
 600     return score;
 601   }
 602
 603
 604   // evaluate_passer_pawns() evaluates the passed pawns and candidate passed
 605   // pawns of the given color.
 606
 607   template<Color Us, bool DoTrace>
 608   Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) {
 609
 610     const Color Them = (Us == WHITE ? BLACK : WHITE);
 611
 612     Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
 613     Score score = SCORE_ZERO;
 614
 615     b = ei.pe->passed_pawns(Us);
 616
 617     while (b)
 618     {
 619         Square s = pop_lsb(&b);
 620
 621         assert(!(pos.pieces(Them, PAWN) & forward_bb(Us, s + pawn_push(Us))));
 622
 623         bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
 624         score -= HinderPassedPawn * popcount(bb);
 625
 626         int r = relative_rank(Us, s) - RANK_2;
 627         int rr = r * (r - 1);
 628
 629         Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
 630
 631         if (rr)
 632         {
 633             Square blockSq = s + pawn_push(Us);
 634
 635             // Adjust bonus based on the king's proximity
 636             ebonus +=  distance(pos.square<KING>(Them), blockSq) * 5 * rr
 637                      - distance(pos.square<KING>(Us  ), blockSq) * 2 * rr;
 638
 639             // If blockSq is not the queening square then consider also a second push
 640             if (relative_rank(Us, blockSq) != RANK_8)
 641                 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
 642
 643             // If the pawn is free to advance, then increase the bonus
 644             if (pos.empty(blockSq))
 645             {
 646                 // If there is a rook or queen attacking/defending the pawn from behind,
 647                 // consider all the squaresToQueen. Otherwise consider only the squares
 648                 // in the pawn's path attacked or occupied by the enemy.
 649                 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
 650
 651                 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
 652
 653                 if (!(pos.pieces(Us) & bb))
 654                     defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
 655
 656                 if (!(pos.pieces(Them) & bb))
 657                     unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
 658
 659                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
 660                 // assign a smaller bonus if the block square isn't attacked.
 661                 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
 662
 663                 // If the path to the queen is fully defended, assign a big bonus.
 664                 // Otherwise assign a smaller bonus if the block square is defended.
 665                 if (defendedSquares == squaresToQueen)
 666                     k += 6;
 667
 668                 else if (defendedSquares & blockSq)
 669                     k += 4;
 670
 671                 mbonus += k * rr, ebonus += k * rr;
 672             }
 673             else if (pos.pieces(Us) & blockSq)
 674                 mbonus += rr + r * 2, ebonus += rr + r * 2;
 675         } // rr != 0
 676
 677         // Scale down bonus for candidate passers which need more than one
 678         // pawn push to become passed or have a pawn in front of them.
 679         if (!pos.pawn_passed(Us, s + pawn_push(Us)) || (pos.pieces(PAWN) & forward_bb(Us, s)))
 680             mbonus /= 2, ebonus /= 2;
 681
 682         score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
 683     }
 684
 685     if (DoTrace)
 686         Trace::add(PASSED, Us, score);
 687
 688     return score;
 689   }
 690
 691
 692   // evaluate_space() computes the space evaluation for a given side. The
 693   // space evaluation is a simple bonus based on the number of safe squares
 694   // available for minor pieces on the central four files on ranks 2--4. Safe
 695   // squares one, two or three squares behind a friendly pawn are counted
 696   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
 697   // improve play on game opening.
 698   template<Color Us>
 699   Score evaluate_space(const Position& pos, const EvalInfo& ei) {
 700
 701     const Color Them = (Us == WHITE ? BLACK : WHITE);
 702     const Bitboard SpaceMask =
 703       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
 704                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
 705
 706     // Find the safe squares for our pieces inside the area defined by
 707     // SpaceMask. A square is unsafe if it is attacked by an enemy
 708     // pawn, or if it is undefended and attacked by an enemy piece.
 709     Bitboard safe =   SpaceMask
 710                    & ~pos.pieces(Us, PAWN)
 711                    & ~ei.attackedBy[Them][PAWN]
 712                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
 713
 714     // Find all squares which are at most three squares behind some friendly pawn
 715     Bitboard behind = pos.pieces(Us, PAWN);
 716     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
 717     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
 718
 719     // Since SpaceMask[Us] is fully on our half of the board...
 720     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
 721
 722     // ...count safe + (behind & safe) with a single popcount.
 723     int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
 724     int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
 725
 726     return make_score(bonus * weight * weight / 16, 0);
 727   }
 728
 729
 730   // evaluate_initiative() computes the initiative correction value for the
 731   // position, i.e., second order bonus/malus based on the known attacking/defending
 732   // status of the players.
 733   Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
 734
 735     int kingDistance =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
 736                       - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
 737     bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
 738
 739     // Compute the initiative bonus for the attacking side
 740     int initiative = 8 * (asymmetry + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
 741
 742     // Now apply the bonus: note that we find the attacking side by extracting
 743     // the sign of the endgame value, and that we carefully cap the bonus so
 744     // that the endgame score will never change sign after the bonus.
 745     int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
 746
 747     return make_score(0, value);
 748   }
 749
 750
 751   // evaluate_scale_factor() computes the scale factor for the winning side
 752   ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
 753
 754     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
 755     ScaleFactor sf = ei.me->scale_factor(pos, strongSide);
 756
 757     // If we don't already have an unusual scale factor, check for certain
 758     // types of endgames, and use a lower scale for those.
 759     if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
 760     {
 761         if (pos.opposite_bishops())
 762         {
 763             // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
 764             // is almost a draw, in case of KBP vs KB, it is even more a draw.
 765             if (   pos.non_pawn_material(WHITE) == BishopValueMg
 766                 && pos.non_pawn_material(BLACK) == BishopValueMg)
 767                 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
 768
 769             // Endgame with opposite-colored bishops, but also other pieces. Still
 770             // a bit drawish, but not as drawish as with only the two bishops.
 771             return ScaleFactor(46);
 772         }
 773         // Endings where weaker side can place his king in front of the opponent's
 774         // pawns are drawish.
 775         else if (    abs(eg) <= BishopValueEg
 776                  &&  pos.count<PAWN>(strongSide) <= 2
 777                  && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
 778             return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
 779     }
 780
 781     return sf;
 782   }
 783
 784 } // namespace
 785
 786
 787 /// evaluate() is the main evaluation function. It returns a static evaluation
 788 /// of the position from the point of view of the side to move.
 789
 790 template<bool DoTrace>
 791 Value Eval::evaluate(const Position& pos) {
 792
 793   assert(!pos.checkers());
 794
 795   Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
 796   Value v;
 797   EvalInfo ei;
 798
 799   // Probe the material hash table
 800   ei.me = Material::probe(pos);
 801
 802   // If we have a specialized evaluation function for the current material
 803   // configuration, call it and return.
 804   if (ei.me->specialized_eval_exists())
 805       return ei.me->evaluate(pos);
 806
 807   // Initialize score by reading the incrementally updated scores included in
 808   // the position object (material + piece square tables) and the material
 809   // imbalance. Score is computed internally from the white point of view.
 810   Score score = pos.psq_score() + ei.me->imbalance();
 811
 812   // Probe the pawn hash table
 813   ei.pe = Pawns::probe(pos);
 814   score += ei.pe->pawns_score();
 815
 816   // Early exit if score is high
 817   v = (mg_value(score) + eg_value(score)) / 2;
 818   if (abs(v) > LazyThreshold)
 819      return pos.side_to_move() == WHITE ? v : -v;
 820
 821   // Initialize attack and king safety bitboards
 822   eval_init<WHITE>(pos, ei);
 823   eval_init<BLACK>(pos, ei);
 824
 825   // Evaluate all pieces but king and pawns
 826   score += evaluate_pieces<DoTrace>(pos, ei, mobility);
 827   score += mobility[WHITE] - mobility[BLACK];
 828
 829   // Evaluate kings after all other pieces because we need full attack
 830   // information when computing the king safety evaluation.
 831   score +=  evaluate_king<WHITE, DoTrace>(pos, ei)
 832           - evaluate_king<BLACK, DoTrace>(pos, ei);
 833
 834   // Evaluate tactical threats, we need full attack information including king
 835   score +=  evaluate_threats<WHITE, DoTrace>(pos, ei)
 836           - evaluate_threats<BLACK, DoTrace>(pos, ei);
 837
 838   // Evaluate passed pawns, we need full attack information including king
 839   score +=  evaluate_passer_pawns<WHITE, DoTrace>(pos, ei)
 840           - evaluate_passer_pawns<BLACK, DoTrace>(pos, ei);
 841
 842   // Evaluate space for both sides, only during opening
 843   if (pos.non_pawn_material() >= SpaceThreshold)
 844       score +=  evaluate_space<WHITE>(pos, ei)
 845               - evaluate_space<BLACK>(pos, ei);
 846
 847   // Evaluate position potential for the winning side
 848   score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
 849
 850   // Evaluate scale factor for the winning side
 851   ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
 852
 853   // Interpolate between a middlegame and a (scaled by 'sf') endgame score
 854   v =  mg_value(score) * int(ei.me->game_phase())
 855      + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
 856
 857   v /= int(PHASE_MIDGAME);
 858
 859   // In case of tracing add all remaining individual evaluation terms
 860   if (DoTrace)
 861   {
 862       Trace::add(MATERIAL, pos.psq_score());
 863       Trace::add(IMBALANCE, ei.me->imbalance());
 864       Trace::add(PAWN, ei.pe->pawns_score());
 865       Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
 866       if (pos.non_pawn_material() >= SpaceThreshold)
 867           Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
 868                           , evaluate_space<BLACK>(pos, ei));
 869       Trace::add(TOTAL, score);
 870   }
 871
 872   return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
 873 }
 874
 875 // Explicit template instantiations
 876 template Value Eval::evaluate<true >(const Position&);
 877 template Value Eval::evaluate<false>(const Position&);
 878
 879
 880 /// trace() is like evaluate(), but instead of returning a value, it returns
 881 /// a string (suitable for outputting to stdout) that contains the detailed
 882 /// descriptions and values of each evaluation term. Useful for debugging.
 883
 884 std::string Eval::trace(const Position& pos) {
 885
 886   std::memset(scores, 0, sizeof(scores));
 887
 888   Value v = evaluate<true>(pos);
 889   v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
 890
 891   std::stringstream ss;
 892   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
 893      << "      Eval term |    White    |    Black    |    Total    \n"
 894      << "                |   MG    EG  |   MG    EG  |   MG    EG  \n"
 895      << "----------------+-------------+-------------+-------------\n"
 896      << "       Material | " << Term(MATERIAL)
 897      << "      Imbalance | " << Term(IMBALANCE)
 898      << "          Pawns | " << Term(PAWN)
 899      << "        Knights | " << Term(KNIGHT)
 900      << "         Bishop | " << Term(BISHOP)
 901      << "          Rooks | " << Term(ROOK)
 902      << "         Queens | " << Term(QUEEN)
 903      << "       Mobility | " << Term(MOBILITY)
 904      << "    King safety | " << Term(KING)
 905      << "        Threats | " << Term(THREAT)
 906      << "   Passed pawns | " << Term(PASSED)
 907      << "          Space | " << Term(SPACE)
 908      << "----------------+-------------+-------------+-------------\n"
 909      << "          Total | " << Term(TOTAL);
 910
 911   ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
 912
 913   return ss.str();
 914 }