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