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