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