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 = pos.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   Phase ph = pos.game_phase();
 493   Color stm = pos.side_to_move();
 494
 495   return Sign[stm] * scale_by_game_phase(pos.value(), ph, sf);
 496 }
 497
 498
 499 /// init_eval() initializes various tables used by the evaluation function
 500
 501 void init_eval(int threads) {
 502
 503   assert(threads <= THREAD_MAX);
 504
 505   for (int i = 0; i < THREAD_MAX; i++)
 506   {
 507     if (i >= threads)
 508     {
 509         delete PawnTable[i];
 510         delete MaterialTable[i];
 511         PawnTable[i] = NULL;
 512         MaterialTable[i] = NULL;
 513         continue;
 514     }
 515     if (!PawnTable[i])
 516         PawnTable[i] = new PawnInfoTable(PawnTableSize);
 517     if (!MaterialTable[i])
 518         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
 519   }
 520 }
 521
 522
 523 /// quit_eval() releases heap-allocated memory at program termination
 524
 525 void quit_eval() {
 526
 527   for (int i = 0; i < THREAD_MAX; i++)
 528   {
 529       delete PawnTable[i];
 530       delete MaterialTable[i];
 531       PawnTable[i] = NULL;
 532       MaterialTable[i] = NULL;
 533   }
 534 }
 535
 536
 537 /// read_weights() reads evaluation weights from the corresponding UCI parameters
 538
 539 void read_weights(Color us) {
 540
 541   Color them = opposite_color(us);
 542
 543   WeightMobilityMidgame      = weight_option("Mobility (Middle Game)", WeightMobilityMidgameInternal);
 544   WeightMobilityEndgame      = weight_option("Mobility (Endgame)", WeightMobilityEndgameInternal);
 545   WeightPawnStructureMidgame = weight_option("Pawn Structure (Middle Game)", WeightPawnStructureMidgameInternal);
 546   WeightPawnStructureEndgame = weight_option("Pawn Structure (Endgame)", WeightPawnStructureEndgameInternal);
 547   WeightPassedPawnsMidgame   = weight_option("Passed Pawns (Middle Game)", WeightPassedPawnsMidgameInternal);
 548   WeightPassedPawnsEndgame   = weight_option("Passed Pawns (Endgame)", WeightPassedPawnsEndgameInternal);
 549   WeightSpace                = weight_option("Space", WeightSpaceInternal);
 550   WeightKingSafety[us]       = weight_option("Cowardice", WeightKingSafetyInternal);
 551   WeightKingSafety[them]     = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
 552
 553   // If running in analysis mode, make sure we use symmetrical king safety. We do this
 554   // by replacing both WeightKingSafety[us] and WeightKingSafety[them] by their average.
 555   if (get_option_value_bool("UCI_AnalyseMode"))
 556   {
 557       WeightKingSafety[us] = (WeightKingSafety[us] + WeightKingSafety[them]) / 2;
 558       WeightKingSafety[them] = WeightKingSafety[us];
 559   }
 560   init_safety();
 561 }
 562
 563
 564 namespace {
 565
 566   // evaluate_mobility() computes mobility and attacks for every piece
 567
 568   template<PieceType Piece, Color Us, bool HasPopCnt>
 569   int evaluate_mobility(Bitboard b, Bitboard mob_area, EvalInfo& ei) {
 570
 571     const Color Them = (Us == WHITE ? BLACK : WHITE);
 572     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
 573     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
 574     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
 575
 576     // Update attack info
 577     ei.attackedBy[Us][Piece] |= b;
 578
 579     // King attacks
 580     if (b & ei.kingZone[Us])
 581     {
 582         ei.kingAttackersCount[Us]++;
 583         ei.kingAttackersWeight[Us] += AttackWeight[Piece];
 584         Bitboard bb = (b & ei.attackedBy[Them][KING]);
 585         if (bb)
 586             ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
 587     }
 588
 589     // Mobility
 590     int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & mob_area)
 591                               : count_1s<HasPopCnt>(b & mob_area));
 592
 593     ei.mgMobility += Sign[Us] * MgBonus[Piece][mob];
 594     ei.egMobility += Sign[Us] * EgBonus[Piece][mob];
 595     return mob;
 596   }
 597
 598
 599   // evaluate_outposts() evaluates bishop and knight outposts squares
 600
 601   template<PieceType Piece, Color Us>
 602   void evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
 603
 604     const Color Them = (Us == WHITE ? BLACK : WHITE);
 605
 606     // Initial bonus based on square
 607     Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
 608                                    : KnightOutpostBonus[relative_square(Us, s)]);
 609
 610     // Increase bonus if supported by pawn, especially if the opponent has
 611     // no minor piece which can exchange the outpost piece
 612     if (bonus && (pos.attacks_from<PAWN>(s, Them) & pos.pieces(PAWN, Us)))
 613     {
 614         if (    pos.pieces(KNIGHT, Them) == EmptyBoardBB
 615             && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
 616             bonus += bonus + bonus / 2;
 617         else
 618             bonus += bonus / 2;
 619     }
 620     ei.value += Sign[Us] * Score(bonus, bonus);
 621   }
 622
 623
 624   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
 625
 626   template<PieceType Piece, Color Us, bool HasPopCnt>
 627   void evaluate_pieces(const Position& pos, EvalInfo& ei) {
 628
 629     Bitboard b;
 630     Square s, ksq;
 631     int mob;
 632     File f;
 633
 634     const Color Them = (Us == WHITE ? BLACK : WHITE);
 635     const Square* ptr = pos.piece_list_begin(Us, Piece);
 636
 637     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
 638     const Bitboard mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
 639
 640     while ((s = *ptr++) != SQ_NONE)
 641     {
 642         if (Piece == KNIGHT || Piece == QUEEN)
 643             b = pos.attacks_from<Piece>(s);
 644         else if (Piece == BISHOP)
 645             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
 646         else if (Piece == ROOK)
 647             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
 648         else
 649             assert(false);
 650
 651         // Attacks and mobility
 652         mob = evaluate_mobility<Piece, Us, HasPopCnt>(b, mob_area, ei);
 653
 654         // Decrease score if we are attacked by an enemy pawn. Remaining part
 655         // of threat evaluation must be done later when we have full attack info.
 656         if (bit_is_set(ei.attackedBy[Them][PAWN], s))
 657             ei.value -= Sign[Us] * Score(MidgameThreatedByPawnPenalty[Piece], EndgameThreatedByPawnPenalty[Piece]);
 658
 659         // Bishop and knight outposts squares
 660         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Them))
 661             evaluate_outposts<Piece, Us>(pos, ei, s);
 662
 663         // Special patterns: trapped bishops on a7/h7/a2/h2
 664         // and trapped bishops on a1/h1/a8/h8 in Chess960.
 665         if (Piece == BISHOP)
 666         {
 667             if (bit_is_set(MaskA7H7[Us], s))
 668                 evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
 669
 670             if (Chess960 && bit_is_set(MaskA1H1[Us], s))
 671                 evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
 672         }
 673
 674         if (Piece == ROOK || Piece == QUEEN)
 675         {
 676             // Queen or rook on 7th rank
 677             if (   relative_rank(Us, s) == RANK_7
 678                 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
 679             {
 680                 ei.value += Sign[Us] * (Piece == ROOK ? Score(MidgameRookOn7thBonus, EndgameRookOn7thBonus)
 681                                                       : Score(MidgameQueenOn7thBonus, EndgameQueenOn7thBonus));
 682             }
 683         }
 684
 685         // Special extra evaluation for rooks
 686         if (Piece == ROOK)
 687         {
 688             // Open and half-open files
 689             f = square_file(s);
 690             if (ei.pi->file_is_half_open(Us, f))
 691             {
 692                 if (ei.pi->file_is_half_open(Them, f))
 693                     ei.value += Sign[Us] * Score(RookOpenFileBonus, RookOpenFileBonus);
 694                 else
 695                     ei.value += Sign[Us] * Score(RookHalfOpenFileBonus, RookHalfOpenFileBonus);
 696             }
 697
 698             // Penalize rooks which are trapped inside a king. Penalize more if
 699             // king has lost right to castle.
 700             if (mob > 6 || ei.pi->file_is_half_open(Us, f))
 701                 continue;
 702
 703             ksq = pos.king_square(Us);
 704
 705             if (    square_file(ksq) >= FILE_E
 706                 &&  square_file(s) > square_file(ksq)
 707                 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 708             {
 709                 // Is there a half-open file between the king and the edge of the board?
 710                 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
 711                     ei.value -= Sign[Us] * Score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
 712                                                                     : (TrappedRookPenalty - mob * 16), 0);
 713             }
 714             else if (    square_file(ksq) <= FILE_D
 715                     &&  square_file(s) < square_file(ksq)
 716                     && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 717             {
 718                 // Is there a half-open file between the king and the edge of the board?
 719                 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
 720                     ei.value -= Sign[Us] * Score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
 721                                                                     : (TrappedRookPenalty - mob * 16), 0);
 722             }
 723         }
 724     }
 725   }
 726
 727
 728   // evaluate_threats<>() assigns bonuses according to the type of attacking piece
 729   // and the type of attacked one.
 730
 731   template<Color Us>
 732   void evaluate_threats(const Position& pos, EvalInfo& ei) {
 733
 734     const Color Them = (Us == WHITE ? BLACK : WHITE);
 735
 736     Bitboard b;
 737     Score bonus(0, 0);
 738
 739     // Enemy pieces not defended by a pawn and under our attack
 740     Bitboard weakEnemies =  pos.pieces_of_color(Them)
 741                           & ~ei.attackedBy[Them][PAWN]
 742                           & ei.attackedBy[Us][0];
 743     if (!weakEnemies)
 744         return;
 745
 746     // Add bonus according to type of attacked enemy pieces and to the
 747     // type of attacking piece, from knights to queens. Kings are not
 748     // considered because are already special handled in king evaluation.
 749     for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
 750     {
 751         b = ei.attackedBy[Us][pt1] & weakEnemies;
 752         if (b)
 753             for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
 754                 if (b & pos.pieces(pt2))
 755                     bonus += Score(MidgameThreatBonus[pt1][pt2], EndgameThreatBonus[pt1][pt2]);
 756     }
 757     ei.value += Sign[Us] * bonus;
 758   }
 759
 760
 761   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
 762   // pieces of a given color.
 763
 764   template<Color Us, bool HasPopCnt>
 765   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
 766
 767       evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei);
 768       evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei);
 769       evaluate_pieces<ROOK,   Us, HasPopCnt>(pos, ei);
 770       evaluate_pieces<QUEEN,  Us, HasPopCnt>(pos, ei);
 771
 772       // Sum up all attacked squares
 773       ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
 774                              | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
 775                              | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
 776   }
 777
 778
 779   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
 780
 781   template<Color Us, bool HasPopCnt>
 782   void evaluate_king(const Position& pos, EvalInfo& ei) {
 783
 784     const Color Them = (Us == WHITE ? BLACK : WHITE);
 785     const Square s = pos.king_square(Us);
 786     int shelter = 0;
 787
 788     // King shelter
 789     if (relative_rank(Us, s) <= RANK_4)
 790     {
 791         shelter = ei.pi->get_king_shelter(pos, Us, s);
 792         ei.value += Score(Sign[Us] * Value(shelter), 0);
 793     }
 794
 795     // King safety. This is quite complicated, and is almost certainly far
 796     // from optimally tuned.
 797     if (   pos.piece_count(Them, QUEEN) >= 1
 798         && ei.kingAttackersCount[Them] >= 2
 799         && pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
 800         && ei.kingAdjacentZoneAttacksCount[Them])
 801     {
 802       // Is it the attackers turn to move?
 803       bool sente = (Them == pos.side_to_move());
 804
 805       // Find the attacked squares around the king which has no defenders
 806       // apart from the king itself
 807       Bitboard undefended =
 808              ei.attacked_by(Them)       & ~ei.attacked_by(Us, PAWN)
 809           & ~ei.attacked_by(Us, KNIGHT) & ~ei.attacked_by(Us, BISHOP)
 810           & ~ei.attacked_by(Us, ROOK)   & ~ei.attacked_by(Us, QUEEN)
 811           &  ei.attacked_by(Us, KING);
 812
 813       Bitboard occ = pos.occupied_squares(), b, b2;
 814
 815       // Initialize the 'attackUnits' variable, which is used later on as an
 816       // index to the SafetyTable[] array.  The initial value is based on the
 817       // number and types of the attacking pieces, the number of attacked and
 818       // undefended squares around the king, the square of the king, and the
 819       // quality of the pawn shelter.
 820       int attackUnits =
 821             Min((ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2, 25)
 822           + (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
 823           + InitKingDanger[relative_square(Us, s)] - (shelter >> 5);
 824
 825       // Analyse safe queen contact checks
 826       b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
 827       if (b)
 828       {
 829         Bitboard attackedByOthers =
 830               ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
 831             | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK);
 832
 833         b &= attackedByOthers;
 834         if (b)
 835         {
 836           // The bitboard b now contains the squares available for safe queen
 837           // contact checks.
 838           int count = count_1s_max_15<HasPopCnt>(b);
 839           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
 840
 841           // Is there a mate threat?
 842           if (QueenContactMates && !pos.is_check())
 843           {
 844             Bitboard escapeSquares =
 845                 pos.attacks_from<KING>(s) & ~pos.pieces_of_color(Us) & ~attackedByOthers;
 846
 847             while (b)
 848             {
 849                 Square from, to = pop_1st_bit(&b);
 850                 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
 851                 {
 852                     // We have a mate, unless the queen is pinned or there
 853                     // is an X-ray attack through the queen.
 854                     for (int i = 0; i < pos.piece_count(Them, QUEEN); i++)
 855                     {
 856                         from = pos.piece_list(Them, QUEEN, i);
 857                         if (    bit_is_set(pos.attacks_from<QUEEN>(from), to)
 858                             && !bit_is_set(pos.pinned_pieces(Them), from)
 859                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & pos.pieces(ROOK, QUEEN, Us))
 860                             && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & pos.pieces(BISHOP, QUEEN, Us)))
 861
 862                             ei.mateThreat[Them] = make_move(from, to);
 863                     }
 864                 }
 865             }
 866           }
 867         }
 868       }
 869
 870       // Analyse safe distance checks
 871       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
 872       {
 873           b = pos.attacks_from<ROOK>(s) & ~pos.pieces_of_color(Them) & ~ei.attacked_by(Us);
 874
 875           // Queen checks
 876           b2 = b & ei.attacked_by(Them, QUEEN);
 877           if (b2)
 878               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 879
 880           // Rook checks
 881           b2 = b & ei.attacked_by(Them, ROOK);
 882           if (b2)
 883               attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 884       }
 885       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
 886       {
 887           b = pos.attacks_from<BISHOP>(s) & ~pos.pieces_of_color(Them) & ~ei.attacked_by(Us);
 888
 889           // Queen checks
 890           b2 = b & ei.attacked_by(Them, QUEEN);
 891           if (b2)
 892               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 893
 894           // Bishop checks
 895           b2 = b & ei.attacked_by(Them, BISHOP);
 896           if (b2)
 897               attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 898       }
 899       if (KnightCheckBonus > 0)
 900       {
 901           b = pos.attacks_from<KNIGHT>(s) & ~pos.pieces_of_color(Them) & ~ei.attacked_by(Us);
 902
 903           // Knight checks
 904           b2 = b & ei.attacked_by(Them, KNIGHT);
 905           if (b2)
 906               attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
 907       }
 908
 909       // Analyse discovered checks (only for non-pawns right now, consider
 910       // adding pawns later).
 911       if (DiscoveredCheckBonus)
 912       {
 913         b = pos.discovered_check_candidates(Them) & ~pos.pieces(PAWN);
 914         if (b)
 915           attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
 916       }
 917
 918       // Has a mate threat been found?  We don't do anything here if the
 919       // side with the mating move is the side to move, because in that
 920       // case the mating side will get a huge bonus at the end of the main
 921       // evaluation function instead.
 922       if (ei.mateThreat[Them] != MOVE_NONE)
 923           attackUnits += MateThreatBonus;
 924
 925       // Ensure that attackUnits is between 0 and 99, in order to avoid array
 926       // out of bounds errors:
 927       if (attackUnits < 0)
 928           attackUnits = 0;
 929
 930       if (attackUnits >= 100)
 931           attackUnits = 99;
 932
 933       // Finally, extract the king safety score from the SafetyTable[] array.
 934       // Add the score to the evaluation, and also to ei.futilityMargin.  The
 935       // reason for adding the king safety score to the futility margin is
 936       // that the king safety scores can sometimes be very big, and that
 937       // capturing a single attacking piece can therefore result in a score
 938       // change far bigger than the value of the captured piece.
 939       Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[Us]);
 940
 941       ei.value -= Score(Sign[Us] * v, 0);
 942
 943       if (Us == pos.side_to_move())
 944           ei.futilityMargin += v;
 945     }
 946   }
 947
 948
 949   // evaluate_passed_pawns() evaluates the passed pawns of the given color
 950
 951   template<Color Us>
 952   void evaluate_passed_pawns_of_color(const Position& pos, int movesToGo[], Square pawnToGo[], EvalInfo& ei) {
 953
 954     const Color Them = (Us == WHITE ? BLACK : WHITE);
 955
 956     Bitboard b2, b3, b4;
 957     Square ourKingSq = pos.king_square(Us);
 958     Square theirKingSq = pos.king_square(Them);
 959     Bitboard b = ei.pi->passed_pawns() & pos.pieces(PAWN, Us);
 960
 961     while (b)
 962     {
 963         Square s = pop_1st_bit(&b);
 964
 965         assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
 966         assert(pos.pawn_is_passed(Us, s));
 967
 968         int r = int(relative_rank(Us, s) - RANK_2);
 969         int tr = Max(0, r * (r - 1));
 970
 971         // Base bonus based on rank
 972         Value mbonus = Value(20 * tr);
 973         Value ebonus = Value(10 + r * r * 10);
 974
 975         // Adjust bonus based on king proximity
 976         if (tr)
 977         {
 978             Square blockSq = s + pawn_push(Us);
 979
 980             ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
 981             ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(Us)) * 1 * tr);
 982             ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
 983
 984             // If the pawn is free to advance, increase bonus
 985             if (pos.square_is_empty(blockSq))
 986             {
 987                 // There are no enemy pawns in the pawn's path
 988                 b2 = squares_in_front_of(Us, s);
 989
 990                 assert((b2 & pos.pieces(PAWN, Them)) == EmptyBoardBB);
 991
 992                 // Squares attacked by us
 993                 b4 = b2 & ei.attacked_by(Us);
 994
 995                 // Squares attacked or occupied by enemy pieces
 996                 b3 = b2 & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
 997
 998                 // If there is an enemy rook or queen attacking the pawn from behind,
 999                 // add all X-ray attacks by the rook or queen.
1000                 if (   (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
1001                     && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<QUEEN>(s)))
1002                     b3 = b2;
1003
1004                 // Are any of the squares in the pawn's path attacked or occupied by the enemy?
1005                 if (b3 == EmptyBoardBB)
1006                     // No enemy attacks or pieces, huge bonus!
1007                     // Even bigger if we protect the pawn's path
1008                     ebonus += Value(tr * (b2 == b4 ? 17 : 15));
1009                 else
1010                     // OK, there are enemy attacks or pieces (but not pawns). Are those
1011                     // squares which are attacked by the enemy also attacked by us ?
1012                     // If yes, big bonus (but smaller than when there are no enemy attacks),
1013                     // if no, somewhat smaller bonus.
1014                     ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
1015
1016                 // At last, add a small bonus when there are no *friendly* pieces
1017                 // in the pawn's path.
1018                 if ((b2 & pos.pieces_of_color(Us)) == EmptyBoardBB)
1019                     ebonus += Value(tr);
1020             }
1021         } // tr != 0
1022
1023         // If the pawn is supported by a friendly pawn, increase bonus
1024         b2 = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
1025         if (b2 & rank_bb(s))
1026             ebonus += Value(r * 20);
1027         else if (pos.attacks_from<PAWN>(s, Them) & b2)
1028             ebonus += Value(r * 12);
1029
1030         // If the other side has only a king, check whether the pawn is
1031         // unstoppable
1032         if (pos.non_pawn_material(Them) == Value(0))
1033         {
1034             Square qsq;
1035             int d;
1036
1037             qsq = relative_square(Us, make_square(square_file(s), RANK_8));
1038             d =  square_distance(s, qsq)
1039                - square_distance(theirKingSq, qsq)
1040                + (Us != pos.side_to_move());
1041
1042             if (d < 0)
1043             {
1044                 int mtg = RANK_8 - relative_rank(Us, s);
1045                 int blockerCount = count_1s_max_15(squares_in_front_of(Us,s) & pos.occupied_squares());
1046                 mtg += blockerCount;
1047                 d += blockerCount;
1048                 if (d < 0 && (!movesToGo[Us] || movesToGo[Us] > mtg))
1049                 {
1050                     movesToGo[Us] = mtg;
1051                     pawnToGo[Us] = s;
1052                 }
1053             }
1054         }
1055
1056         // Rook pawns are a special case: They are sometimes worse, and
1057         // sometimes better than other passed pawns. It is difficult to find
1058         // good rules for determining whether they are good or bad. For now,
1059         // we try the following: Increase the value for rook pawns if the
1060         // other side has no pieces apart from a knight, and decrease the
1061         // value if the other side has a rook or queen.
1062         if (square_file(s) == FILE_A || square_file(s) == FILE_H)
1063         {
1064             if (   pos.non_pawn_material(Them) <= KnightValueMidgame
1065                 && pos.piece_count(Them, KNIGHT) <= 1)
1066                 ebonus += ebonus / 4;
1067             else if (pos.pieces(ROOK, QUEEN, Them))
1068                 ebonus -= ebonus / 4;
1069         }
1070
1071         // Add the scores for this pawn to the middle game and endgame eval.
1072         ei.value += Score(apply_weight(Sign[Us] * mbonus, WeightPassedPawnsMidgame),
1073                           apply_weight(Sign[Us] * ebonus, WeightPassedPawnsEndgame));
1074
1075     } // while
1076   }
1077
1078
1079   // evaluate_passed_pawns() evaluates the passed pawns for both sides
1080
1081   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
1082
1083     int movesToGo[2] = {0, 0};
1084     Square pawnToGo[2] = {SQ_NONE, SQ_NONE};
1085
1086     // Evaluate pawns for each color
1087     evaluate_passed_pawns_of_color<WHITE>(pos, movesToGo, pawnToGo, ei);
1088     evaluate_passed_pawns_of_color<BLACK>(pos, movesToGo, pawnToGo, ei);
1089
1090     // Neither side has an unstoppable passed pawn?
1091     if (!(movesToGo[WHITE] | movesToGo[BLACK]))
1092         return;
1093
1094     // Does only one side have an unstoppable passed pawn?
1095     if (!movesToGo[WHITE] || !movesToGo[BLACK])
1096     {
1097         Color winnerSide = movesToGo[WHITE] ? WHITE : BLACK;
1098         ei.value += Score(0, Sign[winnerSide] * (UnstoppablePawnValue - Value(0x40 * movesToGo[winnerSide])));
1099     }
1100     else
1101     {   // Both sides have unstoppable pawns! Try to find out who queens
1102         // first. We begin by transforming 'movesToGo' to the number of
1103         // plies until the pawn queens for both sides.
1104         movesToGo[WHITE] *= 2;
1105         movesToGo[BLACK] *= 2;
1106         movesToGo[pos.side_to_move()]--;
1107
1108         Color winnerSide = movesToGo[WHITE] < movesToGo[BLACK] ? WHITE : BLACK;
1109         Color loserSide = opposite_color(winnerSide);
1110
1111         // If one side queens at least three plies before the other, that side wins
1112         if (movesToGo[winnerSide] <= movesToGo[loserSide] - 3)
1113             ei.value += Score(0, Sign[winnerSide] * (UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2))));
1114
1115         // If one side queens one ply before the other and checks the king or attacks
1116         // the undefended opponent's queening square, that side wins. To avoid cases
1117         // where the opponent's king could move somewhere before first pawn queens we
1118         // consider only free paths to queen for both pawns.
1119         else if (   !(squares_in_front_of(WHITE, pawnToGo[WHITE]) & pos.occupied_squares())
1120                  && !(squares_in_front_of(BLACK, pawnToGo[BLACK]) & pos.occupied_squares()))
1121         {
1122             assert(movesToGo[loserSide] - movesToGo[winnerSide] == 1);
1123
1124             Square winnerQSq = relative_square(winnerSide, make_square(square_file(pawnToGo[winnerSide]), RANK_8));
1125             Square loserQSq = relative_square(loserSide, make_square(square_file(pawnToGo[loserSide]), RANK_8));
1126
1127             Bitboard b = pos.occupied_squares();
1128             clear_bit(&b, pawnToGo[winnerSide]);
1129             clear_bit(&b, pawnToGo[loserSide]);
1130             b = queen_attacks_bb(winnerQSq, b);
1131
1132             if (  (b & pos.pieces(KING, loserSide))
1133                 ||(bit_is_set(b, loserQSq) && !bit_is_set(ei.attacked_by(loserSide), loserQSq)))
1134                 ei.value += Score(0, Sign[winnerSide] * (UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2))));
1135         }
1136     }
1137   }
1138
1139
1140   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1141   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1142   // if it is.
1143
1144   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo &ei) {
1145
1146     assert(square_is_ok(s));
1147     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1148
1149     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1150     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1151
1152     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1153         && pos.see(s, b6) < 0
1154         && pos.see(s, b8) < 0)
1155     {
1156         ei.value -= Sign[us] * Score(TrappedBishopA7H7Penalty, TrappedBishopA7H7Penalty);
1157     }
1158   }
1159
1160
1161   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1162   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1163   // black), and assigns a penalty if it is. This pattern can obviously
1164   // only occur in Chess960 games.
1165
1166   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei) {
1167
1168     Piece pawn = piece_of_color_and_type(us, PAWN);
1169     Square b2, b3, c3;
1170
1171     assert(Chess960);
1172     assert(square_is_ok(s));
1173     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1174
1175     if (square_file(s) == FILE_A)
1176     {
1177         b2 = relative_square(us, SQ_B2);
1178         b3 = relative_square(us, SQ_B3);
1179         c3 = relative_square(us, SQ_C3);
1180     }
1181     else
1182     {
1183         b2 = relative_square(us, SQ_G2);
1184         b3 = relative_square(us, SQ_G3);
1185         c3 = relative_square(us, SQ_F3);
1186     }
1187
1188     if (pos.piece_on(b2) == pawn)
1189     {
1190         Value penalty;
1191
1192         if (!pos.square_is_empty(b3))
1193             penalty = 2*TrappedBishopA1H1Penalty;
1194         else if (pos.piece_on(c3) == pawn)
1195             penalty = TrappedBishopA1H1Penalty;
1196         else
1197             penalty = TrappedBishopA1H1Penalty / 2;
1198
1199         ei.value -= Sign[us] * Score(penalty, penalty);
1200     }
1201   }
1202
1203
1204   // evaluate_space() computes the space evaluation for a given side. The
1205   // space evaluation is a simple bonus based on the number of safe squares
1206   // available for minor pieces on the central four files on ranks 2--4. Safe
1207   // squares one, two or three squares behind a friendly pawn are counted
1208   // twice. Finally, the space bonus is scaled by a weight taken from the
1209   // material hash table.
1210   template<Color Us, bool HasPopCnt>
1211   void evaluate_space(const Position& pos, EvalInfo& ei) {
1212
1213     const Color Them = (Us == WHITE ? BLACK : WHITE);
1214
1215     // Find the safe squares for our pieces inside the area defined by
1216     // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
1217     // pawn, or if it is undefended and attacked by an enemy piece.
1218
1219     Bitboard safeSquares =   SpaceMask[Us]
1220                           & ~pos.pieces(PAWN, Us)
1221                           & ~ei.attacked_by(Them, PAWN)
1222                           & ~(~ei.attacked_by(Us) & ei.attacked_by(Them));
1223
1224     // Find all squares which are at most three squares behind some friendly
1225     // pawn.
1226     Bitboard behindFriendlyPawns = pos.pieces(PAWN, Us);
1227     behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >>  8 : behindFriendlyPawns <<  8);
1228     behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >> 16 : behindFriendlyPawns << 16);
1229
1230     int space =  count_1s_max_15<HasPopCnt>(safeSquares)
1231                + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
1232
1233     ei.value += Sign[Us] * Score(apply_weight(Value(space * ei.mi->space_weight()), WeightSpace), 0);
1234   }
1235
1236
1237   // apply_weight() applies an evaluation weight to a value
1238
1239   inline Value apply_weight(Value v, int w) {
1240     return (v*w) / 0x100;
1241   }
1242
1243
1244   // scale_by_game_phase() interpolates between a middle game and an endgame
1245   // score, based on game phase.  It also scales the return value by a
1246   // ScaleFactor array.
1247
1248   Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]) {
1249
1250     assert(v.mg() > -VALUE_INFINITE && v.mg() < VALUE_INFINITE);
1251     assert(v.eg() > -VALUE_INFINITE && v.eg() < VALUE_INFINITE);
1252     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1253
1254     Value ev = apply_scale_factor(v.eg(), sf[(v.eg() > Value(0) ? WHITE : BLACK)]);
1255
1256     Value result = Value(int((v.mg() * ph + ev * (128 - ph)) / 128));
1257     return Value(int(result) & ~(GrainSize - 1));
1258   }
1259
1260
1261   // weight_option() computes the value of an evaluation weight, by combining
1262   // an UCI-configurable weight with an internal weight.
1263
1264   int weight_option(const std::string& opt, int internalWeight) {
1265
1266     int uciWeight = get_option_value_int(opt);
1267     uciWeight = (uciWeight * 0x100) / 100;
1268     return (uciWeight * internalWeight) / 0x100;
1269   }
1270
1271
1272   // init_safety() initizes the king safety evaluation, based on UCI
1273   // parameters.  It is called from read_weights().
1274
1275   void init_safety() {
1276
1277     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1278     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
1279     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
1280     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
1281     KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
1282     DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
1283     MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
1284
1285     int maxSlope = get_option_value_int("King Safety Max Slope");
1286     int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
1287     double a     = get_option_value_int("King Safety Coefficient") / 100.0;
1288     double b     = get_option_value_int("King Safety X Intercept");
1289     bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
1290     bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
1291
1292     for (int i = 0; i < 100; i++)
1293     {
1294         if (i < b)
1295             SafetyTable[i] = Value(0);
1296         else if (quad)
1297             SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1298         else if (linear)
1299             SafetyTable[i] = Value((int)(100 * a * (i - b)));
1300     }
1301
1302     for (int i = 0; i < 100; i++)
1303     {
1304         if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1305             for (int j = i + 1; j < 100; j++)
1306                 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1307
1308         if (SafetyTable[i]  > Value(peak))
1309             SafetyTable[i] = Value(peak);
1310     }
1311   }
1312 }
1313
1314 std::ostream& operator<<(std::ostream &os, Score s) {
1315
1316     return os << "(" << s.mg() << ", " << s.eg() << ")";
1317 }