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