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