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     // Squares strongly protected by the enemy, either because they defend the
 528     // square with a pawn, or because they defend the square twice and we don't.
 529     stronglyProtected =  attackedBy[Them][PAWN]
 530                        | (attackedBy2[Them] & ~attackedBy2[Us]);
 531
 532     // Non-pawn enemies, strongly protected
 533     defended = nonPawnEnemies & stronglyProtected;
 534
 535     // Enemies not strongly protected and under our attack
 536     weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
 537
 538     // Bonus according to the kind of attacking pieces
 539     if (defended | weak)
 540     {
 541         b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
 542         while (b)
 543         {
 544             Square s = pop_lsb(&b);
 545             score += ThreatByMinor[type_of(pos.piece_on(s))];
 546             if (type_of(pos.piece_on(s)) != PAWN)
 547                 score += ThreatByRank * (int)relative_rank(Them, s);
 548         }
 549
 550         b = (pos.pieces(Them, QUEEN) | weak) & attackedBy[Us][ROOK];
 551         while (b)
 552         {
 553             Square s = pop_lsb(&b);
 554             score += ThreatByRook[type_of(pos.piece_on(s))];
 555             if (type_of(pos.piece_on(s)) != PAWN)
 556                 score += ThreatByRank * (int)relative_rank(Them, s);
 557         }
 558
 559         b = weak & attackedBy[Us][KING];
 560         if (b)
 561             score += ThreatByKing[more_than_one(b)];
 562
 563         score += Hanging * popcount(weak & ~attackedBy[Them][ALL_PIECES]);
 564
 565         // Bonus for overload (non-pawn enemies attacked and defended exactly once)
 566         b =  nonPawnEnemies
 567            & attackedBy[Us][ALL_PIECES]   & ~attackedBy2[Us]
 568            & attackedBy[Them][ALL_PIECES] & ~attackedBy2[Them];
 569         score += Overload * popcount(b);
 570     }
 571
 572     // Bonus for enemy unopposed weak pawns
 573     if (pos.pieces(Us, ROOK, QUEEN))
 574         score += WeakUnopposedPawn * pe->weak_unopposed(Them);
 575
 576     // Our safe or protected pawns
 577     b =   pos.pieces(Us, PAWN)
 578        & (~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES]);
 579
 580     safeThreats = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
 581     score += ThreatBySafePawn * popcount(safeThreats);
 582
 583     // Find squares where our pawns can push on the next move
 584     b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
 585     b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
 586
 587     // Keep only the squares which are not completely unsafe
 588     b &= ~attackedBy[Them][PAWN]
 589         & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
 590
 591     // Bonus for safe pawn threats on the next move
 592     b =   pawn_attacks_bb<Us>(b)
 593        &  pos.pieces(Them)
 594        & ~attackedBy[Us][PAWN];
 595
 596     score += ThreatByPawnPush * popcount(b);
 597
 598     // Bonus for threats on the next moves against enemy queen
 599     if (pos.count<QUEEN>(Them) == 1)
 600     {
 601         Square s = pos.square<QUEEN>(Them);
 602         safeThreats = mobilityArea[Us] & ~stronglyProtected;
 603
 604         b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
 605
 606         score += KnightOnQueen * popcount(b & safeThreats);
 607
 608         b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
 609            | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
 610
 611         score += SliderOnQueen * popcount(b & safeThreats & attackedBy2[Us]);
 612     }
 613
 614     // Connectivity: ensure that knights, bishops, rooks, and queens are protected
 615     b = (pos.pieces(Us) ^ pos.pieces(Us, PAWN, KING)) & attackedBy[Us][ALL_PIECES];
 616     score += Connectivity * 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
 743     // Find all squares which are at most three squares behind some friendly pawn
 744     Bitboard behind = pos.pieces(Us, PAWN);
 745     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
 746     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
 747
 748     int bonus = popcount(safe) + popcount(behind & safe);
 749     int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
 750
 751     Score score = make_score(bonus * weight * weight / 16, 0);
 752
 753     if (T)
 754         Trace::add(SPACE, Us, score);
 755
 756     return score;
 757   }
 758
 759
 760   // Evaluation::initiative() computes the initiative correction value
 761   // for the position. It is a second order bonus/malus based on the
 762   // known attacking/defending status of the players.
 763
 764   template<Tracing T>
 765   Score Evaluation<T>::initiative(Value eg) const {
 766
 767     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
 768                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
 769
 770     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
 771                             && (pos.pieces(PAWN) & KingSide);
 772
 773     // Compute the initiative bonus for the attacking side
 774     int complexity =   8 * outflanking
 775                     +  8 * pe->pawn_asymmetry()
 776                     + 12 * pos.count<PAWN>()
 777                     + 16 * pawnsOnBothFlanks
 778                     + 48 * !pos.non_pawn_material()
 779                     -136 ;
 780
 781     // Now apply the bonus: note that we find the attacking side by extracting
 782     // the sign of the endgame value, and that we carefully cap the bonus so
 783     // that the endgame score will never change sign after the bonus.
 784     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
 785
 786     if (T)
 787         Trace::add(INITIATIVE, make_score(0, v));
 788
 789     return make_score(0, v);
 790   }
 791
 792
 793   // Evaluation::scale_factor() computes the scale factor for the winning side
 794
 795   template<Tracing T>
 796   ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
 797
 798     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
 799     int sf = me->scale_factor(pos, strongSide);
 800
 801     // If we don't already have an unusual scale factor, check for certain
 802     // types of endgames, and use a lower scale for those.
 803     if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
 804     {
 805         if (pos.opposite_bishops())
 806         {
 807             // Endgame with opposite-colored bishops and no other pieces is almost a draw
 808             if (   pos.non_pawn_material(WHITE) == BishopValueMg
 809                 && pos.non_pawn_material(BLACK) == BishopValueMg)
 810                 sf = 31;
 811
 812             // Endgame with opposite-colored bishops, but also other pieces. Still
 813             // a bit drawish, but not as drawish as with only the two bishops.
 814             else
 815                 sf = 46;
 816         }
 817         // Endings where weaker side can place his king in front of the enemy's
 818         // pawns are drawish.
 819         else if (    abs(eg) <= BishopValueEg
 820                  &&  pos.count<PAWN>(strongSide) <= 2
 821                  && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
 822             sf = 37 + 7 * pos.count<PAWN>(strongSide);
 823     }
 824
 825     return ScaleFactor(sf);
 826   }
 827
 828
 829   // Evaluation::value() is the main function of the class. It computes the various
 830   // parts of the evaluation and returns the value of the position from the point
 831   // of view of the side to move.
 832
 833   template<Tracing T>
 834   Value Evaluation<T>::value() {
 835
 836     assert(!pos.checkers());
 837
 838     // Probe the material hash table
 839     me = Material::probe(pos);
 840
 841     // If we have a specialized evaluation function for the current material
 842     // configuration, call it and return.
 843     if (me->specialized_eval_exists())
 844         return me->evaluate(pos);
 845
 846     // Initialize score by reading the incrementally updated scores included in
 847     // the position object (material + piece square tables) and the material
 848     // imbalance. Score is computed internally from the white point of view.
 849     Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
 850
 851     // Probe the pawn hash table
 852     pe = Pawns::probe(pos);
 853     score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
 854
 855     // Early exit if score is high
 856     Value v = (mg_value(score) + eg_value(score)) / 2;
 857     if (abs(v) > LazyThreshold)
 858        return pos.side_to_move() == WHITE ? v : -v;
 859
 860     // Main evaluation begins here
 861
 862     initialize<WHITE>();
 863     initialize<BLACK>();
 864
 865     // Pieces should be evaluated first (populate attack tables)
 866     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
 867             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
 868             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
 869             + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
 870
 871     score += mobility[WHITE] - mobility[BLACK];
 872
 873     score +=  king<   WHITE>() - king<   BLACK>()
 874             + threats<WHITE>() - threats<BLACK>()
 875             + passed< WHITE>() - passed< BLACK>()
 876             + space<  WHITE>() - space<  BLACK>();
 877
 878     score += initiative(eg_value(score));
 879
 880     // Interpolate between a middlegame and a (scaled by 'sf') endgame score
 881     ScaleFactor sf = scale_factor(eg_value(score));
 882     v =  mg_value(score) * int(me->game_phase())
 883        + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
 884
 885     v /= int(PHASE_MIDGAME);
 886
 887     // In case of tracing add all remaining individual evaluation terms
 888     if (T)
 889     {
 890         Trace::add(MATERIAL, pos.psq_score());
 891         Trace::add(IMBALANCE, me->imbalance());
 892         Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
 893         Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
 894         Trace::add(TOTAL, score);
 895     }
 896
 897     return  (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view
 898            + Eval::Tempo;
 899   }
 900
 901 } // namespace
 902
 903
 904 /// evaluate() is the evaluator for the outer world. It returns a static
 905 /// evaluation of the position from the point of view of the side to move.
 906
 907 Value Eval::evaluate(const Position& pos) {
 908   return Evaluation<NO_TRACE>(pos).value();
 909 }
 910
 911
 912 /// trace() is like evaluate(), but instead of returning a value, it returns
 913 /// a string (suitable for outputting to stdout) that contains the detailed
 914 /// descriptions and values of each evaluation term. Useful for debugging.
 915
 916 std::string Eval::trace(const Position& pos) {
 917
 918   std::memset(scores, 0, sizeof(scores));
 919
 920   pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
 921
 922   Value v = Evaluation<TRACE>(pos).value();
 923
 924   v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
 925
 926   std::stringstream ss;
 927   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
 928      << "     Term    |    White    |    Black    |    Total   \n"
 929      << "             |   MG    EG  |   MG    EG  |   MG    EG \n"
 930      << " ------------+-------------+-------------+------------\n"
 931      << "    Material | " << Term(MATERIAL)
 932      << "   Imbalance | " << Term(IMBALANCE)
 933      << "  Initiative | " << Term(INITIATIVE)
 934      << "       Pawns | " << Term(PAWN)
 935      << "     Knights | " << Term(KNIGHT)
 936      << "     Bishops | " << Term(BISHOP)
 937      << "       Rooks | " << Term(ROOK)
 938      << "      Queens | " << Term(QUEEN)
 939      << "    Mobility | " << Term(MOBILITY)
 940      << " King safety | " << Term(KING)
 941      << "     Threats | " << Term(THREAT)
 942      << "      Passed | " << Term(PASSED)
 943      << "       Space | " << Term(SPACE)
 944      << " ------------+-------------+-------------+------------\n"
 945      << "       Total | " << Term(TOTAL);
 946
 947   ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";
 948
 949   return ss.str();
 950 }