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