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