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