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