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