git.sesse.net Git - stockfish/blob - src/evaluate.cpp

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