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