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