git.sesse.net Git - stockfish/blob - src/evaluate.cpp

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