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-2009 Marco Costalba
   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
  21 ////
  22 //// Includes
  23 ////
  24
  25 #include <cassert>
  26 #include <cstring>
  27
  28 #include "bitcount.h"
  29 #include "evaluate.h"
  30 #include "material.h"
  31 #include "pawns.h"
  32 #include "scale.h"
  33 #include "thread.h"
  34 #include "ucioption.h"
  35
  36
  37 ////
  38 //// Local definitions
  39 ////
  40
  41 namespace {
  42
  43   const int Sign[2] = { 1, -1 };
  44
  45   // Evaluation grain size, must be a power of 2
  46   const int GrainSize = 4;
  47
  48   // Evaluation weights, initialized from UCI options
  49   int WeightMobilityMidgame, WeightMobilityEndgame;
  50   int WeightPawnStructureMidgame, WeightPawnStructureEndgame;
  51   int WeightPassedPawnsMidgame, WeightPassedPawnsEndgame;
  52   int WeightKingSafety[2];
  53   int WeightSpace;
  54
  55   // Internal evaluation weights. These are applied on top of the evaluation
  56   // weights read from UCI parameters. The purpose is to be able to change
  57   // the evaluation weights while keeping the default values of the UCI
  58   // parameters at 100, which looks prettier.
  59   //
  60   // Values modified by Joona Kiiski
  61   const int WeightMobilityMidgameInternal      = 248;
  62   const int WeightMobilityEndgameInternal      = 271;
  63   const int WeightPawnStructureMidgameInternal = 233;
  64   const int WeightPawnStructureEndgameInternal = 201;
  65   const int WeightPassedPawnsMidgameInternal   = 252;
  66   const int WeightPassedPawnsEndgameInternal   = 259;
  67   const int WeightKingSafetyInternal           = 247;
  68   const int WeightKingOppSafetyInternal        = 259;
  69   const int WeightSpaceInternal                = 46;
  70
  71   // Mobility and outposts bonus modified by Joona Kiiski
  72   //
  73   // Visually better to define tables constants
  74   typedef Value V;
  75
  76   // Knight mobility bonus in middle game and endgame, indexed by the number
  77   // of attacked squares not occupied by friendly piecess.
  78   const Value MidgameKnightMobilityBonus[] = {
  79   //    0       1      2     3      4      5      6      7      8
  80     V(-38), V(-25),V(-12), V(0), V(12), V(25), V(31), V(38), V(38)
  81   };
  82
  83   const Value EndgameKnightMobilityBonus[] = {
  84   //    0       1      2     3      4      5      6      7      8
  85     V(-33), V(-23),V(-13), V(-3), V(7), V(17), V(22), V(27), V(27)
  86   };
  87
  88   // Bishop mobility bonus in middle game and endgame, indexed by the number
  89   // of attacked squares not occupied by friendly pieces. X-ray attacks through
  90   // queens are also included.
  91   const Value MidgameBishopMobilityBonus[] = {
  92   //    0       1      2      3      4      5      6      7
  93     V(-25), V(-11),  V(3), V(17), V(31), V(45), V(57), V(65),
  94   //    8       9     10     11     12     13     14     15
  95     V( 71), V( 74), V(76), V(78), V(79), V(80), V(81), V(81)
  96   };
  97
  98   const Value EndgameBishopMobilityBonus[] = {
  99   //    0       1      2      3      4      5      6      7
 100     V(-30), V(-16), V(-2), V(12), V(26), V(40), V(52), V(60),
 101   //    8       9     10     11     12     13     14     15
 102     V( 65), V( 69), V(71), V(73), V(74), V(75), V(76), V(76)
 103   };
 104
 105   // Rook mobility bonus in middle game and endgame, indexed by the number
 106   // of attacked squares not occupied by friendly pieces. X-ray attacks through
 107   // queens and rooks are also included.
 108   const Value MidgameRookMobilityBonus[] = {
 109   //    0       1      2      3      4      5      6      7
 110     V(-20), V(-14), V(-8), V(-2),  V(4), V(10), V(14), V(19),
 111   //    8       9     10     11     12     13     14     15
 112     V( 23), V( 26), V(27), V(28), V(29), V(30), V(31), V(32)
 113   };
 114
 115   const Value EndgameRookMobilityBonus[] = {
 116   //    0       1      2      3      4      5      6      7
 117     V(-36), V(-19), V(-3), V(13), V(29), V(46), V(62), V(79),
 118   //    8       9     10     11     12     13     14     15
 119     V( 95), V(106),V(111),V(114),V(116),V(117),V(118),V(118)
 120   };
 121
 122   // Queen mobility bonus in middle game and endgame, indexed by the number
 123   // of attacked squares not occupied by friendly pieces.
 124   const Value MidgameQueenMobilityBonus[] = {
 125   //    0      1      2      3      4      5      6      7
 126     V(-10), V(-8), V(-6), V(-3), V(-1), V( 1), V( 3), V( 5),
 127   //    8      9     10     11     12     13     14     15
 128     V(  8), V(10), V(12), V(15), V(16), V(17), V(18), V(20),
 129   //   16     17     18     19     20     21     22     23
 130     V( 20), V(20), V(20), V(20), V(20), V(20), V(20), V(20),
 131   //   24     25     26     27     28     29     30     31
 132     V( 20), V(20), V(20), V(20), V(20), V(20), V(20), V(20)
 133   };
 134
 135   const Value EndgameQueenMobilityBonus[] = {
 136   //    0      1      2      3      4      5      6      7
 137     V(-18),V(-13), V(-7), V(-2), V( 3), V (8), V(13), V(19),
 138   //    8      9     10     11     12     13     14     15
 139     V( 23), V(27), V(32), V(34), V(35), V(35), V(35), V(35),
 140   //   16     17     18     19     20     21     22     23
 141     V( 35), V(35), V(35), V(35), V(35), V(35), V(35), V(35),
 142   //   24     25     26     27     28     29     30     31
 143     V( 35), V(35), V(35), V(35), V(35), V(35), V(35), V(35)
 144   };
 145
 146   // Outpost bonuses for knights and bishops, indexed by square (from white's
 147   // point of view).
 148   const Value KnightOutpostBonus[64] = {
 149   //  A     B     C     D     E     F     G     H
 150     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
 151     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
 152     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0), // 3
 153     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0), // 4
 154     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0), // 5
 155     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0), // 6
 156     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
 157     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
 158   };
 159
 160   const Value BishopOutpostBonus[64] = {
 161   //  A     B     C     D     E     F     G     H
 162     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
 163     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
 164     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), // 3
 165     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), // 4
 166     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0), // 5
 167     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0), // 6
 168     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
 169     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
 170   };
 171
 172   // Bonus for unstoppable passed pawns
 173   const Value UnstoppablePawnValue = Value(0x500);
 174
 175   // Rooks and queens on the 7th rank (modified by Joona Kiiski)
 176   const Value MidgameRookOn7thBonus  = Value(47);
 177   const Value EndgameRookOn7thBonus  = Value(98);
 178   const Value MidgameQueenOn7thBonus = Value(27);
 179   const Value EndgameQueenOn7thBonus = Value(54);
 180
 181   // Rooks on open files (modified by Joona Kiiski)
 182   const Value RookOpenFileBonus = Value(43);
 183   const Value RookHalfOpenFileBonus = Value(19);
 184
 185   // Penalty for rooks trapped inside a friendly king which has lost the
 186   // right to castle.
 187   const Value TrappedRookPenalty = Value(180);
 188
 189   // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
 190   // enemy pawns.
 191   const Value TrappedBishopA7H7Penalty = Value(300);
 192
 193   // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
 194   const Bitboard MaskA7H7[2] = {
 195     ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
 196     ((1ULL << SQ_A2) | (1ULL << SQ_H2))
 197   };
 198
 199   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
 200   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
 201   // happen in Chess960 games.
 202   const Value TrappedBishopA1H1Penalty = Value(100);
 203
 204   // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
 205   const Bitboard MaskA1H1[2] = {
 206     ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
 207     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
 208   };
 209
 210   // The SpaceMask[color] contains area of the board which is consdered by
 211   // the space evaluation. In the middle game, each side is given a bonus
 212   // based on how many squares inside this area are safe and available for
 213   // friendly minor pieces.
 214   const Bitboard SpaceMask[2] = {
 215     (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
 216     (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
 217     (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
 218     (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
 219     (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
 220     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
 221   };
 222
 223   /// King safety constants and variables. The king safety scores are taken
 224   /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
 225   /// the strength of the attack are added up into an integer, which is used
 226   /// as an index to SafetyTable[].
 227
 228   // Attack weights for each piece type
 229   const int QueenAttackWeight  = 5;
 230   const int RookAttackWeight   = 3;
 231   const int BishopAttackWeight = 2;
 232   const int KnightAttackWeight = 2;
 233
 234   // Bonuses for safe checks, initialized from UCI options
 235   int QueenContactCheckBonus, DiscoveredCheckBonus;
 236   int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
 237
 238   // Scan for queen contact mates?
 239   const bool QueenContactMates = true;
 240
 241   // Bonus for having a mate threat, initialized from UCI options
 242   int MateThreatBonus;
 243
 244   // InitKingDanger[] contains bonuses based on the position of the defending
 245   // king.
 246   const int InitKingDanger[64] = {
 247      2,  0,  2,  5,  5,  2,  0,  2,
 248      2,  2,  4,  8,  8,  4,  2,  2,
 249      7, 10, 12, 12, 12, 12, 10,  7,
 250     15, 15, 15, 15, 15, 15, 15, 15,
 251     15, 15, 15, 15, 15, 15, 15, 15,
 252     15, 15, 15, 15, 15, 15, 15, 15,
 253     15, 15, 15, 15, 15, 15, 15, 15,
 254     15, 15, 15, 15, 15, 15, 15, 15
 255   };
 256
 257   // SafetyTable[] contains the actual king safety scores. It is initialized
 258   // in init_safety().
 259   Value SafetyTable[100];
 260
 261   // Pawn and material hash tables, indexed by the current thread id
 262   PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 263   MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 264
 265   // Sizes of pawn and material hash tables
 266   const int PawnTableSize = 16384;
 267   const int MaterialTableSize = 1024;
 268
 269   // Array which gives the number of nonzero bits in an 8-bit integer
 270   uint8_t BitCount8Bit[256];
 271
 272   // Function prototypes
 273   template<bool HasPopCnt>
 274   Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
 275
 276   template<PieceType Piece, bool HasPopCnt>
 277   void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
 278
 279   template<bool HasPopCnt>
 280   void evaluate_king(const Position& p, Color us, EvalInfo &ei);
 281
 282   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
 283   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
 284                                     EvalInfo &ei);
 285   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
 286                                     EvalInfo &ei);
 287   template<bool HasPopCnt>
 288   void evaluate_space(const Position &p, Color us, EvalInfo &ei);
 289   inline Value apply_weight(Value v, int w);
 290   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 291
 292   int compute_weight(int uciWeight, int internalWeight);
 293   int weight_option(const std::string& opt, int weight);
 294   void init_safety();
 295
 296 }
 297
 298
 299 ////
 300 //// Functions
 301 ////
 302
 303 /// evaluate() is the main evaluation function. It always computes two
 304 /// values, an endgame score and a middle game score, and interpolates
 305 /// between them based on the remaining material.
 306 Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
 307
 308     return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
 309                         : do_evaluate<false>(pos, ei, threadID);
 310 }
 311
 312 namespace {
 313
 314 template<bool HasPopCnt>
 315 Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
 316
 317   assert(pos.is_ok());
 318   assert(threadID >= 0 && threadID < THREAD_MAX);
 319
 320   memset(&ei, 0, sizeof(EvalInfo));
 321
 322   // Initialize by reading the incrementally updated scores included in the
 323   // position object (material + piece square tables)
 324   ei.mgValue = pos.mg_value();
 325   ei.egValue = pos.eg_value();
 326
 327   // Probe the material hash table
 328   ei.mi = MaterialTable[threadID]->get_material_info(pos);
 329   ei.mgValue += ei.mi->material_value();
 330   ei.egValue += ei.mi->material_value();
 331
 332   // If we have a specialized evaluation function for the current material
 333   // configuration, call it and return
 334   if (ei.mi->specialized_eval_exists())
 335       return ei.mi->evaluate(pos);
 336
 337   // After get_material_info() call that modifies them
 338   ScaleFactor factor[2];
 339   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
 340   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
 341
 342   // Probe the pawn hash table
 343   ei.pi = PawnTable[threadID]->get_pawn_info(pos);
 344   ei.mgValue += apply_weight(ei.pi->mg_value(), WeightPawnStructureMidgame);
 345   ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
 346
 347   // Initialize king attack bitboards and king attack zones for both sides
 348   ei.attackedBy[WHITE][KING] = pos.piece_attacks<KING>(pos.king_square(WHITE));
 349   ei.attackedBy[BLACK][KING] = pos.piece_attacks<KING>(pos.king_square(BLACK));
 350   ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
 351   ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
 352
 353   // Initialize pawn attack bitboards for both sides
 354   ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
 355   ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
 356   Bitboard b1 = ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING];
 357   Bitboard b2 = ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING];
 358   if (b1)
 359       ei.kingAttackersCount[WHITE] = count_1s_max_15<HasPopCnt>(b1)/2;
 360
 361   if (b2)
 362       ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(b2)/2;
 363
 364   // Evaluate pieces
 365   for (Color c = WHITE; c <= BLACK; c++)
 366   {
 367       evaluate_pieces<KNIGHT, HasPopCnt>(pos, c, ei);
 368       evaluate_pieces<BISHOP, HasPopCnt>(pos, c, ei);
 369       evaluate_pieces<ROOK,   HasPopCnt>(pos, c, ei);
 370       evaluate_pieces<QUEEN,  HasPopCnt>(pos, c, ei);
 371
 372       // Sum up all attacked squares
 373       ei.attackedBy[c][0] =   ei.attackedBy[c][PAWN]   | ei.attackedBy[c][KNIGHT]
 374                             | ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
 375                             | ei.attackedBy[c][QUEEN]  | ei.attackedBy[c][KING];
 376   }
 377
 378   // Kings. Kings are evaluated after all other pieces for both sides,
 379   // because we need complete attack information for all pieces when computing
 380   // the king safety evaluation.
 381   for (Color c = WHITE; c <= BLACK; c++)
 382       evaluate_king<HasPopCnt>(pos, c, ei);
 383
 384   // Evaluate passed pawns.  We evaluate passed pawns for both sides at once,
 385   // because we need to know which side promotes first in positions where
 386   // both sides have an unstoppable passed pawn.
 387   if (ei.pi->passed_pawns())
 388       evaluate_passed_pawns(pos, ei);
 389
 390   Phase phase = pos.game_phase();
 391
 392   // Middle-game specific evaluation terms
 393   if (phase > PHASE_ENDGAME)
 394   {
 395     // Pawn storms in positions with opposite castling.
 396     if (   square_file(pos.king_square(WHITE)) >= FILE_E
 397         && square_file(pos.king_square(BLACK)) <= FILE_D)
 398
 399         ei.mgValue += ei.pi->queenside_storm_value(WHITE)
 400                     - ei.pi->kingside_storm_value(BLACK);
 401
 402     else if (   square_file(pos.king_square(WHITE)) <= FILE_D
 403              && square_file(pos.king_square(BLACK)) >= FILE_E)
 404
 405         ei.mgValue += ei.pi->kingside_storm_value(WHITE)
 406                     - ei.pi->queenside_storm_value(BLACK);
 407
 408     // Evaluate space for both sides
 409     if (ei.mi->space_weight() > 0)
 410     {
 411         evaluate_space<HasPopCnt>(pos, WHITE, ei);
 412         evaluate_space<HasPopCnt>(pos, BLACK, ei);
 413     }
 414   }
 415
 416   // Mobility
 417   ei.mgValue += apply_weight(ei.mgMobility, WeightMobilityMidgame);
 418   ei.egValue += apply_weight(ei.egMobility, WeightMobilityEndgame);
 419
 420   // If we don't already have an unusual scale factor, check for opposite
 421   // colored bishop endgames, and use a lower scale for those
 422   if (   phase < PHASE_MIDGAME
 423       && pos.opposite_colored_bishops()
 424       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
 425           || (factor[BLACK] == SCALE_FACTOR_NORMAL && ei.egValue < Value(0))))
 426   {
 427       ScaleFactor sf;
 428
 429       // Only the two bishops ?
 430       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
 431           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
 432       {
 433           // Check for KBP vs KB with only a single pawn that is almost
 434           // certainly a draw or at least two pawns.
 435           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
 436           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
 437       }
 438       else
 439           // Endgame with opposite-colored bishops, but also other pieces. Still
 440           // a bit drawish, but not as drawish as with only the two bishops.
 441            sf = ScaleFactor(50);
 442
 443       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
 444           factor[WHITE] = sf;
 445       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
 446           factor[BLACK] = sf;
 447   }
 448
 449   // Interpolate between the middle game and the endgame score, and
 450   // return
 451   Color stm = pos.side_to_move();
 452
 453   Value v = Sign[stm] * scale_by_game_phase(ei.mgValue, ei.egValue, phase, factor);
 454
 455   return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
 456 }
 457
 458 } // namespace
 459
 460 /// quick_evaluate() does a very approximate evaluation of the current position.
 461 /// It currently considers only material and piece square table scores.  Perhaps
 462 /// we should add scores from the pawn and material hash tables?
 463
 464 Value quick_evaluate(const Position &pos) {
 465
 466   assert(pos.is_ok());
 467
 468   static const
 469   ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
 470
 471   Value mgv = pos.mg_value();
 472   Value egv = pos.eg_value();
 473   Phase ph = pos.game_phase();
 474   Color stm = pos.side_to_move();
 475
 476   return Sign[stm] * scale_by_game_phase(mgv, egv, ph, sf);
 477 }
 478
 479
 480 /// init_eval() initializes various tables used by the evaluation function.
 481
 482 void init_eval(int threads) {
 483
 484   assert(threads <= THREAD_MAX);
 485
 486   for (int i = 0; i < THREAD_MAX; i++)
 487   {
 488     if (i >= threads)
 489     {
 490         delete PawnTable[i];
 491         delete MaterialTable[i];
 492         PawnTable[i] = NULL;
 493         MaterialTable[i] = NULL;
 494         continue;
 495     }
 496     if (!PawnTable[i])
 497         PawnTable[i] = new PawnInfoTable(PawnTableSize);
 498     if (!MaterialTable[i])
 499         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
 500   }
 501
 502   for (Bitboard b = 0ULL; b < 256ULL; b++)
 503   {
 504       assert(count_1s(b) == int(uint8_t(count_1s(b))));
 505       BitCount8Bit[b] = (uint8_t)count_1s(b);
 506   }
 507 }
 508
 509
 510 /// quit_eval() releases heap-allocated memory at program termination.
 511
 512 void quit_eval() {
 513
 514   for (int i = 0; i < THREAD_MAX; i++)
 515   {
 516       delete PawnTable[i];
 517       delete MaterialTable[i];
 518       PawnTable[i] = NULL;
 519       MaterialTable[i] = NULL;
 520   }
 521 }
 522
 523
 524 /// read_weights() reads evaluation weights from the corresponding UCI
 525 /// parameters.
 526
 527 void read_weights(Color us) {
 528
 529   WeightMobilityMidgame      = weight_option("Mobility (Middle Game)", WeightMobilityMidgameInternal);
 530   WeightMobilityEndgame      = weight_option("Mobility (Endgame)", WeightMobilityEndgameInternal);
 531   WeightPawnStructureMidgame = weight_option("Pawn Structure (Middle Game)", WeightPawnStructureMidgameInternal);
 532   WeightPawnStructureEndgame = weight_option("Pawn Structure (Endgame)", WeightPawnStructureEndgameInternal);
 533   WeightPassedPawnsMidgame   = weight_option("Passed Pawns (Middle Game)", WeightPassedPawnsMidgameInternal);
 534   WeightPassedPawnsEndgame   = weight_option("Passed Pawns (Endgame)", WeightPassedPawnsEndgameInternal);
 535
 536   Color them = opposite_color(us);
 537
 538   WeightKingSafety[us]   = weight_option("Cowardice", WeightKingSafetyInternal);
 539   WeightKingSafety[them] = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
 540   // If running in analysis mode, make sure we use symmetrical king safety.
 541   // We do this by replacing both WeightKingSafety[us] and
 542   // WeightKingSafety[them] by their average.
 543   if (get_option_value_bool("UCI_AnalyseMode")) {
 544       WeightKingSafety[us] = (WeightKingSafety[us] + WeightKingSafety[them]) / 2;
 545       WeightKingSafety[them] = WeightKingSafety[us];
 546   }
 547
 548   WeightSpace = weight_option("Space", WeightSpaceInternal);
 549
 550   init_safety();
 551 }
 552
 553
 554 namespace {
 555
 556   // evaluate_mobility() computes mobility and attacks for every piece
 557
 558   template<PieceType Piece, bool HasPopCnt>
 559   int evaluate_mobility(const Position& p, const Bitboard& b, Color us, Color them, EvalInfo& ei) {
 560
 561     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
 562     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
 563     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
 564
 565     // Update attack info
 566     ei.attackedBy[us][Piece] |= b;
 567
 568     // King attacks
 569     if (b & ei.kingZone[us])
 570     {
 571         ei.kingAttackersCount[us]++;
 572         ei.kingAttackersWeight[us] += AttackWeight[Piece];
 573         Bitboard bb = (b & ei.attackedBy[them][KING]);
 574         if (bb)
 575             ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<HasPopCnt>(bb);
 576     }
 577
 578     // Remove squares protected by enemy pawns
 579     Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
 580
 581     // Mobility
 582     int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(bb & ~p.pieces_of_color(us))
 583                               : count_1s<HasPopCnt>(bb & ~p.pieces_of_color(us)));
 584
 585     ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
 586     ei.egMobility += Sign[us] * EgBonus[Piece][mob];
 587     return mob;
 588   }
 589
 590
 591   // evaluate_outposts() evaluates bishop and knight outposts squares
 592
 593   template<PieceType Piece>
 594   void evaluate_outposts(const Position& p, Color us, Color them, EvalInfo& ei, Square s) {
 595
 596     // Initial bonus based on square
 597     Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(us, s)]
 598                                    : KnightOutpostBonus[relative_square(us, s)]);
 599
 600     // Increase bonus if supported by pawn, especially if the opponent has
 601     // no minor piece which can exchange the outpost piece
 602     if (bonus && (p.pawn_attacks(them, s) & p.pawns(us)))
 603     {
 604         if (    p.knights(them) == EmptyBoardBB
 605             && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
 606             bonus += bonus + bonus / 2;
 607         else
 608             bonus += bonus / 2;
 609     }
 610     ei.mgValue += Sign[us] * bonus;
 611     ei.egValue += Sign[us] * bonus;
 612   }
 613
 614
 615   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
 616   // color.
 617
 618   template<PieceType Piece, bool HasPopCnt>
 619   void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
 620
 621     Bitboard b;
 622     Square s, ksq;
 623     int mob;
 624     File f;
 625     Color them = opposite_color(us);
 626
 627     for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
 628     {
 629         s = pos.piece_list(us, Piece, i);
 630
 631         if (Piece == KNIGHT || Piece == QUEEN)
 632             b = pos.piece_attacks<Piece>(s);
 633         else if (Piece == BISHOP)
 634             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.queens(us));
 635         else if (Piece == ROOK)
 636             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
 637         else
 638             assert(false);
 639
 640         // Attacks and mobility
 641         mob = evaluate_mobility<Piece, HasPopCnt>(pos, b, us, them, ei);
 642
 643         // Bishop and knight outposts squares
 644         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, them))
 645             evaluate_outposts<Piece>(pos, us, them, ei, s);
 646
 647         // Special patterns: trapped bishops on a7/h7/a2/h2
 648         // and trapped bishops on a1/h1/a8/h8 in Chess960.
 649         if (Piece == BISHOP)
 650         {
 651             if (bit_is_set(MaskA7H7[us], s))
 652                 evaluate_trapped_bishop_a7h7(pos, s, us, ei);
 653
 654             if (Chess960 && bit_is_set(MaskA1H1[us], s))
 655                 evaluate_trapped_bishop_a1h1(pos, s, us, ei);
 656         }
 657
 658         if (Piece == ROOK || Piece == QUEEN)
 659         {
 660             // Queen or rook on 7th rank
 661             if (   relative_rank(us, s) == RANK_7
 662                 && relative_rank(us, pos.king_square(them)) == RANK_8)
 663             {
 664                 ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
 665                 ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
 666             }
 667         }
 668
 669         // Special extra evaluation for rooks
 670         if (Piece == ROOK)
 671         {
 672             // Open and half-open files
 673             f = square_file(s);
 674             if (ei.pi->file_is_half_open(us, f))
 675             {
 676                 if (ei.pi->file_is_half_open(them, f))
 677                 {
 678                     ei.mgValue += Sign[us] * RookOpenFileBonus;
 679                     ei.egValue += Sign[us] * RookOpenFileBonus;
 680                 }
 681                 else
 682                 {
 683                     ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
 684                     ei.egValue += Sign[us] * RookHalfOpenFileBonus;
 685                 }
 686             }
 687
 688             // Penalize rooks which are trapped inside a king. Penalize more if
 689             // king has lost right to castle.
 690             if (mob > 6 || ei.pi->file_is_half_open(us, f))
 691                 continue;
 692
 693             ksq = pos.king_square(us);
 694
 695             if (    square_file(ksq) >= FILE_E
 696                 &&  square_file(s) > square_file(ksq)
 697                 && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 698             {
 699                 // Is there a half-open file between the king and the edge of the board?
 700                 if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
 701                     ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
 702                                                     : Sign[us] *  (TrappedRookPenalty - mob * 16);
 703             }
 704             else if (    square_file(ksq) <= FILE_D
 705                     &&  square_file(s) < square_file(ksq)
 706                     && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 707             {
 708                 // Is there a half-open file between the king and the edge of the board?
 709                 if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
 710                     ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
 711                                                     : Sign[us] * (TrappedRookPenalty - mob * 16);
 712             }
 713         }
 714     }
 715   }
 716
 717   inline Bitboard shiftRowsDown(const Bitboard& b, int num) {
 718
 719     return b >> (num << 3);
 720   }
 721
 722   // evaluate_king<>() assigns bonuses and penalties to a king of a given color.
 723
 724   template<bool HasPopCnt>
 725   void evaluate_king(const Position& p, Color us, EvalInfo& ei) {
 726
 727     int shelter = 0, sign = Sign[us];
 728     Square s = p.king_square(us);
 729
 730     // King shelter
 731     if (relative_rank(us, s) <= RANK_4)
 732     {
 733         // Shelter cache lookup
 734         shelter = ei.pi->kingShelter(us, s);
 735         if (shelter == -1)
 736         {
 737             shelter = 0;
 738             Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
 739             Rank r = square_rank(s);
 740             for (int i = 1; i < 4; i++)
 741                 shelter += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
 742
 743             // Cache shelter value in pawn info
 744             ei.pi->setKingShelter(us, s, shelter);
 745         }
 746         ei.mgValue += sign * Value(shelter);
 747     }
 748
 749     // King safety. This is quite complicated, and is almost certainly far
 750     // from optimally tuned.
 751     Color them = opposite_color(us);
 752
 753     if (   p.piece_count(them, QUEEN) >= 1
 754         && ei.kingAttackersCount[them] >= 2
 755         && p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
 756         && ei.kingAdjacentZoneAttacksCount[them])
 757     {
 758       // Is it the attackers turn to move?
 759       bool sente = (them == p.side_to_move());
 760
 761       // Find the attacked squares around the king which has no defenders
 762       // apart from the king itself
 763       Bitboard undefended =
 764              ei.attacked_by(them)       & ~ei.attacked_by(us, PAWN)
 765           & ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP)
 766           & ~ei.attacked_by(us, ROOK)   & ~ei.attacked_by(us, QUEEN)
 767           & ei.attacked_by(us, KING);
 768
 769       Bitboard occ = p.occupied_squares(), b, b2;
 770
 771       // Initialize the 'attackUnits' variable, which is used later on as an
 772       // index to the SafetyTable[] array.  The initial value is based on the
 773       // number and types of the attacking pieces, the number of attacked and
 774       // undefended squares around the king, the square of the king, and the
 775       // quality of the pawn shelter.
 776       int attackUnits =
 777             Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
 778           + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
 779           + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
 780
 781       // Analyse safe queen contact checks
 782       b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them);
 783       if (b)
 784       {
 785         Bitboard attackedByOthers =
 786               ei.attacked_by(them, PAWN)   | ei.attacked_by(them, KNIGHT)
 787             | ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK);
 788
 789         b &= attackedByOthers;
 790         if (b)
 791         {
 792           // The bitboard b now contains the squares available for safe queen
 793           // contact checks.
 794           int count = count_1s_max_15<HasPopCnt>(b);
 795           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
 796
 797           // Is there a mate threat?
 798           if (QueenContactMates && !p.is_check())
 799           {
 800             Bitboard escapeSquares =
 801                 p.piece_attacks<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
 802
 803             while (b)
 804             {
 805                 Square from, to = pop_1st_bit(&b);
 806                 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
 807                 {
 808                     // We have a mate, unless the queen is pinned or there
 809                     // is an X-ray attack through the queen.
 810                     for (int i = 0; i < p.piece_count(them, QUEEN); i++)
 811                     {
 812                         from = p.piece_list(them, QUEEN, i);
 813                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
 814                             && !bit_is_set(p.pinned_pieces(them), from)
 815                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
 816                             && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.bishops_and_queens(us)))
 817
 818                             ei.mateThreat[them] = make_move(from, to);
 819                     }
 820                 }
 821             }
 822           }
 823         }
 824       }
 825
 826       // Analyse safe distance checks
 827       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
 828       {
 829           b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 830
 831           // Queen checks
 832           b2 = b & ei.attacked_by(them, QUEEN);
 833           if( b2)
 834               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 835
 836           // Rook checks
 837           b2 = b & ei.attacked_by(them, ROOK);
 838           if (b2)
 839               attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 840       }
 841       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
 842       {
 843           b = p.piece_attacks<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 844
 845           // Queen checks
 846           b2 = b & ei.attacked_by(them, QUEEN);
 847           if (b2)
 848               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 849
 850           // Bishop checks
 851           b2 = b & ei.attacked_by(them, BISHOP);
 852           if (b2)
 853               attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 854       }
 855       if (KnightCheckBonus > 0)
 856       {
 857           b = p.piece_attacks<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 858
 859           // Knight checks
 860           b2 = b & ei.attacked_by(them, KNIGHT);
 861           if (b2)
 862               attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 863       }
 864
 865       // Analyse discovered checks (only for non-pawns right now, consider
 866       // adding pawns later).
 867       if (DiscoveredCheckBonus)
 868       {
 869         b = p.discovered_check_candidates(them) & ~p.pawns();
 870         if (b)
 871           attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente? 2 : 1);
 872       }
 873
 874       // Has a mate threat been found?  We don't do anything here if the
 875       // side with the mating move is the side to move, because in that
 876       // case the mating side will get a huge bonus at the end of the main
 877       // evaluation function instead.
 878       if (ei.mateThreat[them] != MOVE_NONE)
 879           attackUnits += MateThreatBonus;
 880
 881       // Ensure that attackUnits is between 0 and 99, in order to avoid array
 882       // out of bounds errors:
 883       if (attackUnits < 0)
 884           attackUnits = 0;
 885
 886       if (attackUnits >= 100)
 887           attackUnits = 99;
 888
 889       // Finally, extract the king safety score from the SafetyTable[] array.
 890       // Add the score to the evaluation, and also to ei.futilityMargin.  The
 891       // reason for adding the king safety score to the futility margin is
 892       // that the king safety scores can sometimes be very big, and that
 893       // capturing a single attacking piece can therefore result in a score
 894       // change far bigger than the value of the captured piece.
 895       Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]);
 896
 897       ei.mgValue -= sign * v;
 898
 899       if (us == p.side_to_move())
 900           ei.futilityMargin += v;
 901     }
 902   }
 903
 904
 905   // evaluate_passed_pawns() evaluates the passed pawns for both sides.
 906
 907   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei) {
 908
 909     bool hasUnstoppable[2] = {false, false};
 910     int movesToGo[2] = {100, 100};
 911
 912     for (Color us = WHITE; us <= BLACK; us++)
 913     {
 914         Color them = opposite_color(us);
 915         Square ourKingSq = pos.king_square(us);
 916         Square theirKingSq = pos.king_square(them);
 917         Bitboard b = ei.pi->passed_pawns() & pos.pawns(us), b2, b3, b4;
 918
 919         while (b)
 920         {
 921             Square s = pop_1st_bit(&b);
 922
 923             assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
 924             assert(pos.pawn_is_passed(us, s));
 925
 926             int r = int(relative_rank(us, s) - RANK_2);
 927             int tr = Max(0, r * (r - 1));
 928             Square blockSq = s + pawn_push(us);
 929
 930             // Base bonus based on rank
 931             Value mbonus = Value(20 * tr);
 932             Value ebonus = Value(10 + r * r * 10);
 933
 934             // Adjust bonus based on king proximity
 935             if (tr != 0)
 936             {
 937                 ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
 938                 ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
 939                 ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
 940
 941                 // If the pawn is free to advance, increase bonus
 942                 if (pos.square_is_empty(blockSq))
 943                 {
 944                     b2 = squares_in_front_of(us, s);
 945                     b3 = b2 & ei.attacked_by(them);
 946                     b4 = b2 & ei.attacked_by(us);
 947
 948                     // If there is an enemy rook or queen attacking the pawn from behind,
 949                     // add all X-ray attacks by the rook or queen.
 950                     if (    bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
 951                         && (squares_behind(us, s) & pos.rooks_and_queens(them)))
 952                         b3 = b2;
 953
 954                     // Squares attacked or occupied by enemy pieces
 955                     b3 |= (b2 & pos.pieces_of_color(them));
 956
 957                     // There are no enemy pawns in the pawn's path
 958                     assert((b2 & pos.pieces_of_color_and_type(them, PAWN)) == EmptyBoardBB);
 959
 960                     // Are any of the squares in the pawn's path attacked or occupied by the enemy?
 961                     if (b3 == EmptyBoardBB)
 962                         // No enemy attacks or pieces, huge bonus!
 963                         ebonus += Value(tr * (b2 == b4 ? 17 : 15));
 964                     else
 965                         // OK, there are enemy attacks or pieces (but not pawns). Are those
 966                         // squares which are attacked by the enemy also attacked by us?
 967                         // If yes, big bonus (but smaller than when there are no enemy attacks),
 968                         // if no, somewhat smaller bonus.
 969                         ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
 970
 971                     // At last, add a small bonus when there are no *friendly* pieces
 972                     // in the pawn's path.
 973                     if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
 974                         ebonus += Value(tr);
 975                 }
 976             }
 977
 978             // If the pawn is supported by a friendly pawn, increase bonus
 979             b2 = pos.pawns(us) & neighboring_files_bb(s);
 980             if (b2 & rank_bb(s))
 981                 ebonus += Value(r * 20);
 982             else if (pos.pawn_attacks(them, s) & b2)
 983                 ebonus += Value(r * 12);
 984
 985             // If the other side has only a king, check whether the pawn is
 986             // unstoppable
 987             if (pos.non_pawn_material(them) == Value(0))
 988             {
 989                 Square qsq;
 990                 int d;
 991
 992                 qsq = relative_square(us, make_square(square_file(s), RANK_8));
 993                 d =  square_distance(s, qsq)
 994                    - square_distance(theirKingSq, qsq)
 995                    + (us != pos.side_to_move());
 996
 997                 if (d < 0)
 998                 {
 999                     int mtg = RANK_8 - relative_rank(us, s);
1000                     int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
1001                     mtg += blockerCount;
1002                     d += blockerCount;
1003                     if (d < 0)
1004                     {
1005                         hasUnstoppable[us] = true;
1006                         movesToGo[us] = Min(movesToGo[us], mtg);
1007                     }
1008                 }
1009             }
1010             // Rook pawns are a special case: They are sometimes worse, and
1011             // sometimes better than other passed pawns. It is difficult to find
1012             // good rules for determining whether they are good or bad. For now,
1013             // we try the following: Increase the value for rook pawns if the
1014             // other side has no pieces apart from a knight, and decrease the
1015             // value if the other side has a rook or queen.
1016             if (square_file(s) == FILE_A || square_file(s) == FILE_H)
1017             {
1018                 if (   pos.non_pawn_material(them) <= KnightValueMidgame
1019                     && pos.piece_count(them, KNIGHT) <= 1)
1020                     ebonus += ebonus / 4;
1021                 else if (pos.rooks_and_queens(them))
1022                     ebonus -= ebonus / 4;
1023             }
1024
1025             // Add the scores for this pawn to the middle game and endgame eval.
1026             ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
1027             ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
1028         }
1029     }
1030
1031     // Does either side have an unstoppable passed pawn?
1032     if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
1033         ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
1034     else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
1035         ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
1036     else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
1037     {
1038         // Both sides have unstoppable pawns! Try to find out who queens
1039         // first. We begin by transforming 'movesToGo' to the number of
1040         // plies until the pawn queens for both sides.
1041         movesToGo[WHITE] *= 2;
1042         movesToGo[BLACK] *= 2;
1043         movesToGo[pos.side_to_move()]--;
1044
1045         // If one side queens at least three plies before the other, that
1046         // side wins.
1047         if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
1048             ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
1049         else if(movesToGo[BLACK] <= movesToGo[WHITE] - 3)
1050             ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));
1051
1052         // We could also add some rules about the situation when one side
1053         // queens exactly one ply before the other: Does the first queen
1054         // check the opponent's king, or attack the opponent's queening square?
1055         // This is slightly tricky to get right, because it is possible that
1056         // the opponent's king has moved somewhere before the first pawn queens.
1057     }
1058   }
1059
1060
1061   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1062   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1063   // if it is.
1064
1065   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
1066                                     EvalInfo &ei) {
1067     assert(square_is_ok(s));
1068     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1069
1070     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1071     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1072
1073     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1074         && pos.see(s, b6) < 0
1075         && pos.see(s, b8) < 0)
1076     {
1077         ei.mgValue -= Sign[us] * TrappedBishopA7H7Penalty;
1078         ei.egValue -= Sign[us] * TrappedBishopA7H7Penalty;
1079     }
1080   }
1081
1082
1083   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1084   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1085   // black), and assigns a penalty if it is.  This pattern can obviously
1086   // only occur in Chess960 games.
1087
1088   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
1089                                     EvalInfo &ei) {
1090     Piece pawn = piece_of_color_and_type(us, PAWN);
1091     Square b2, b3, c3;
1092
1093     assert(Chess960);
1094     assert(square_is_ok(s));
1095     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1096
1097     if (square_file(s) == FILE_A)
1098     {
1099         b2 = relative_square(us, SQ_B2);
1100         b3 = relative_square(us, SQ_B3);
1101         c3 = relative_square(us, SQ_C3);
1102     }
1103     else
1104     {
1105         b2 = relative_square(us, SQ_G2);
1106         b3 = relative_square(us, SQ_G3);
1107         c3 = relative_square(us, SQ_F3);
1108     }
1109
1110     if (pos.piece_on(b2) == pawn)
1111     {
1112         Value penalty;
1113
1114         if (!pos.square_is_empty(b3))
1115             penalty = 2*TrappedBishopA1H1Penalty;
1116         else if (pos.piece_on(c3) == pawn)
1117             penalty = TrappedBishopA1H1Penalty;
1118         else
1119             penalty = TrappedBishopA1H1Penalty / 2;
1120
1121         ei.mgValue -= Sign[us] * penalty;
1122         ei.egValue -= Sign[us] * penalty;
1123     }
1124   }
1125
1126
1127   // evaluate_space() computes the space evaluation for a given side. The
1128   // space evaluation is a simple bonus based on the number of safe squares
1129   // available for minor pieces on the central four files on ranks 2--4. Safe
1130   // squares one, two or three squares behind a friendly pawn are counted
1131   // twice. Finally, the space bonus is scaled by a weight taken from the
1132   // material hash table.
1133   template<bool HasPopCnt>
1134   void evaluate_space(const Position &pos, Color us, EvalInfo &ei) {
1135
1136     Color them = opposite_color(us);
1137
1138     // Find the safe squares for our pieces inside the area defined by
1139     // SpaceMask[us]. A square is unsafe it is attacked by an enemy
1140     // pawn, or if it is undefended and attacked by an enemy piece.
1141
1142     Bitboard safeSquares =   SpaceMask[us]
1143                           & ~pos.pawns(us)
1144                           & ~ei.attacked_by(them, PAWN)
1145                           & ~(~ei.attacked_by(us) & ei.attacked_by(them));
1146
1147     // Find all squares which are at most three squares behind some friendly
1148     // pawn.
1149     Bitboard behindFriendlyPawns = pos.pawns(us);
1150     if (us == WHITE)
1151     {
1152         behindFriendlyPawns |= (behindFriendlyPawns >> 8);
1153         behindFriendlyPawns |= (behindFriendlyPawns >> 16);
1154     }
1155     else
1156     {
1157         behindFriendlyPawns |= (behindFriendlyPawns << 8);
1158         behindFriendlyPawns |= (behindFriendlyPawns << 16);
1159     }
1160
1161     int space =  count_1s_max_15<HasPopCnt>(safeSquares)
1162                + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
1163
1164     ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
1165   }
1166
1167
1168   // apply_weight() applies an evaluation weight to a value
1169
1170   inline Value apply_weight(Value v, int w) {
1171     return (v*w) / 0x100;
1172   }
1173
1174
1175   // scale_by_game_phase() interpolates between a middle game and an endgame
1176   // score, based on game phase.  It also scales the return value by a
1177   // ScaleFactor array.
1178
1179   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
1180
1181     assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
1182     assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);
1183     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1184
1185     ev = apply_scale_factor(ev, sf[(ev > Value(0) ? WHITE : BLACK)]);
1186
1187     Value result = Value(int((mv * ph + ev * (128 - ph)) / 128));
1188     return Value(int(result) & ~(GrainSize - 1));
1189   }
1190
1191
1192   // compute_weight() computes the value of an evaluation weight, by combining
1193   // an UCI-configurable weight with an internal weight.
1194
1195   int compute_weight(int uciWeight, int internalWeight) {
1196
1197     uciWeight = (uciWeight * 0x100) / 100;
1198     return (uciWeight * internalWeight) / 0x100;
1199   }
1200
1201
1202   // helper used in read_weights()
1203   int weight_option(const std::string& opt, int weight) {
1204
1205     return compute_weight(get_option_value_int(opt), weight);
1206   }
1207
1208
1209   // init_safety() initizes the king safety evaluation, based on UCI
1210   // parameters.  It is called from read_weights().
1211
1212   void init_safety() {
1213
1214     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1215     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
1216     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
1217     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
1218     KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
1219     DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
1220     MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
1221
1222     int maxSlope = get_option_value_int("King Safety Max Slope");
1223     int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
1224     double a     = get_option_value_int("King Safety Coefficient") / 100.0;
1225     double b     = get_option_value_int("King Safety X Intercept");
1226     bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
1227     bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
1228
1229     for (int i = 0; i < 100; i++)
1230     {
1231         if (i < b)
1232             SafetyTable[i] = Value(0);
1233         else if(quad)
1234             SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1235         else if(linear)
1236             SafetyTable[i] = Value((int)(100 * a * (i - b)));
1237     }
1238
1239     for (int i = 0; i < 100; i++)
1240     {
1241         if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1242             for (int j = i + 1; j < 100; j++)
1243                 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1244
1245         if (SafetyTable[i]  > Value(peak))
1246             SafetyTable[i] = Value(peak);
1247     }
1248   }
1249 }