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