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