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