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