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