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