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