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