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(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(2, 44), S(36, 71), S(36, 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         // Additional bonus if weak piece is only protected by a queen
 521         score += make_score(14, 0) * popcount(weak & attackedBy[Them][QUEEN]);
 522     }
 523
 524     // Bonus for restricting their piece moves
 525     b =   attackedBy[Them][ALL_PIECES]
 526        & ~stronglyProtected
 527        &  attackedBy[Us][ALL_PIECES];
 528     score += RestrictedPiece * popcount(b);
 529
 530     // Protected or unattacked squares
 531     safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
 532
 533     // Bonus for attacking enemy pieces with our relatively safe pawns
 534     b = pos.pieces(Us, PAWN) & safe;
 535     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
 536     score += ThreatBySafePawn * popcount(b);
 537
 538     // Find squares where our pawns can push on the next move
 539     b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
 540     b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
 541
 542     // Keep only the squares which are relatively safe
 543     b &= ~attackedBy[Them][PAWN] & safe;
 544
 545     // Bonus for safe pawn threats on the next move
 546     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
 547     score += ThreatByPawnPush * popcount(b);
 548
 549     // Bonus for threats on the next moves against enemy queen
 550     if (pos.count<QUEEN>(Them) == 1)
 551     {
 552         Square s = pos.square<QUEEN>(Them);
 553         safe = mobilityArea[Us] & ~stronglyProtected;
 554
 555         b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
 556
 557         score += KnightOnQueen * popcount(b & safe);
 558
 559         b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
 560            | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
 561
 562         score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]);
 563     }
 564
 565     if (T)
 566         Trace::add(THREAT, Us, score);
 567
 568     return score;
 569   }
 570
 571   // Evaluation::passed() evaluates the passed pawns and candidate passed
 572   // pawns of the given color.
 573
 574   template<Tracing T> template<Color Us>
 575   Score Evaluation<T>::passed() const {
 576
 577     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
 578     constexpr Direction Up   = pawn_push(Us);
 579
 580     auto king_proximity = [&](Color c, Square s) {
 581       return std::min(distance(pos.square<KING>(c), s), 5);
 582     };
 583
 584     Bitboard b, bb, squaresToQueen, unsafeSquares;
 585     Score score = SCORE_ZERO;
 586
 587     b = pe->passed_pawns(Us);
 588
 589     while (b)
 590     {
 591         Square s = pop_lsb(&b);
 592
 593         assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
 594
 595         int r = relative_rank(Us, s);
 596
 597         Score bonus = PassedRank[r];
 598
 599         if (r > RANK_3)
 600         {
 601             int w = 5 * r - 13;
 602             Square blockSq = s + Up;
 603
 604             // Adjust bonus based on the king's proximity
 605             bonus += make_score(0, (  (king_proximity(Them, blockSq) * 19) / 4
 606                                      - king_proximity(Us,   blockSq) *  2) * w);
 607
 608             // If blockSq is not the queening square then consider also a second push
 609             if (r != RANK_7)
 610                 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
 611
 612             // If the pawn is free to advance, then increase the bonus
 613             if (pos.empty(blockSq))
 614             {
 615                 squaresToQueen = forward_file_bb(Us, s);
 616                 unsafeSquares = passed_pawn_span(Us, s);
 617
 618                 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
 619
 620                 if (!(pos.pieces(Them) & bb))
 621                     unsafeSquares &= attackedBy[Them][ALL_PIECES];
 622
 623                 // If there are no enemy attacks on passed pawn span, assign a big bonus.
 624                 // Otherwise assign a smaller bonus if the path to queen is not attacked
 625                 // and even smaller bonus if it is attacked but block square is not.
 626                 int k = !unsafeSquares                    ? 35 :
 627                         !(unsafeSquares & squaresToQueen) ? 20 :
 628                         !(unsafeSquares & blockSq)        ?  9 :
 629                                                              0 ;
 630
 631                 // Assign a larger bonus if the block square is defended
 632                 if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
 633                     k += 5;
 634
 635                 bonus += make_score(k * w, k * w);
 636             }
 637         } // r > RANK_3
 638
 639         // Scale down bonus for candidate passers which need more than one
 640         // pawn push to become passed, or have a pawn in front of them.
 641         if (   !pos.pawn_passed(Us, s + Up)
 642             || (pos.pieces(PAWN) & (s + Up)))
 643             bonus = bonus / 2;
 644
 645         score += bonus - PassedFile * map_to_queenside(file_of(s));
 646     }
 647
 648     if (T)
 649         Trace::add(PASSED, Us, score);
 650
 651     return score;
 652   }
 653
 654
 655   // Evaluation::space() computes the space evaluation for a given side. The
 656   // space evaluation is a simple bonus based on the number of safe squares
 657   // available for minor pieces on the central four files on ranks 2--4. Safe
 658   // squares one, two or three squares behind a friendly pawn are counted
 659   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
 660   // improve play on game opening.
 661
 662   template<Tracing T> template<Color Us>
 663   Score Evaluation<T>::space() const {
 664
 665     if (pos.non_pawn_material() < SpaceThreshold)
 666         return SCORE_ZERO;
 667
 668     constexpr Color Them     = (Us == WHITE ? BLACK : WHITE);
 669     constexpr Direction Down = -pawn_push(Us);
 670     constexpr Bitboard SpaceMask =
 671       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
 672                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
 673
 674     // Find the available squares for our pieces inside the area defined by SpaceMask
 675     Bitboard safe =   SpaceMask
 676                    & ~pos.pieces(Us, PAWN)
 677                    & ~attackedBy[Them][PAWN];
 678
 679     // Find all squares which are at most three squares behind some friendly pawn
 680     Bitboard behind = pos.pieces(Us, PAWN);
 681     behind |= shift<Down>(behind);
 682     behind |= shift<Down+Down>(behind);
 683
 684     int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
 685     int weight = pos.count<ALL_PIECES>(Us) - 1;
 686     Score score = make_score(bonus * weight * weight / 16, 0);
 687
 688     if (T)
 689         Trace::add(SPACE, Us, score);
 690
 691     return score;
 692   }
 693
 694
 695   // Evaluation::initiative() computes the initiative correction value
 696   // for the position. It is a second order bonus/malus based on the
 697   // known attacking/defending status of the players.
 698
 699   template<Tracing T>
 700   Score Evaluation<T>::initiative(Score score) const {
 701
 702     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
 703                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
 704
 705     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
 706                             && (pos.pieces(PAWN) & KingSide);
 707
 708     bool almostUnwinnable =   !pe->passed_count()
 709                            &&  outflanking < 0
 710                            && !pawnsOnBothFlanks;
 711
 712     bool infiltration = rank_of(pos.square<KING>(WHITE)) > RANK_4
 713                      || rank_of(pos.square<KING>(BLACK)) < RANK_5;
 714
 715     // Compute the initiative bonus for the attacking side
 716     int complexity =   9 * pe->passed_count()
 717                     + 11 * pos.count<PAWN>()
 718                     +  9 * outflanking
 719                     + 21 * pawnsOnBothFlanks
 720                     + 24 * infiltration
 721                     + 51 * !pos.non_pawn_material()
 722                     - 43 * almostUnwinnable
 723                     -110 ;
 724
 725     Value mg = mg_value(score);
 726     Value eg = eg_value(score);
 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 = 22 ;
 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   if (pos.checkers())
 855       return "Total evaluation: none (in check)";
 856
 857   std::memset(scores, 0, sizeof(scores));
 858
 859   pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
 860
 861   Value v = Evaluation<TRACE>(pos).value();
 862
 863   v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
 864
 865   std::stringstream ss;
 866   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
 867      << "     Term    |    White    |    Black    |    Total   \n"
 868      << "             |   MG    EG  |   MG    EG  |   MG    EG \n"
 869      << " ------------+-------------+-------------+------------\n"
 870      << "    Material | " << Term(MATERIAL)
 871      << "   Imbalance | " << Term(IMBALANCE)
 872      << "       Pawns | " << Term(PAWN)
 873      << "     Knights | " << Term(KNIGHT)
 874      << "     Bishops | " << Term(BISHOP)
 875      << "       Rooks | " << Term(ROOK)
 876      << "      Queens | " << Term(QUEEN)
 877      << "    Mobility | " << Term(MOBILITY)
 878      << " King safety | " << Term(KING)
 879      << "     Threats | " << Term(THREAT)
 880      << "      Passed | " << Term(PASSED)
 881      << "       Space | " << Term(SPACE)
 882      << "  Initiative | " << Term(INITIATIVE)
 883      << " ------------+-------------+-------------+------------\n"
 884      << "       Total | " << Term(TOTAL);
 885
 886   ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";
 887
 888   return ss.str();
 889 }