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