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  = 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( 30, 21);
 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( 52, 10);
 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   = pawn_push(Us);
 217     constexpr Direction Down = -Up;
 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, by blockers to attacks on our king
 228     // or controlled by enemy pawns are excluded from the mobility area.
 229     mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | 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     Square s = make_square(clamp(file_of(ksq), FILE_B, FILE_G),
 239                            clamp(rank_of(ksq), RANK_2, RANK_7));
 240     kingRing[Us] = PseudoAttacks[KING][s] | s;
 241
 242     kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
 243     kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
 244
 245     // Remove from kingRing[] the squares defended by two pawns
 246     kingRing[Us] &= ~dblAttackByPawn;
 247   }
 248
 249
 250   // Evaluation::pieces() scores pieces of a given color and type
 251   template<Tracing T> template<Color Us, PieceType Pt>
 252   Score Evaluation<T>::pieces() {
 253
 254     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
 255     constexpr Direction Down = -pawn_push(Us);
 256     constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
 257                                                    : Rank5BB | Rank4BB | Rank3BB);
 258     const Square* pl = pos.squares<Pt>(Us);
 259
 260     Bitboard b, bb;
 261     Score score = SCORE_ZERO;
 262
 263     attackedBy[Us][Pt] = 0;
 264
 265     for (Square s = *pl; s != SQ_NONE; s = *++pl)
 266     {
 267         // Find attacked squares, including x-ray attacks for bishops and rooks
 268         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
 269           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
 270                          : pos.attacks_from<Pt>(s);
 271
 272         if (pos.blockers_for_king(Us) & s)
 273             b &= LineBB[pos.square<KING>(Us)][s];
 274
 275         attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
 276         attackedBy[Us][Pt] |= b;
 277         attackedBy[Us][ALL_PIECES] |= b;
 278
 279         if (b & kingRing[Them])
 280         {
 281             kingAttackersCount[Us]++;
 282             kingAttackersWeight[Us] += KingAttackWeights[Pt];
 283             kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
 284         }
 285
 286         int mob = popcount(b & mobilityArea[Us]);
 287
 288         mobility[Us] += MobilityBonus[Pt - 2][mob];
 289
 290         if (Pt == BISHOP || Pt == KNIGHT)
 291         {
 292             // Bonus if piece is on an outpost square or can reach one
 293             bb = OutpostRanks & attackedBy[Us][PAWN] & ~pe->pawn_attacks_span(Them);
 294             if (bb & s)
 295                 score += Outpost * (Pt == KNIGHT ? 2 : 1);
 296
 297             else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us))
 298                 score += Outpost;
 299
 300             // Knight and Bishop bonus for being right behind a pawn
 301             if (shift<Down>(pos.pieces(PAWN)) & s)
 302                 score += MinorBehindPawn;
 303
 304             // Penalty if the piece is far from the king
 305             score -= KingProtector * distance(s, pos.square<KING>(Us));
 306
 307             if (Pt == BISHOP)
 308             {
 309                 // Penalty according to number of pawns on the same color square as the
 310                 // bishop, bigger when the center files are blocked with pawns.
 311                 Bitboard blocked = pos.pieces(Us, PAWN) & shift<Down>(pos.pieces());
 312
 313                 score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s)
 314                                      * (1 + popcount(blocked & CenterFiles));
 315
 316                 // Bonus for bishop on a long diagonal which can "see" both center squares
 317                 if (more_than_one(attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & Center))
 318                     score += LongDiagonalBishop;
 319
 320                 // An important Chess960 pattern: a cornered bishop blocked by a friendly
 321                 // pawn diagonally in front of it is a very serious problem, especially
 322                 // when that pawn is also blocked.
 323                 if (   pos.is_chess960()
 324                     && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
 325                 {
 326                     Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
 327                     if (pos.piece_on(s + d) == make_piece(Us, PAWN))
 328                         score -= !pos.empty(s + d + pawn_push(Us))                ? CorneredBishop * 4
 329                                 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
 330                                                                                   : CorneredBishop;
 331                 }
 332             }
 333         }
 334
 335         if (Pt == ROOK)
 336         {
 337             // Bonus for rook on the same file as a queen
 338             if (file_bb(s) & pos.pieces(QUEEN))
 339                 score += RookOnQueenFile;
 340
 341             // Bonus for rook on an open or semi-open file
 342             if (pos.is_on_semiopen_file(Us, s))
 343                 score += RookOnFile[pos.is_on_semiopen_file(Them, s)];
 344
 345             // Penalty when trapped by the king, even more if the king cannot castle
 346             else if (mob <= 3)
 347             {
 348                 File kf = file_of(pos.square<KING>(Us));
 349                 if ((kf < FILE_E) == (file_of(s) < kf))
 350                     score -= TrappedRook * (1 + !pos.castling_rights(Us));
 351             }
 352         }
 353
 354         if (Pt == QUEEN)
 355         {
 356             // Penalty if any relative pin or discovered attack against the queen
 357             Bitboard queenPinners;
 358             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
 359                 score -= WeakQueen;
 360         }
 361     }
 362     if (T)
 363         Trace::add(Pt, Us, score);
 364
 365     return score;
 366   }
 367
 368
 369   // Evaluation::king() assigns bonuses and penalties to a king of a given color
 370   template<Tracing T> template<Color Us>
 371   Score Evaluation<T>::king() const {
 372
 373     constexpr Color    Them = (Us == WHITE ? BLACK : WHITE);
 374     constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
 375                                            : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
 376
 377     Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0;
 378     Bitboard rookChecks, queenChecks, bishopChecks, knightChecks;
 379     int kingDanger = 0;
 380     const Square ksq = pos.square<KING>(Us);
 381
 382     // Init the score with king shelter and enemy pawns storm
 383     Score score = pe->king_safety<Us>(pos);
 384
 385     // Attacked squares defended at most once by our queen or king
 386     weak =  attackedBy[Them][ALL_PIECES]
 387           & ~attackedBy2[Us]
 388           & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
 389
 390     // Analyse the safe enemy's checks which are possible on next move
 391     safe  = ~pos.pieces(Them);
 392     safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
 393
 394     b1 = attacks_bb<ROOK  >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
 395     b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
 396
 397     // Enemy rooks checks
 398     rookChecks = b1 & safe & attackedBy[Them][ROOK];
 399
 400     if (rookChecks)
 401         kingDanger += RookSafeCheck;
 402     else
 403         unsafeChecks |= b1 & attackedBy[Them][ROOK];
 404
 405     // Enemy queen safe checks: we count them only if they are from squares from
 406     // which we can't give a rook check, because rook checks are more valuable.
 407     queenChecks =  (b1 | b2)
 408                  & attackedBy[Them][QUEEN]
 409                  & safe
 410                  & ~attackedBy[Us][QUEEN]
 411                  & ~rookChecks;
 412
 413     if (queenChecks)
 414         kingDanger += QueenSafeCheck;
 415
 416     // Enemy bishops checks: we count them only if they are from squares from
 417     // which we can't give a queen check, because queen checks are more valuable.
 418     bishopChecks =  b2
 419                   & attackedBy[Them][BISHOP]
 420                   & safe
 421                   & ~queenChecks;
 422
 423     if (bishopChecks)
 424         kingDanger += BishopSafeCheck;
 425     else
 426         unsafeChecks |= b2 & attackedBy[Them][BISHOP];
 427
 428     // Enemy knights checks
 429     knightChecks = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
 430
 431     if (knightChecks & safe)
 432         kingDanger += KnightSafeCheck;
 433     else
 434         unsafeChecks |= knightChecks;
 435
 436     // Find the squares that opponent attacks in our king flank, the squares
 437     // which they attack twice in that flank, and the squares that we defend.
 438     b1 = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
 439     b2 = b1 & attackedBy2[Them];
 440     b3 = attackedBy[Us][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
 441
 442     int kingFlankAttack = popcount(b1) + popcount(b2);
 443     int kingFlankDefense = popcount(b3);
 444
 445     kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
 446                  + 185 * popcount(kingRing[Us] & weak)
 447                  + 148 * popcount(unsafeChecks)
 448                  +  98 * popcount(pos.blockers_for_king(Us))
 449                  +  69 * kingAttacksCount[Them]
 450                  +   3 * kingFlankAttack * kingFlankAttack / 8
 451                  +       mg_value(mobility[Them] - mobility[Us])
 452                  - 873 * !pos.count<QUEEN>(Them)
 453                  - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
 454                  -   6 * mg_value(score) / 8
 455                  -   4 * kingFlankDefense
 456                  +  37;
 457
 458     // Transform the kingDanger units into a Score, and subtract it from the evaluation
 459     if (kingDanger > 100)
 460         score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
 461
 462     // Penalty when our king is on a pawnless flank
 463     if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
 464         score -= PawnlessFlank;
 465
 466     // Penalty if king flank is under attack, potentially moving toward the king
 467     score -= FlankAttacks * kingFlankAttack;
 468
 469     if (T)
 470         Trace::add(KING, Us, score);
 471
 472     return score;
 473   }
 474
 475
 476   // Evaluation::threats() assigns bonuses according to the types of the
 477   // attacking and the attacked pieces.
 478   template<Tracing T> template<Color Us>
 479   Score Evaluation<T>::threats() const {
 480
 481     constexpr Color     Them     = (Us == WHITE ? BLACK   : WHITE);
 482     constexpr Direction Up       = pawn_push(Us);
 483     constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
 484
 485     Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
 486     Score score = SCORE_ZERO;
 487
 488     // Non-pawn enemies
 489     nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN);
 490
 491     // Squares strongly protected by the enemy, either because they defend the
 492     // square with a pawn, or because they defend the square twice and we don't.
 493     stronglyProtected =  attackedBy[Them][PAWN]
 494                        | (attackedBy2[Them] & ~attackedBy2[Us]);
 495
 496     // Non-pawn enemies, strongly protected
 497     defended = nonPawnEnemies & stronglyProtected;
 498
 499     // Enemies not strongly protected and under our attack
 500     weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
 501
 502     // Bonus according to the kind of attacking pieces
 503     if (defended | weak)
 504     {
 505         b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
 506         while (b)
 507             score += ThreatByMinor[type_of(pos.piece_on(pop_lsb(&b)))];
 508
 509         b = weak & attackedBy[Us][ROOK];
 510         while (b)
 511             score += ThreatByRook[type_of(pos.piece_on(pop_lsb(&b)))];
 512
 513         if (weak & attackedBy[Us][KING])
 514             score += ThreatByKing;
 515
 516         b =  ~attackedBy[Them][ALL_PIECES]
 517            | (nonPawnEnemies & attackedBy2[Us]);
 518         score += Hanging * popcount(weak & b);
 519     }
 520
 521     // Bonus for restricting their piece moves
 522     b =   attackedBy[Them][ALL_PIECES]
 523        & ~stronglyProtected
 524        &  attackedBy[Us][ALL_PIECES];
 525     score += RestrictedPiece * popcount(b);
 526
 527     // Protected or unattacked squares
 528     safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
 529
 530     // Bonus for attacking enemy pieces with our relatively safe pawns
 531     b = pos.pieces(Us, PAWN) & safe;
 532     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
 533     score += ThreatBySafePawn * popcount(b);
 534
 535     // Find squares where our pawns can push on the next move
 536     b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
 537     b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
 538
 539     // Keep only the squares which are relatively safe
 540     b &= ~attackedBy[Them][PAWN] & safe;
 541
 542     // Bonus for safe pawn threats on the next move
 543     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
 544     score += ThreatByPawnPush * popcount(b);
 545
 546     // Bonus for threats on the next moves against enemy queen
 547     if (pos.count<QUEEN>(Them) == 1)
 548     {
 549         Square s = pos.square<QUEEN>(Them);
 550         safe = mobilityArea[Us] & ~stronglyProtected;
 551
 552         b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
 553
 554         score += KnightOnQueen * popcount(b & safe);
 555
 556         b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
 557            | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
 558
 559         score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]);
 560     }
 561
 562     if (T)
 563         Trace::add(THREAT, Us, score);
 564
 565     return score;
 566   }
 567
 568   // Evaluation::passed() evaluates the passed pawns and candidate passed
 569   // pawns of the given color.
 570
 571   template<Tracing T> template<Color Us>
 572   Score Evaluation<T>::passed() const {
 573
 574     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
 575     constexpr Direction Up   = pawn_push(Us);
 576
 577     auto king_proximity = [&](Color c, Square s) {
 578       return std::min(distance(pos.square<KING>(c), s), 5);
 579     };
 580
 581     Bitboard b, bb, squaresToQueen, unsafeSquares;
 582     Score score = SCORE_ZERO;
 583
 584     b = pe->passed_pawns(Us);
 585
 586     while (b)
 587     {
 588         Square s = pop_lsb(&b);
 589
 590         assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
 591
 592         int r = relative_rank(Us, s);
 593
 594         Score bonus = PassedRank[r];
 595
 596         if (r > RANK_3)
 597         {
 598             int w = 5 * r - 13;
 599             Square blockSq = s + Up;
 600
 601             // Adjust bonus based on the king's proximity
 602             bonus += make_score(0, (  (king_proximity(Them, blockSq) * 19) / 4
 603                                      - king_proximity(Us,   blockSq) *  2) * w);
 604
 605             // If blockSq is not the queening square then consider also a second push
 606             if (r != RANK_7)
 607                 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
 608
 609             // If the pawn is free to advance, then increase the bonus
 610             if (pos.empty(blockSq))
 611             {
 612                 squaresToQueen = forward_file_bb(Us, s);
 613                 unsafeSquares = passed_pawn_span(Us, s);
 614
 615                 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
 616
 617                 if (!(pos.pieces(Them) & bb))
 618                     unsafeSquares &= attackedBy[Them][ALL_PIECES];
 619
 620                 // If there are no enemy attacks on passed pawn span, assign a big bonus.
 621                 // Otherwise assign a smaller bonus if the path to queen is not attacked
 622                 // and even smaller bonus if it is attacked but block square is not.
 623                 int k = !unsafeSquares                    ? 35 :
 624                         !(unsafeSquares & squaresToQueen) ? 20 :
 625                         !(unsafeSquares & blockSq)        ?  9 :
 626                                                              0 ;
 627
 628                 // Assign a larger bonus if the block square is defended
 629                 if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
 630                     k += 5;
 631
 632                 bonus += make_score(k * w, k * w);
 633             }
 634         } // r > RANK_3
 635
 636         // Scale down bonus for candidate passers which need more than one
 637         // pawn push to become passed, or have a pawn in front of them.
 638         if (   !pos.pawn_passed(Us, s + Up)
 639             || (pos.pieces(PAWN) & (s + Up)))
 640             bonus = bonus / 2;
 641
 642         score += bonus - PassedFile * map_to_queenside(file_of(s));
 643     }
 644
 645     if (T)
 646         Trace::add(PASSED, Us, score);
 647
 648     return score;
 649   }
 650
 651
 652   // Evaluation::space() computes the space evaluation for a given side. The
 653   // space evaluation is a simple bonus based on the number of safe squares
 654   // available for minor pieces on the central four files on ranks 2--4. Safe
 655   // squares one, two or three squares behind a friendly pawn are counted
 656   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
 657   // improve play on game opening.
 658
 659   template<Tracing T> template<Color Us>
 660   Score Evaluation<T>::space() const {
 661
 662     if (pos.non_pawn_material() < SpaceThreshold)
 663         return SCORE_ZERO;
 664
 665     constexpr Color Them     = (Us == WHITE ? BLACK : WHITE);
 666     constexpr Direction Down = -pawn_push(Us);
 667     constexpr Bitboard SpaceMask =
 668       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
 669                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
 670
 671     // Find the available squares for our pieces inside the area defined by SpaceMask
 672     Bitboard safe =   SpaceMask
 673                    & ~pos.pieces(Us, PAWN)
 674                    & ~attackedBy[Them][PAWN];
 675
 676     // Find all squares which are at most three squares behind some friendly pawn
 677     Bitboard behind = pos.pieces(Us, PAWN);
 678     behind |= shift<Down>(behind);
 679     behind |= shift<Down+Down>(behind);
 680
 681     int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
 682     int weight = pos.count<ALL_PIECES>(Us) - 1;
 683     Score score = make_score(bonus * weight * weight / 16, 0);
 684
 685     if (T)
 686         Trace::add(SPACE, Us, score);
 687
 688     return score;
 689   }
 690
 691
 692   // Evaluation::initiative() computes the initiative correction value
 693   // for the position. It is a second order bonus/malus based on the
 694   // known attacking/defending status of the players.
 695
 696   template<Tracing T>
 697   Score Evaluation<T>::initiative(Score score) const {
 698
 699     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
 700                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
 701
 702     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
 703                             && (pos.pieces(PAWN) & KingSide);
 704
 705     bool almostUnwinnable =   !pe->passed_count()
 706                            &&  outflanking < 0
 707                            && !pawnsOnBothFlanks;
 708
 709     bool infiltration = rank_of(pos.square<KING>(WHITE)) > RANK_4
 710                      || rank_of(pos.square<KING>(BLACK)) < RANK_5;
 711
 712     // Compute the initiative bonus for the attacking side
 713     int complexity =   9 * pe->passed_count()
 714                     + 11 * pos.count<PAWN>()
 715                     +  9 * outflanking
 716                     + 21 * pawnsOnBothFlanks
 717                     + 24 * infiltration
 718                     + 51 * !pos.non_pawn_material()
 719                     - 43 * almostUnwinnable
 720                     -110 ;
 721
 722     Value mg = mg_value(score);
 723     Value eg = eg_value(score);
 724
 725     // Now apply the bonus: note that we find the attacking side by extracting the
 726     // sign of the midgame or endgame values, and that we carefully cap the bonus
 727     // so that the midgame and endgame scores do not change sign after the bonus.
 728     int u = ((mg > 0) - (mg < 0)) * std::max(std::min(complexity + 50, 0), -abs(mg));
 729     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
 730
 731     if (T)
 732         Trace::add(INITIATIVE, make_score(u, v));
 733
 734     return make_score(u, v);
 735   }
 736
 737
 738   // Evaluation::scale_factor() computes the scale factor for the winning side
 739
 740   template<Tracing T>
 741   ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
 742
 743     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
 744     int sf = me->scale_factor(pos, strongSide);
 745
 746     // If scale is not already specific, scale down the endgame via general heuristics
 747     if (sf == SCALE_FACTOR_NORMAL)
 748     {
 749         if (   pos.opposite_bishops()
 750             && pos.non_pawn_material() == 2 * BishopValueMg)
 751             sf = 22 ;
 752         else
 753             sf = std::min(sf, 36 + (pos.opposite_bishops() ? 2 : 7) * pos.count<PAWN>(strongSide));
 754
 755         sf = std::max(0, sf - (pos.rule50_count() - 12) / 4);
 756     }
 757
 758     return ScaleFactor(sf);
 759   }
 760
 761
 762   // Evaluation::value() is the main function of the class. It computes the various
 763   // parts of the evaluation and returns the value of the position from the point
 764   // of view of the side to move.
 765
 766   template<Tracing T>
 767   Value Evaluation<T>::value() {
 768
 769     assert(!pos.checkers());
 770
 771     // Probe the material hash table
 772     me = Material::probe(pos);
 773
 774     // If we have a specialized evaluation function for the current material
 775     // configuration, call it and return.
 776     if (me->specialized_eval_exists())
 777         return me->evaluate(pos);
 778
 779     // Initialize score by reading the incrementally updated scores included in
 780     // the position object (material + piece square tables) and the material
 781     // imbalance. Score is computed internally from the white point of view.
 782     Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
 783
 784     // Probe the pawn hash table
 785     pe = Pawns::probe(pos);
 786     score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
 787
 788     // Early exit if score is high
 789     Value v = (mg_value(score) + eg_value(score)) / 2;
 790     if (abs(v) > LazyThreshold + pos.non_pawn_material() / 64)
 791        return pos.side_to_move() == WHITE ? v : -v;
 792
 793     // Main evaluation begins here
 794
 795     initialize<WHITE>();
 796     initialize<BLACK>();
 797
 798     // Pieces should be evaluated first (populate attack tables)
 799     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
 800             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
 801             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
 802             + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
 803
 804     score += mobility[WHITE] - mobility[BLACK];
 805
 806     score +=  king<   WHITE>() - king<   BLACK>()
 807             + threats<WHITE>() - threats<BLACK>()
 808             + passed< WHITE>() - passed< BLACK>()
 809             + space<  WHITE>() - space<  BLACK>();
 810
 811     score += initiative(score);
 812
 813     // Interpolate between a middlegame and a (scaled by 'sf') endgame score
 814     ScaleFactor sf = scale_factor(eg_value(score));
 815     v =  mg_value(score) * int(me->game_phase())
 816        + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
 817
 818     v /= PHASE_MIDGAME;
 819
 820     // In case of tracing add all remaining individual evaluation terms
 821     if (T)
 822     {
 823         Trace::add(MATERIAL, pos.psq_score());
 824         Trace::add(IMBALANCE, me->imbalance());
 825         Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
 826         Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
 827         Trace::add(TOTAL, score);
 828     }
 829
 830     return  (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view
 831            + Eval::Tempo;
 832   }
 833
 834 } // namespace
 835
 836
 837 /// evaluate() is the evaluator for the outer world. It returns a static
 838 /// evaluation of the position from the point of view of the side to move.
 839
 840 Value Eval::evaluate(const Position& pos) {
 841   return Evaluation<NO_TRACE>(pos).value();
 842 }
 843
 844
 845 /// trace() is like evaluate(), but instead of returning a value, it returns
 846 /// a string (suitable for outputting to stdout) that contains the detailed
 847 /// descriptions and values of each evaluation term. Useful for debugging.
 848
 849 std::string Eval::trace(const Position& pos) {
 850
 851   if (pos.checkers())
 852       return "Total evaluation: none (in check)";
 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 }