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