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