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 = 8;
  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 the area of the board which is consdered
 211   // by 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   // Function prototypes
 270   template<bool HasPopCnt>
 271   Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
 272
 273   template<Color Us, bool HasPopCnt>
 274   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
 275
 276   template<Color Us, bool HasPopCnt>
 277   void evaluate_king(const Position& pos, EvalInfo& ei);
 278
 279   template<Color Us, bool HasPopCnt>
 280   void evaluate_space(const Position& pos, 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, EvalInfo& ei);
 284   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei);
 285   inline Value apply_weight(Value v, int w);
 286   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 287   int weight_option(const std::string& opt, int weight);
 288   void init_safety();
 289 }
 290
 291
 292 ////
 293 //// Functions
 294 ////
 295
 296 /// evaluate() is the main evaluation function. It always computes two
 297 /// values, an endgame score and a middle game score, and interpolates
 298 /// between them based on the remaining material.
 299 Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
 300
 301     return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
 302                         : do_evaluate<false>(pos, ei, threadID);
 303 }
 304
 305 namespace {
 306
 307 template<bool HasPopCnt>
 308 Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
 309
 310   assert(pos.is_ok());
 311   assert(threadID >= 0 && threadID < THREAD_MAX);
 312
 313   memset(&ei, 0, sizeof(EvalInfo));
 314
 315   // Initialize by reading the incrementally updated scores included in the
 316   // position object (material + piece square tables)
 317   ei.mgValue = pos.mg_value();
 318   ei.egValue = pos.eg_value();
 319
 320   // Probe the material hash table
 321   ei.mi = MaterialTable[threadID]->get_material_info(pos);
 322   ei.mgValue += ei.mi->material_value();
 323   ei.egValue += ei.mi->material_value();
 324
 325   // If we have a specialized evaluation function for the current material
 326   // configuration, call it and return
 327   if (ei.mi->specialized_eval_exists())
 328       return ei.mi->evaluate(pos);
 329
 330   // After get_material_info() call that modifies them
 331   ScaleFactor factor[2];
 332   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
 333   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
 334
 335   // Probe the pawn hash table
 336   ei.pi = PawnTable[threadID]->get_pawn_info(pos);
 337   ei.mgValue += apply_weight(ei.pi->mg_value(), WeightPawnStructureMidgame);
 338   ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
 339
 340   // Initialize king attack bitboards and king attack zones for both sides
 341   ei.attackedBy[WHITE][KING] = pos.attacks_from<KING>(pos.king_square(WHITE));
 342   ei.attackedBy[BLACK][KING] = pos.attacks_from<KING>(pos.king_square(BLACK));
 343   ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
 344   ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
 345
 346   // Initialize pawn attack bitboards for both sides
 347   ei.attackedBy[WHITE][PAWN] = ei.pi->pawn_attacks(WHITE);
 348   ei.attackedBy[BLACK][PAWN] = ei.pi->pawn_attacks(BLACK);
 349   Bitboard b1 = ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING];
 350   Bitboard b2 = ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING];
 351   if (b1)
 352       ei.kingAttackersCount[WHITE] = count_1s_max_15<HasPopCnt>(b1)/2;
 353
 354   if (b2)
 355       ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(b2)/2;
 356
 357   // Evaluate pieces
 358   evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
 359   evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
 360
 361   // Kings. Kings are evaluated after all other pieces for both sides,
 362   // because we need complete attack information for all pieces when computing
 363   // the king safety evaluation.
 364   evaluate_king<WHITE, HasPopCnt>(pos, ei);
 365   evaluate_king<BLACK, HasPopCnt>(pos, ei);
 366
 367   // Evaluate passed pawns. We evaluate passed pawns for both sides at once,
 368   // because we need to know which side promotes first in positions where
 369   // both sides have an unstoppable passed pawn.
 370   if (ei.pi->passed_pawns())
 371       evaluate_passed_pawns(pos, ei);
 372
 373   Phase phase = pos.game_phase();
 374
 375   // Middle-game specific evaluation terms
 376   if (phase > PHASE_ENDGAME)
 377   {
 378     // Pawn storms in positions with opposite castling.
 379     if (   square_file(pos.king_square(WHITE)) >= FILE_E
 380         && square_file(pos.king_square(BLACK)) <= FILE_D)
 381
 382         ei.mgValue += ei.pi->queenside_storm_value(WHITE)
 383                     - ei.pi->kingside_storm_value(BLACK);
 384
 385     else if (   square_file(pos.king_square(WHITE)) <= FILE_D
 386              && square_file(pos.king_square(BLACK)) >= FILE_E)
 387
 388         ei.mgValue += ei.pi->kingside_storm_value(WHITE)
 389                     - ei.pi->queenside_storm_value(BLACK);
 390
 391     // Evaluate space for both sides
 392     if (ei.mi->space_weight() > 0)
 393     {
 394         evaluate_space<WHITE, HasPopCnt>(pos, ei);
 395         evaluate_space<BLACK, HasPopCnt>(pos, ei);
 396     }
 397   }
 398
 399   // Mobility
 400   ei.mgValue += apply_weight(ei.mgMobility, WeightMobilityMidgame);
 401   ei.egValue += apply_weight(ei.egMobility, WeightMobilityEndgame);
 402
 403   // If we don't already have an unusual scale factor, check for opposite
 404   // colored bishop endgames, and use a lower scale for those
 405   if (   phase < PHASE_MIDGAME
 406       && pos.opposite_colored_bishops()
 407       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
 408           || (factor[BLACK] == SCALE_FACTOR_NORMAL && ei.egValue < Value(0))))
 409   {
 410       ScaleFactor sf;
 411
 412       // Only the two bishops ?
 413       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
 414           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
 415       {
 416           // Check for KBP vs KB with only a single pawn that is almost
 417           // certainly a draw or at least two pawns.
 418           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
 419           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
 420       }
 421       else
 422           // Endgame with opposite-colored bishops, but also other pieces. Still
 423           // a bit drawish, but not as drawish as with only the two bishops.
 424            sf = ScaleFactor(50);
 425
 426       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
 427           factor[WHITE] = sf;
 428       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
 429           factor[BLACK] = sf;
 430   }
 431
 432   // Interpolate between the middle game and the endgame score
 433   Color stm = pos.side_to_move();
 434
 435   Value v = Sign[stm] * scale_by_game_phase(ei.mgValue, ei.egValue, phase, factor);
 436
 437   return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
 438 }
 439
 440 } // namespace
 441
 442 /// quick_evaluate() does a very approximate evaluation of the current position.
 443 /// It currently considers only material and piece square table scores. Perhaps
 444 /// we should add scores from the pawn and material hash tables?
 445
 446 Value quick_evaluate(const Position &pos) {
 447
 448   assert(pos.is_ok());
 449
 450   static const
 451   ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
 452
 453   Value mgv = pos.mg_value();
 454   Value egv = pos.eg_value();
 455   Phase ph = pos.game_phase();
 456   Color stm = pos.side_to_move();
 457
 458   return Sign[stm] * scale_by_game_phase(mgv, egv, ph, sf);
 459 }
 460
 461
 462 /// init_eval() initializes various tables used by the evaluation function
 463
 464 void init_eval(int threads) {
 465
 466   assert(threads <= THREAD_MAX);
 467
 468   for (int i = 0; i < THREAD_MAX; i++)
 469   {
 470     if (i >= threads)
 471     {
 472         delete PawnTable[i];
 473         delete MaterialTable[i];
 474         PawnTable[i] = NULL;
 475         MaterialTable[i] = NULL;
 476         continue;
 477     }
 478     if (!PawnTable[i])
 479         PawnTable[i] = new PawnInfoTable(PawnTableSize);
 480     if (!MaterialTable[i])
 481         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
 482   }
 483 }
 484
 485
 486 /// quit_eval() releases heap-allocated memory at program termination
 487
 488 void quit_eval() {
 489
 490   for (int i = 0; i < THREAD_MAX; i++)
 491   {
 492       delete PawnTable[i];
 493       delete MaterialTable[i];
 494       PawnTable[i] = NULL;
 495       MaterialTable[i] = NULL;
 496   }
 497 }
 498
 499
 500 /// read_weights() reads evaluation weights from the corresponding UCI parameters
 501
 502 void read_weights(Color us) {
 503
 504   Color them = opposite_color(us);
 505
 506   WeightMobilityMidgame      = weight_option("Mobility (Middle Game)", WeightMobilityMidgameInternal);
 507   WeightMobilityEndgame      = weight_option("Mobility (Endgame)", WeightMobilityEndgameInternal);
 508   WeightPawnStructureMidgame = weight_option("Pawn Structure (Middle Game)", WeightPawnStructureMidgameInternal);
 509   WeightPawnStructureEndgame = weight_option("Pawn Structure (Endgame)", WeightPawnStructureEndgameInternal);
 510   WeightPassedPawnsMidgame   = weight_option("Passed Pawns (Middle Game)", WeightPassedPawnsMidgameInternal);
 511   WeightPassedPawnsEndgame   = weight_option("Passed Pawns (Endgame)", WeightPassedPawnsEndgameInternal);
 512   WeightSpace                = weight_option("Space", WeightSpaceInternal);
 513   WeightKingSafety[us]       = weight_option("Cowardice", WeightKingSafetyInternal);
 514   WeightKingSafety[them]     = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
 515
 516   // If running in analysis mode, make sure we use symmetrical king safety. We do this
 517   // by replacing both WeightKingSafety[us] and WeightKingSafety[them] by their average.
 518   if (get_option_value_bool("UCI_AnalyseMode"))
 519   {
 520       WeightKingSafety[us] = (WeightKingSafety[us] + WeightKingSafety[them]) / 2;
 521       WeightKingSafety[them] = WeightKingSafety[us];
 522   }
 523   init_safety();
 524 }
 525
 526
 527 namespace {
 528
 529   // evaluate_mobility() computes mobility and attacks for every piece
 530
 531   template<PieceType Piece, Color Us, bool HasPopCnt>
 532   int evaluate_mobility(const Position& pos, Bitboard b, EvalInfo& ei) {
 533
 534     const Color Them = (Us == WHITE ? BLACK : WHITE);
 535     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
 536     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
 537     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
 538     static const int lastIndex[] = { 0, 0, 8, 15, 15, 31 };
 539
 540     // Update attack info
 541     ei.attackedBy[Us][Piece] |= b;
 542
 543     // King attacks
 544     if (b & ei.kingZone[Us])
 545     {
 546         ei.kingAttackersCount[Us]++;
 547         ei.kingAttackersWeight[Us] += AttackWeight[Piece];
 548         Bitboard bb = (b & ei.attackedBy[Them][KING]);
 549         if (bb)
 550             ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
 551     }
 552
 553     // Remove squares protected by enemy pawns or occupied by our pieces
 554     b &= ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
 555
 556     // The squares occupied by enemy pieces (not defended by pawns) will be
 557     // counted two times instead of one. The shift (almost) guarantees that
 558     // intersection with b is zero so when we 'or' the two bitboards togheter
 559     // and count we get the correct sum of '1' in b and attacked bitboards.
 560     Bitboard attacked = Us == WHITE ? ((b & pos.pieces_of_color(Them)) >> 1)
 561                                     : ((b & pos.pieces_of_color(Them)) << 1);
 562     // Mobility
 563     int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b | attacked)
 564                               : count_1s<HasPopCnt>(b | attacked));
 565
 566     if (mob > lastIndex[Piece])
 567         mob = lastIndex[Piece];
 568
 569     ei.mgMobility += Sign[Us] * MgBonus[Piece][mob];
 570     ei.egMobility += Sign[Us] * EgBonus[Piece][mob];
 571     return mob;
 572   }
 573
 574
 575   // evaluate_outposts() evaluates bishop and knight outposts squares
 576
 577   template<PieceType Piece, Color Us>
 578   void evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
 579
 580     const Color Them = (Us == WHITE ? BLACK : WHITE);
 581
 582     // Initial bonus based on square
 583     Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
 584                                    : KnightOutpostBonus[relative_square(Us, s)]);
 585
 586     // Increase bonus if supported by pawn, especially if the opponent has
 587     // no minor piece which can exchange the outpost piece
 588     if (bonus && (pos.attacks_from<PAWN>(s, Them) & pos.pieces(PAWN, Us)))
 589     {
 590         if (    pos.pieces(KNIGHT, Them) == EmptyBoardBB
 591             && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
 592             bonus += bonus + bonus / 2;
 593         else
 594             bonus += bonus / 2;
 595     }
 596     ei.mgValue += Sign[Us] * bonus;
 597     ei.egValue += Sign[Us] * bonus;
 598   }
 599
 600
 601   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
 602
 603   template<PieceType Piece, Color Us, bool HasPopCnt>
 604   void evaluate_pieces(const Position& pos, EvalInfo& ei) {
 605
 606     Bitboard b;
 607     Square s, ksq;
 608     int mob;
 609     File f;
 610
 611     const Color Them = (Us == WHITE ? BLACK : WHITE);
 612     const Square* ptr = pos.piece_list_begin(Us, Piece);
 613
 614     while ((s = *ptr++) != SQ_NONE)
 615     {
 616         if (Piece == KNIGHT || Piece == QUEEN)
 617             b = pos.attacks_from<Piece>(s);
 618         else if (Piece == BISHOP)
 619             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
 620         else if (Piece == ROOK)
 621             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
 622         else
 623             assert(false);
 624
 625         // Attacks and mobility
 626         mob = evaluate_mobility<Piece, Us, HasPopCnt>(pos, b, ei);
 627
 628         // Bishop and knight outposts squares
 629         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Them))
 630             evaluate_outposts<Piece, Us>(pos, ei, s);
 631
 632         // Special patterns: trapped bishops on a7/h7/a2/h2
 633         // and trapped bishops on a1/h1/a8/h8 in Chess960.
 634         if (Piece == BISHOP)
 635         {
 636             if (bit_is_set(MaskA7H7[Us], s))
 637                 evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
 638
 639             if (Chess960 && bit_is_set(MaskA1H1[Us], s))
 640                 evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
 641         }
 642
 643         if (Piece == ROOK || Piece == QUEEN)
 644         {
 645             // Queen or rook on 7th rank
 646             if (   relative_rank(Us, s) == RANK_7
 647                 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
 648             {
 649                 ei.mgValue += Sign[Us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
 650                 ei.egValue += Sign[Us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
 651             }
 652         }
 653
 654         // Special extra evaluation for rooks
 655         if (Piece == ROOK)
 656         {
 657             // Open and half-open files
 658             f = square_file(s);
 659             if (ei.pi->file_is_half_open(Us, f))
 660             {
 661                 if (ei.pi->file_is_half_open(Them, f))
 662                 {
 663                     ei.mgValue += Sign[Us] * RookOpenFileBonus;
 664                     ei.egValue += Sign[Us] * RookOpenFileBonus;
 665                 }
 666                 else
 667                 {
 668                     ei.mgValue += Sign[Us] * RookHalfOpenFileBonus;
 669                     ei.egValue += Sign[Us] * RookHalfOpenFileBonus;
 670                 }
 671             }
 672
 673             // Penalize rooks which are trapped inside a king. Penalize more if
 674             // king has lost right to castle.
 675             if (mob > 6 || ei.pi->file_is_half_open(Us, f))
 676                 continue;
 677
 678             ksq = pos.king_square(Us);
 679
 680             if (    square_file(ksq) >= FILE_E
 681                 &&  square_file(s) > square_file(ksq)
 682                 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 683             {
 684                 // Is there a half-open file between the king and the edge of the board?
 685                 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
 686                     ei.mgValue -= pos.can_castle(Us)? Sign[Us] * ((TrappedRookPenalty - mob * 16) / 2)
 687                                                     : Sign[Us] *  (TrappedRookPenalty - mob * 16);
 688             }
 689             else if (    square_file(ksq) <= FILE_D
 690                     &&  square_file(s) < square_file(ksq)
 691                     && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 692             {
 693                 // Is there a half-open file between the king and the edge of the board?
 694                 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
 695                     ei.mgValue -= pos.can_castle(Us)? Sign[Us] * ((TrappedRookPenalty - mob * 16) / 2)
 696                                                     : Sign[Us] * (TrappedRookPenalty - mob * 16);
 697             }
 698         }
 699     }
 700   }
 701
 702
 703   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
 704   // pieces of a given color.
 705
 706   template<Color Us, bool HasPopCnt>
 707   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
 708
 709       evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei);
 710       evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei);
 711       evaluate_pieces<ROOK,   Us, HasPopCnt>(pos, ei);
 712       evaluate_pieces<QUEEN,  Us, HasPopCnt>(pos, ei);
 713
 714       // Sum up all attacked squares
 715       ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
 716                              | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
 717                              | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
 718   }
 719
 720
 721   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
 722
 723   template<Color Us, bool HasPopCnt>
 724   void evaluate_king(const Position& pos, EvalInfo& ei) {
 725
 726     const Color Them = (Us == WHITE ? BLACK : WHITE);
 727     const Square s = pos.king_square(Us);
 728     int shelter = 0;
 729
 730     // King shelter
 731     if (relative_rank(Us, s) <= RANK_4)
 732     {
 733         shelter = ei.pi->get_king_shelter(pos, Us, s);
 734         ei.mgValue += Sign[Us] * Value(shelter);
 735     }
 736
 737     // King safety. This is quite complicated, and is almost certainly far
 738     // from optimally tuned.
 739     if (   pos.piece_count(Them, QUEEN) >= 1
 740         && ei.kingAttackersCount[Them] >= 2
 741         && pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
 742         && ei.kingAdjacentZoneAttacksCount[Them])
 743     {
 744       // Is it the attackers turn to move?
 745       bool sente = (Them == pos.side_to_move());
 746
 747       // Find the attacked squares around the king which has no defenders
 748       // apart from the king itself
 749       Bitboard undefended =
 750              ei.attacked_by(Them)       & ~ei.attacked_by(Us, PAWN)
 751           & ~ei.attacked_by(Us, KNIGHT) & ~ei.attacked_by(Us, BISHOP)
 752           & ~ei.attacked_by(Us, ROOK)   & ~ei.attacked_by(Us, QUEEN)
 753           &  ei.attacked_by(Us, KING);
 754
 755       Bitboard occ = pos.occupied_squares(), b, b2;
 756
 757       // Initialize the 'attackUnits' variable, which is used later on as an
 758       // index to the SafetyTable[] array.  The initial value is based on the
 759       // number and types of the attacking pieces, the number of attacked and
 760       // undefended squares around the king, the square of the king, and the
 761       // quality of the pawn shelter.
 762       int attackUnits =
 763             Min((ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2, 25)
 764           + (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
 765           + InitKingDanger[relative_square(Us, s)] - (shelter >> 5);
 766
 767       // Analyse safe queen contact checks
 768       b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
 769       if (b)
 770       {
 771         Bitboard attackedByOthers =
 772               ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
 773             | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK);
 774
 775         b &= attackedByOthers;
 776         if (b)
 777         {
 778           // The bitboard b now contains the squares available for safe queen
 779           // contact checks.
 780           int count = count_1s_max_15<HasPopCnt>(b);
 781           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
 782
 783           // Is there a mate threat?
 784           if (QueenContactMates && !pos.is_check())
 785           {
 786             Bitboard escapeSquares =
 787                 pos.attacks_from<KING>(s) & ~pos.pieces_of_color(Us) & ~attackedByOthers;
 788
 789             while (b)
 790             {
 791                 Square from, to = pop_1st_bit(&b);
 792                 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
 793                 {
 794                     // We have a mate, unless the queen is pinned or there
 795                     // is an X-ray attack through the queen.
 796                     for (int i = 0; i < pos.piece_count(Them, QUEEN); i++)
 797                     {
 798                         from = pos.piece_list(Them, QUEEN, i);
 799                         if (    bit_is_set(pos.attacks_from<QUEEN>(from), to)
 800                             && !bit_is_set(pos.pinned_pieces(Them), from)
 801                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & pos.pieces(ROOK, QUEEN, Us))
 802                             && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & pos.pieces(BISHOP, QUEEN, Us)))
 803
 804                             ei.mateThreat[Them] = make_move(from, to);
 805                     }
 806                 }
 807             }
 808           }
 809         }
 810       }
 811
 812       // Analyse safe distance checks
 813       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
 814       {
 815           b = pos.attacks_from<ROOK>(s) & ~pos.pieces_of_color(Them) & ~ei.attacked_by(Us);
 816
 817           // Queen checks
 818           b2 = b & ei.attacked_by(Them, QUEEN);
 819           if (b2)
 820               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 821
 822           // Rook checks
 823           b2 = b & ei.attacked_by(Them, ROOK);
 824           if (b2)
 825               attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 826       }
 827       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
 828       {
 829           b = pos.attacks_from<BISHOP>(s) & ~pos.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           // Bishop checks
 837           b2 = b & ei.attacked_by(Them, BISHOP);
 838           if (b2)
 839               attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 840       }
 841       if (KnightCheckBonus > 0)
 842       {
 843           b = pos.attacks_from<KNIGHT>(s) & ~pos.pieces_of_color(Them) & ~ei.attacked_by(Us);
 844
 845           // Knight checks
 846           b2 = b & ei.attacked_by(Them, KNIGHT);
 847           if (b2)
 848               attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 849       }
 850
 851       // Analyse discovered checks (only for non-pawns right now, consider
 852       // adding pawns later).
 853       if (DiscoveredCheckBonus)
 854       {
 855         b = pos.discovered_check_candidates(Them) & ~pos.pieces(PAWN);
 856         if (b)
 857           attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
 858       }
 859
 860       // Has a mate threat been found?  We don't do anything here if the
 861       // side with the mating move is the side to move, because in that
 862       // case the mating side will get a huge bonus at the end of the main
 863       // evaluation function instead.
 864       if (ei.mateThreat[Them] != MOVE_NONE)
 865           attackUnits += MateThreatBonus;
 866
 867       // Ensure that attackUnits is between 0 and 99, in order to avoid array
 868       // out of bounds errors:
 869       if (attackUnits < 0)
 870           attackUnits = 0;
 871
 872       if (attackUnits >= 100)
 873           attackUnits = 99;
 874
 875       // Finally, extract the king safety score from the SafetyTable[] array.
 876       // Add the score to the evaluation, and also to ei.futilityMargin.  The
 877       // reason for adding the king safety score to the futility margin is
 878       // that the king safety scores can sometimes be very big, and that
 879       // capturing a single attacking piece can therefore result in a score
 880       // change far bigger than the value of the captured piece.
 881       Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[Us]);
 882
 883       ei.mgValue -= Sign[Us] * v;
 884
 885       if (Us == pos.side_to_move())
 886           ei.futilityMargin += v;
 887     }
 888   }
 889
 890
 891   // evaluate_passed_pawns() evaluates the passed pawns for both sides
 892
 893   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
 894
 895     bool hasUnstoppable[2] = {false, false};
 896     int movesToGo[2] = {100, 100};
 897
 898     for (Color us = WHITE; us <= BLACK; us++)
 899     {
 900         Color them = opposite_color(us);
 901         Square ourKingSq = pos.king_square(us);
 902         Square theirKingSq = pos.king_square(them);
 903         Bitboard b = ei.pi->passed_pawns() & pos.pieces(PAWN, us), b2, b3, b4;
 904
 905         while (b)
 906         {
 907             Square s = pop_1st_bit(&b);
 908
 909             assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
 910             assert(pos.pawn_is_passed(us, s));
 911
 912             int r = int(relative_rank(us, s) - RANK_2);
 913             int tr = Max(0, r * (r - 1));
 914             Square blockSq = s + pawn_push(us);
 915
 916             // Base bonus based on rank
 917             Value mbonus = Value(20 * tr);
 918             Value ebonus = Value(10 + r * r * 10);
 919
 920             // Adjust bonus based on king proximity
 921             if (tr != 0)
 922             {
 923                 ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
 924                 ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
 925                 ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
 926
 927                 // If the pawn is free to advance, increase bonus
 928                 if (pos.square_is_empty(blockSq))
 929                 {
 930                     b2 = squares_in_front_of(us, s);
 931                     b3 = b2 & ei.attacked_by(them);
 932                     b4 = b2 & ei.attacked_by(us);
 933
 934                     // If there is an enemy rook or queen attacking the pawn from behind,
 935                     // add all X-ray attacks by the rook or queen.
 936                     if (    bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
 937                         && (squares_behind(us, s) & pos.pieces(ROOK, QUEEN, them)))
 938                         b3 = b2;
 939
 940                     // Squares attacked or occupied by enemy pieces
 941                     b3 |= (b2 & pos.pieces_of_color(them));
 942
 943                     // There are no enemy pawns in the pawn's path
 944                     assert((b2 & pos.pieces(PAWN, them)) == EmptyBoardBB);
 945
 946                     // Are any of the squares in the pawn's path attacked or occupied by the enemy?
 947                     if (b3 == EmptyBoardBB)
 948                         // No enemy attacks or pieces, huge bonus!
 949                         ebonus += Value(tr * (b2 == b4 ? 17 : 15));
 950                     else
 951                         // OK, there are enemy attacks or pieces (but not pawns). Are those
 952                         // squares which are attacked by the enemy also attacked by us?
 953                         // If yes, big bonus (but smaller than when there are no enemy attacks),
 954                         // if no, somewhat smaller bonus.
 955                         ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
 956
 957                     // At last, add a small bonus when there are no *friendly* pieces
 958                     // in the pawn's path.
 959                     if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
 960                         ebonus += Value(tr);
 961                 }
 962             }
 963
 964             // If the pawn is supported by a friendly pawn, increase bonus
 965             b2 = pos.pieces(PAWN, us) & neighboring_files_bb(s);
 966             if (b2 & rank_bb(s))
 967                 ebonus += Value(r * 20);
 968             else if (pos.attacks_from<PAWN>(s, them) & b2)
 969                 ebonus += Value(r * 12);
 970
 971             // If the other side has only a king, check whether the pawn is
 972             // unstoppable
 973             if (pos.non_pawn_material(them) == Value(0))
 974             {
 975                 Square qsq;
 976                 int d;
 977
 978                 qsq = relative_square(us, make_square(square_file(s), RANK_8));
 979                 d =  square_distance(s, qsq)
 980                    - square_distance(theirKingSq, qsq)
 981                    + (us != pos.side_to_move());
 982
 983                 if (d < 0)
 984                 {
 985                     int mtg = RANK_8 - relative_rank(us, s);
 986                     int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
 987                     mtg += blockerCount;
 988                     d += blockerCount;
 989                     if (d < 0)
 990                     {
 991                         hasUnstoppable[us] = true;
 992                         movesToGo[us] = Min(movesToGo[us], mtg);
 993                     }
 994                 }
 995             }
 996             // Rook pawns are a special case: They are sometimes worse, and
 997             // sometimes better than other passed pawns. It is difficult to find
 998             // good rules for determining whether they are good or bad. For now,
 999             // we try the following: Increase the value for rook pawns if the
1000             // other side has no pieces apart from a knight, and decrease the
1001             // value if the other side has a rook or queen.
1002             if (square_file(s) == FILE_A || square_file(s) == FILE_H)
1003             {
1004                 if (   pos.non_pawn_material(them) <= KnightValueMidgame
1005                     && pos.piece_count(them, KNIGHT) <= 1)
1006                     ebonus += ebonus / 4;
1007                 else if (pos.pieces(ROOK, QUEEN, them))
1008                     ebonus -= ebonus / 4;
1009             }
1010
1011             // Add the scores for this pawn to the middle game and endgame eval.
1012             ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
1013             ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
1014         }
1015     }
1016
1017     // Does either side have an unstoppable passed pawn?
1018     if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
1019         ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
1020     else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
1021         ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
1022     else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
1023     {
1024         // Both sides have unstoppable pawns! Try to find out who queens
1025         // first. We begin by transforming 'movesToGo' to the number of
1026         // plies until the pawn queens for both sides.
1027         movesToGo[WHITE] *= 2;
1028         movesToGo[BLACK] *= 2;
1029         movesToGo[pos.side_to_move()]--;
1030
1031         // If one side queens at least three plies before the other, that
1032         // side wins.
1033         if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
1034             ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
1035         else if (movesToGo[BLACK] <= movesToGo[WHITE] - 3)
1036             ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));
1037
1038         // We could also add some rules about the situation when one side
1039         // queens exactly one ply before the other: Does the first queen
1040         // check the opponent's king, or attack the opponent's queening square?
1041         // This is slightly tricky to get right, because it is possible that
1042         // the opponent's king has moved somewhere before the first pawn queens.
1043     }
1044   }
1045
1046
1047   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1048   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1049   // if it is.
1050
1051   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo &ei) {
1052
1053     assert(square_is_ok(s));
1054     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1055
1056     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1057     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1058
1059     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1060         && pos.see(s, b6) < 0
1061         && pos.see(s, b8) < 0)
1062     {
1063         ei.mgValue -= Sign[us] * TrappedBishopA7H7Penalty;
1064         ei.egValue -= Sign[us] * TrappedBishopA7H7Penalty;
1065     }
1066   }
1067
1068
1069   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1070   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1071   // black), and assigns a penalty if it is. This pattern can obviously
1072   // only occur in Chess960 games.
1073
1074   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei) {
1075
1076     Piece pawn = piece_of_color_and_type(us, PAWN);
1077     Square b2, b3, c3;
1078
1079     assert(Chess960);
1080     assert(square_is_ok(s));
1081     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1082
1083     if (square_file(s) == FILE_A)
1084     {
1085         b2 = relative_square(us, SQ_B2);
1086         b3 = relative_square(us, SQ_B3);
1087         c3 = relative_square(us, SQ_C3);
1088     }
1089     else
1090     {
1091         b2 = relative_square(us, SQ_G2);
1092         b3 = relative_square(us, SQ_G3);
1093         c3 = relative_square(us, SQ_F3);
1094     }
1095
1096     if (pos.piece_on(b2) == pawn)
1097     {
1098         Value penalty;
1099
1100         if (!pos.square_is_empty(b3))
1101             penalty = 2*TrappedBishopA1H1Penalty;
1102         else if (pos.piece_on(c3) == pawn)
1103             penalty = TrappedBishopA1H1Penalty;
1104         else
1105             penalty = TrappedBishopA1H1Penalty / 2;
1106
1107         ei.mgValue -= Sign[us] * penalty;
1108         ei.egValue -= Sign[us] * penalty;
1109     }
1110   }
1111
1112
1113   // evaluate_space() computes the space evaluation for a given side. The
1114   // space evaluation is a simple bonus based on the number of safe squares
1115   // available for minor pieces on the central four files on ranks 2--4. Safe
1116   // squares one, two or three squares behind a friendly pawn are counted
1117   // twice. Finally, the space bonus is scaled by a weight taken from the
1118   // material hash table.
1119   template<Color Us, bool HasPopCnt>
1120   void evaluate_space(const Position& pos, EvalInfo& ei) {
1121
1122     const Color Them = (Us == WHITE ? BLACK : WHITE);
1123
1124     // Find the safe squares for our pieces inside the area defined by
1125     // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
1126     // pawn, or if it is undefended and attacked by an enemy piece.
1127
1128     Bitboard safeSquares =   SpaceMask[Us]
1129                           & ~pos.pieces(PAWN, Us)
1130                           & ~ei.attacked_by(Them, PAWN)
1131                           & ~(~ei.attacked_by(Us) & ei.attacked_by(Them));
1132
1133     // Find all squares which are at most three squares behind some friendly
1134     // pawn.
1135     Bitboard behindFriendlyPawns = pos.pieces(PAWN, Us);
1136     behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >>  8 : behindFriendlyPawns <<  8);
1137     behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >> 16 : behindFriendlyPawns << 16);
1138
1139     int space =  count_1s_max_15<HasPopCnt>(safeSquares)
1140                + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
1141
1142     ei.mgValue += Sign[Us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
1143   }
1144
1145
1146   // apply_weight() applies an evaluation weight to a value
1147
1148   inline Value apply_weight(Value v, int w) {
1149     return (v*w) / 0x100;
1150   }
1151
1152
1153   // scale_by_game_phase() interpolates between a middle game and an endgame
1154   // score, based on game phase.  It also scales the return value by a
1155   // ScaleFactor array.
1156
1157   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
1158
1159     assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
1160     assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);
1161     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1162
1163     ev = apply_scale_factor(ev, sf[(ev > Value(0) ? WHITE : BLACK)]);
1164
1165     Value result = Value(int((mv * ph + ev * (128 - ph)) / 128));
1166     return Value(int(result) & ~(GrainSize - 1));
1167   }
1168
1169
1170   // weight_option() computes the value of an evaluation weight, by combining
1171   // an UCI-configurable weight with an internal weight.
1172
1173   int weight_option(const std::string& opt, int internalWeight) {
1174
1175     int uciWeight = get_option_value_int(opt);
1176     uciWeight = (uciWeight * 0x100) / 100;
1177     return (uciWeight * internalWeight) / 0x100;
1178   }
1179
1180
1181   // init_safety() initizes the king safety evaluation, based on UCI
1182   // parameters.  It is called from read_weights().
1183
1184   void init_safety() {
1185
1186     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1187     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
1188     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
1189     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
1190     KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
1191     DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
1192     MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
1193
1194     int maxSlope = get_option_value_int("King Safety Max Slope");
1195     int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
1196     double a     = get_option_value_int("King Safety Coefficient") / 100.0;
1197     double b     = get_option_value_int("King Safety X Intercept");
1198     bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
1199     bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
1200
1201     for (int i = 0; i < 100; i++)
1202     {
1203         if (i < b)
1204             SafetyTable[i] = Value(0);
1205         else if (quad)
1206             SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1207         else if (linear)
1208             SafetyTable[i] = Value((int)(100 * a * (i - b)));
1209     }
1210
1211     for (int i = 0; i < 100; i++)
1212     {
1213         if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1214             for (int j = i + 1; j < 100; j++)
1215                 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1216
1217         if (SafetyTable[i]  > Value(peak))
1218             SafetyTable[i] = Value(peak);
1219     }
1220   }
1221 }