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