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