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