git.sesse.net Git - stockfish/blob - src/evaluate.cpp

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