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