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 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 "evaluate.h"
  29 #include "material.h"
  30 #include "pawns.h"
  31 #include "scale.h"
  32 #include "thread.h"
  33 #include "ucioption.h"
  34
  35
  36 ////
  37 //// Local definitions
  38 ////
  39
  40 namespace {
  41
  42   const int Sign[2] = {1, -1};
  43
  44   // Evaluation grain size, must be a power of 2.
  45   const int GrainSize = 4;
  46
  47   // Evaluation weights
  48   int WeightMobilityMidgame      = 0x100;
  49   int WeightMobilityEndgame      = 0x100;
  50   int WeightPawnStructureMidgame = 0x100;
  51   int WeightPawnStructureEndgame = 0x100;
  52   int WeightPassedPawnsMidgame   = 0x100;
  53   int WeightPassedPawnsEndgame   = 0x100;
  54   int WeightKingSafety[2] = { 0x100, 0x100 };
  55   int WeightSpace;
  56
  57   // Internal evaluation weights.  These are applied on top of the evaluation
  58   // weights read from UCI parameters.  The purpose is to be able to change
  59   // the evaluation weights while keeping the default values of the UCI
  60   // parameters at 100, which looks prettier.
  61   const int WeightMobilityMidgameInternal      = 0x100;
  62   const int WeightMobilityEndgameInternal      = 0x100;
  63   const int WeightPawnStructureMidgameInternal = 0x100;
  64   const int WeightPawnStructureEndgameInternal = 0x100;
  65   const int WeightPassedPawnsMidgameInternal   = 0x100;
  66   const int WeightPassedPawnsEndgameInternal   = 0x100;
  67   const int WeightKingSafetyInternal           = 0x110;
  68   const int WeightKingOppSafetyInternal        = 0x110;
  69   const int WeightSpaceInternal                = 0x30;
  70
  71   // Visually better to define tables constants
  72   typedef Value V;
  73
  74   // Knight mobility bonus in middle game and endgame, indexed by the number
  75   // of attacked squares not occupied by friendly piecess.
  76   const Value MidgameKnightMobilityBonus[] = {
  77   //    0       1      2     3      4      5      6      7      8
  78     V(-30), V(-20),V(-10), V(0), V(10), V(20), V(25), V(30), V(30)
  79   };
  80
  81   const Value EndgameKnightMobilityBonus[] = {
  82   //    0       1      2     3      4      5      6      7      8
  83     V(-30), V(-20),V(-10), V(0), V(10), V(20), V(25), V(30), V(30)
  84   };
  85
  86   // Bishop mobility bonus in middle game and endgame, indexed by the number
  87   // of attacked squares not occupied by friendly pieces.  X-ray attacks through
  88   // queens are also included.
  89   const Value MidgameBishopMobilityBonus[] = {
  90   //    0       1      2      3      4      5      6      7
  91     V(-30), V(-15),  V(0), V(15), V(30), V(45), V(58), V(66),
  92   //    8       9     10     11     12     13     14     15
  93     V( 72), V( 76), V(78), V(80), V(81), V(82), V(83), V(83)
  94   };
  95
  96   const Value EndgameBishopMobilityBonus[] = {
  97   //    0       1      2      3      4      5      6      7
  98     V(-30), V(-15),  V(0), V(15), V(30), V(45), V(58), V(66),
  99   //    8       9     10     11     12     13     14     15
 100     V( 72), V( 76), V(78), V(80), V(81), V(82), V(83), V(83)
 101   };
 102
 103   // Rook mobility bonus in middle game and endgame, indexed by the number
 104   // of attacked squares not occupied by friendly pieces.  X-ray attacks through
 105   // queens and rooks are also included.
 106   const Value MidgameRookMobilityBonus[] = {
 107   //    0       1      2      3      4      5      6      7
 108     V(-18), V(-12), V(-6),  V(0),  V(6), V(12), V(16), V(21),
 109   //    8       9     10     11     12     13     14     15
 110     V( 24), V( 27), V(28), V(29), V(30), V(31), V(32), V(33)
 111   };
 112
 113   const Value EndgameRookMobilityBonus[] = {
 114   //    0       1      2      3      4      5      6      7
 115     V(-30), V(-18), V(-6),  V(6), V(18), V(30), V(42), V(54),
 116   //    8       9     10     11     12     13     14     15
 117     V( 66), V( 74), V(78), V(80), V(81), V(82), V(83), V(83)
 118   };
 119
 120   // Queen mobility bonus in middle game and endgame, indexed by the number
 121   // of attacked squares not occupied by friendly pieces.
 122   const Value MidgameQueenMobilityBonus[] = {
 123   //    0      1      2      3      4      5      6      7
 124     V(-10), V(-8), V(-6), V(-4), V(-2), V( 0), V( 2), V( 4),
 125   //    8      9     10     11     12     13     14     15
 126     V(  6), V( 8), V(10), V(12), V(13), V(14), V(15), V(16),
 127   //   16     17     18     19     20     21     22     23
 128     V( 16), V(16), V(16), V(16), V(16), V(16), V(16), V(16),
 129   //   24     25     26     27     28     29     30     31
 130     V( 16), V(16), V(16), V(16), V(16), V(16), V(16), V(16)
 131   };
 132
 133   const Value EndgameQueenMobilityBonus[] = {
 134   //    0      1      2      3      4      5      6      7
 135     V(-20),V(-15),V(-10), V(-5), V( 0), V( 5), V(10), V(15),
 136   //    8      9     10     11     12     13     14     15
 137     V( 19), V(23), V(27), V(29), V(30), V(30), V(30), V(30),
 138   //   16     17     18     19     20     21     22     23
 139     V( 30), V(30), V(30), V(30), V(30), V(30), V(30), V(30),
 140   //   24     25     26     27     28     29     30     31
 141     V( 30), V(30), V(30), V(30), V(30), V(30), V(30), V(30)
 142   };
 143
 144   // Outpost bonuses for knights and bishops, indexed by square (from white's
 145   // point of view).
 146   const Value KnightOutpostBonus[64] = {
 147   //  A     B     C     D     E     F     G     H
 148     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
 149     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
 150     V(0), V(0), V(5),V(10),V(10), V(5), V(0), V(0), // 3
 151     V(0), V(5),V(20),V(30),V(30),V(20), V(5), V(0), // 4
 152     V(0),V(10),V(30),V(40),V(40),V(30),V(10), V(0), // 5
 153     V(0), V(5),V(20),V(20),V(20),V(20), V(5), V(0), // 6
 154     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
 155     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
 156   };
 157
 158   const Value BishopOutpostBonus[64] = {
 159   //  A     B     C     D     E     F     G     H
 160     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
 161     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
 162     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), // 3
 163     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), // 4
 164     V(0),V(10),V(20),V(20),V(20),V(20),V(10), V(0), // 5
 165     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0), // 6
 166     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
 167     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
 168   };
 169
 170   // Bonus for unstoppable passed pawns:
 171   const Value UnstoppablePawnValue = Value(0x500);
 172
 173   // Rooks and queens on the 7th rank:
 174   const Value MidgameRookOn7thBonus  = Value(50);
 175   const Value EndgameRookOn7thBonus  = Value(100);
 176   const Value MidgameQueenOn7thBonus = Value(25);
 177   const Value EndgameQueenOn7thBonus = Value(50);
 178
 179   // Rooks on open files:
 180   const Value RookOpenFileBonus     = Value(40);
 181   const Value RookHalfOpenFileBonus = Value(20);
 182
 183   // Penalty for rooks trapped inside a friendly king which has lost the
 184   // right to castle:
 185   const Value TrappedRookPenalty = Value(180);
 186
 187   // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
 188   // enemy pawns:
 189   const Value TrappedBishopA7H7Penalty = Value(300);
 190
 191   // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black):
 192   const Bitboard MaskA7H7[2] = {
 193     ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
 194     ((1ULL << SQ_A2) | (1ULL << SQ_H2))
 195   };
 196
 197   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
 198   // a friendly pawn on b2/g2 (b7/g7 for black).  This can obviously only
 199   // happen in Chess960 games.
 200   const Value TrappedBishopA1H1Penalty = Value(100);
 201
 202   // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black):
 203   const Bitboard MaskA1H1[2] = {
 204     ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
 205     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
 206   };
 207
 208   // The SpaceMask[color] contains area of the board which is consdered by
 209   // the space evaluation.  In the middle game, each side is given a bonus
 210   // based on how many squares inside this area are safe and available for
 211   // friendly minor pieces.
 212   const Bitboard SpaceMask[2] = {
 213     (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
 214     (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
 215     (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
 216     (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
 217     (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
 218     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
 219   };
 220
 221   /// King safety constants and variables.  The king safety scores are taken
 222   /// from the array SafetyTable[].  Various little "meta-bonuses" measuring
 223   /// the strength of the attack are added up into an integer, which is used
 224   /// as an index to SafetyTable[].
 225
 226   // Attack weights for each piece type.
 227   const int QueenAttackWeight  = 5;
 228   const int RookAttackWeight   = 3;
 229   const int BishopAttackWeight = 2;
 230   const int KnightAttackWeight = 2;
 231
 232   // Bonuses for safe checks for each piece type.
 233   int QueenContactCheckBonus = 3;
 234   int QueenCheckBonus        = 2;
 235   int RookCheckBonus         = 1;
 236   int BishopCheckBonus       = 1;
 237   int KnightCheckBonus       = 1;
 238   int DiscoveredCheckBonus   = 3;
 239
 240   // Scan for queen contact mates?
 241   const bool QueenContactMates = true;
 242
 243   // Bonus for having a mate threat.
 244   int MateThreatBonus = 3;
 245
 246   // InitKingDanger[] contains bonuses based on the position of the defending
 247   // king.
 248   const int InitKingDanger[64] = {
 249      2,  0,  2,  5,  5,  2,  0,  2,
 250      2,  2,  4,  8,  8,  4,  2,  2,
 251      7, 10, 12, 12, 12, 12, 10,  7,
 252     15, 15, 15, 15, 15, 15, 15, 15,
 253     15, 15, 15, 15, 15, 15, 15, 15,
 254     15, 15, 15, 15, 15, 15, 15, 15,
 255     15, 15, 15, 15, 15, 15, 15, 15,
 256     15, 15, 15, 15, 15, 15, 15, 15
 257   };
 258
 259   // SafetyTable[] contains the actual king safety scores.  It is initialized
 260   // in init_safety().
 261   Value SafetyTable[100];
 262
 263   // Pawn and material hash tables, indexed by the current thread id
 264   PawnInfoTable *PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 265   MaterialInfoTable *MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 266
 267   // Sizes of pawn and material hash tables
 268   const int PawnTableSize = 16384;
 269   const int MaterialTableSize = 1024;
 270
 271   // Array which gives the number of nonzero bits in an 8-bit integer:
 272   uint8_t BitCount8Bit[256];
 273
 274   // Function prototypes
 275   template<PieceType Piece>
 276   void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
 277
 278   template<>
 279   void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo &ei);
 280
 281   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
 282   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
 283                                     EvalInfo &ei);
 284   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
 285                                     EvalInfo &ei);
 286
 287   void evaluate_space(const Position &p, Color us, EvalInfo &ei);
 288   inline Value apply_weight(Value v, int w);
 289   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 290
 291   int count_1s_8bit(Bitboard b);
 292
 293   int compute_weight(int uciWeight, int internalWeight);
 294   int weight_option(const std::string& opt, int weight);
 295   void init_safety();
 296
 297 }
 298
 299
 300 ////
 301 //// Functions
 302 ////
 303
 304 /// evaluate() is the main evaluation function.  It always computes two
 305 /// values, an endgame score and a middle game score, and interpolates
 306 /// between them based on the remaining material.
 307
 308 Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
 309
 310   assert(pos.is_ok());
 311   assert(threadID >= 0 && threadID < THREAD_MAX);
 312
 313   memset(&ei, 0, sizeof(EvalInfo));
 314
 315   // Initialize by reading the incrementally updated scores included in the
 316   // position object (material + piece square tables)
 317   ei.mgValue = pos.mg_value();
 318   ei.egValue = pos.eg_value();
 319
 320   // Probe the material hash table
 321   ei.mi = MaterialTable[threadID]->get_material_info(pos);
 322   ei.mgValue += ei.mi->mg_value();
 323   ei.egValue += ei.mi->eg_value();
 324
 325   // If we have a specialized evaluation function for the current material
 326   // configuration, call it and return
 327   if (ei.mi->specialized_eval_exists())
 328       return ei.mi->evaluate(pos);
 329
 330   // After get_material_info() call that modifies them
 331   ScaleFactor factor[2];
 332   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
 333   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
 334
 335   // Probe the pawn hash table
 336   ei.pi = PawnTable[threadID]->get_pawn_info(pos);
 337   ei.mgValue += apply_weight(ei.pi->mg_value(), WeightPawnStructureMidgame);
 338   ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
 339
 340   // Initialize king attack bitboards and king attack zones for both sides
 341   ei.attackedBy[WHITE][KING] = pos.piece_attacks<KING>(pos.king_square(WHITE));
 342   ei.attackedBy[BLACK][KING] = pos.piece_attacks<KING>(pos.king_square(BLACK));
 343   ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
 344   ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
 345
 346   // Initialize pawn attack bitboards for both sides
 347   ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
 348   ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
 349   ei.kingAttackersCount[WHITE] = count_1s_max_15(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
 350   ei.kingAttackersCount[BLACK] = count_1s_max_15(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
 351
 352   // Evaluate pieces
 353   for (Color c = WHITE; c <= BLACK; c++)
 354   {
 355       evaluate_pieces<KNIGHT>(pos, c, ei);
 356       evaluate_pieces<BISHOP>(pos, c, ei);
 357       evaluate_pieces<ROOK>(pos, c, ei);
 358       evaluate_pieces<QUEEN>(pos, c, ei);
 359
 360       // Sum up all attacked squares
 361       ei.attackedBy[c][0] =   ei.attackedBy[c][PAWN]   | ei.attackedBy[c][KNIGHT]
 362                             | ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
 363                             | ei.attackedBy[c][QUEEN]  | ei.attackedBy[c][KING];
 364   }
 365
 366   // Kings.  Kings are evaluated after all other pieces for both sides,
 367   // because we need complete attack information for all pieces when computing
 368   // the king safety evaluation.
 369   for (Color c = WHITE; c <= BLACK; c++)
 370       evaluate_pieces<KING>(pos, c, ei);
 371
 372   // Evaluate passed pawns.  We evaluate passed pawns for both sides at once,
 373   // because we need to know which side promotes first in positions where
 374   // both sides have an unstoppable passed pawn.
 375   if (ei.pi->passed_pawns())
 376       evaluate_passed_pawns(pos, ei);
 377
 378   Phase phase = pos.game_phase();
 379
 380   // Middle-game specific evaluation terms
 381   if (phase > PHASE_ENDGAME)
 382   {
 383     // Pawn storms in positions with opposite castling.
 384     if (   square_file(pos.king_square(WHITE)) >= FILE_E
 385         && square_file(pos.king_square(BLACK)) <= FILE_D)
 386
 387         ei.mgValue += ei.pi->queenside_storm_value(WHITE)
 388                     - ei.pi->kingside_storm_value(BLACK);
 389
 390     else if (   square_file(pos.king_square(WHITE)) <= FILE_D
 391              && square_file(pos.king_square(BLACK)) >= FILE_E)
 392
 393         ei.mgValue += ei.pi->kingside_storm_value(WHITE)
 394                     - ei.pi->queenside_storm_value(BLACK);
 395
 396     // Evaluate space for both sides
 397     if (ei.mi->space_weight() > 0)
 398     {
 399         evaluate_space(pos, WHITE, ei);
 400         evaluate_space(pos, BLACK, ei);
 401     }
 402   }
 403
 404   // Mobility
 405   ei.mgValue += apply_weight(ei.mgMobility, WeightMobilityMidgame);
 406   ei.egValue += apply_weight(ei.egMobility, WeightMobilityEndgame);
 407
 408   // If we don't already have an unusual scale factor, check for opposite
 409   // colored bishop endgames, and use a lower scale for those
 410   if (   phase < PHASE_MIDGAME
 411       && pos.opposite_colored_bishops()
 412       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
 413           || (factor[BLACK] == SCALE_FACTOR_NORMAL && ei.egValue < Value(0))))
 414   {
 415       ScaleFactor sf;
 416
 417       // Only the two bishops ?
 418       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
 419           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
 420       {
 421           // Check for KBP vs KB with only a single pawn that is almost
 422           // certainly a draw or at least two pawns.
 423           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
 424           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
 425       }
 426       else
 427           // Endgame with opposite-colored bishops, but also other pieces. Still
 428           // a bit drawish, but not as drawish as with only the two bishops.
 429            sf = ScaleFactor(50);
 430
 431       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
 432           factor[WHITE] = sf;
 433       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
 434           factor[BLACK] = sf;
 435   }
 436
 437   // Interpolate between the middle game and the endgame score, and
 438   // return
 439   Color stm = pos.side_to_move();
 440
 441   Value v = Sign[stm] * scale_by_game_phase(ei.mgValue, ei.egValue, phase, factor);
 442
 443   return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
 444 }
 445
 446
 447 /// quick_evaluate() does a very approximate evaluation of the current position.
 448 /// It currently considers only material and piece square table scores.  Perhaps
 449 /// we should add scores from the pawn and material hash tables?
 450
 451 Value quick_evaluate(const Position &pos) {
 452
 453   assert(pos.is_ok());
 454
 455   static const
 456   ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
 457
 458   Value mgv = pos.mg_value();
 459   Value egv = pos.eg_value();
 460   Phase ph = pos.game_phase();
 461   Color stm = pos.side_to_move();
 462
 463   return Sign[stm] * scale_by_game_phase(mgv, egv, ph, sf);
 464 }
 465
 466
 467 /// init_eval() initializes various tables used by the evaluation function.
 468
 469 void init_eval(int threads) {
 470
 471   assert(threads <= THREAD_MAX);
 472
 473   for (int i = 0; i < THREAD_MAX; i++)
 474   {
 475     if (i >= threads)
 476     {
 477         delete PawnTable[i];
 478         delete MaterialTable[i];
 479         PawnTable[i] = NULL;
 480         MaterialTable[i] = NULL;
 481         continue;
 482     }
 483     if (!PawnTable[i])
 484         PawnTable[i] = new PawnInfoTable(PawnTableSize);
 485     if (!MaterialTable[i])
 486         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
 487   }
 488
 489   for (Bitboard b = 0ULL; b < 256ULL; b++)
 490       BitCount8Bit[b] = count_1s(b);
 491 }
 492
 493
 494 /// quit_eval() releases heap-allocated memory at program termination.
 495
 496 void quit_eval() {
 497
 498   for (int i = 0; i < THREAD_MAX; i++)
 499   {
 500       delete PawnTable[i];
 501       delete MaterialTable[i];
 502   }
 503 }
 504
 505
 506 /// read_weights() reads evaluation weights from the corresponding UCI
 507 /// parameters.
 508
 509 void read_weights(Color us) {
 510
 511   WeightMobilityMidgame      = weight_option("Mobility (Middle Game)", WeightMobilityMidgameInternal);
 512   WeightMobilityEndgame      = weight_option("Mobility (Endgame)", WeightMobilityEndgameInternal);
 513   WeightPawnStructureMidgame = weight_option("Pawn Structure (Middle Game)", WeightPawnStructureMidgameInternal);
 514   WeightPawnStructureEndgame = weight_option("Pawn Structure (Endgame)", WeightPawnStructureEndgameInternal);
 515   WeightPassedPawnsMidgame   = weight_option("Passed Pawns (Middle Game)", WeightPassedPawnsMidgameInternal);
 516   WeightPassedPawnsEndgame   = weight_option("Passed Pawns (Endgame)", WeightPassedPawnsEndgameInternal);
 517
 518   Color them = opposite_color(us);
 519
 520   WeightKingSafety[us]   = weight_option("Cowardice", WeightKingSafetyInternal);
 521   WeightKingSafety[them] = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
 522   WeightSpace = weight_option("Space", WeightSpaceInternal);
 523
 524   init_safety();
 525 }
 526
 527
 528 namespace {
 529
 530   // evaluate_common() computes terms common to all pieces attack
 531
 532   template<PieceType Piece>
 533   int evaluate_common(const Position& p, const Bitboard& b, Color us, EvalInfo& ei, Square s = SQ_NONE) {
 534
 535     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
 536     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
 537     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
 538     static const Value* OutpostBonus[] = { 0, 0, KnightOutpostBonus, BishopOutpostBonus, 0, 0 };
 539
 540     Color them = opposite_color(us);
 541
 542     // Update attack info
 543     ei.attackedBy[us][Piece] |= b;
 544
 545     // King attack
 546     if (b & ei.kingZone[us])
 547     {
 548         ei.kingAttackersCount[us]++;
 549         ei.kingAttackersWeight[us] += AttackWeight[Piece];
 550         Bitboard bb = (b & ei.attackedBy[them][KING]);
 551         if (bb)
 552             ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15(bb);
 553     }
 554
 555     // Remove squares protected by enemy pawns
 556     Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
 557
 558     // Mobility
 559     int mob = (Piece != QUEEN ? count_1s_max_15(bb & ~p.pieces_of_color(us))
 560                               : count_1s(bb & ~p.pieces_of_color(us)));
 561
 562     ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
 563     ei.egMobility += Sign[us] * EgBonus[Piece][mob];
 564
 565     // Bishop and Knight outposts
 566     if (  (Piece != BISHOP && Piece != KNIGHT) // compile time condition
 567         || !p.square_is_weak(s, them))
 568         return mob;
 569
 570     // Initial bonus based on square
 571     Value v, bonus;
 572     v = bonus = OutpostBonus[Piece][relative_square(us, s)];
 573
 574     // Increase bonus if supported by pawn, especially if the opponent has
 575     // no minor piece which can exchange the outpost piece
 576     if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
 577     {
 578         bonus += v / 2;
 579         if (   p.piece_count(them, KNIGHT) == 0
 580             && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
 581             bonus += v;
 582     }
 583     ei.mgValue += Sign[us] * bonus;
 584     ei.egValue += Sign[us] * bonus;
 585     return mob;
 586   }
 587
 588
 589   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
 590   // color.
 591
 592   template<PieceType Piece>
 593   void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
 594
 595     Bitboard b;
 596     Square s, ksq;
 597     Color them;
 598     int mob;
 599     File f;
 600
 601     for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
 602     {
 603         s = pos.piece_list(us, Piece, i);
 604
 605         if (Piece == KNIGHT || Piece == QUEEN)
 606             b = pos.piece_attacks<Piece>(s);
 607         else if (Piece == BISHOP)
 608             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.queens(us));
 609         else if (Piece == ROOK)
 610             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
 611
 612         // Attacks, mobility and outposts
 613         mob = evaluate_common<Piece>(pos, b, us, ei, s);
 614
 615         // Special patterns: trapped bishops on a7/h7/a2/h2
 616         // and trapped bishops on a1/h1/a8/h8 in Chess960.
 617         if (Piece == BISHOP)
 618         {
 619             if (bit_is_set(MaskA7H7[us], s))
 620                 evaluate_trapped_bishop_a7h7(pos, s, us, ei);
 621
 622             if (Chess960 && bit_is_set(MaskA1H1[us], s))
 623                 evaluate_trapped_bishop_a1h1(pos, s, us, ei);
 624         }
 625
 626         if (Piece != ROOK && Piece != QUEEN)
 627             continue;
 628
 629         // Queen or rook on 7th rank
 630         them = opposite_color(us);
 631
 632         if (   relative_rank(us, s) == RANK_7
 633             && relative_rank(us, pos.king_square(them)) == RANK_8)
 634         {
 635             ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
 636             ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
 637         }
 638
 639         // Special extra evaluation for rooks
 640         if (Piece != ROOK)
 641             continue;
 642
 643         // Open and half-open files
 644         f = square_file(s);
 645         if (ei.pi->file_is_half_open(us, f))
 646         {
 647             if (ei.pi->file_is_half_open(them, f))
 648             {
 649                 ei.mgValue += Sign[us] * RookOpenFileBonus;
 650                 ei.egValue += Sign[us] * RookOpenFileBonus;
 651             }
 652             else
 653             {
 654                 ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
 655                 ei.egValue += Sign[us] * RookHalfOpenFileBonus;
 656             }
 657         }
 658
 659         // Penalize rooks which are trapped inside a king. Penalize more if
 660         // king has lost right to castle.
 661         if (mob > 6 || ei.pi->file_is_half_open(us, f))
 662             continue;
 663
 664         ksq = pos.king_square(us);
 665
 666         if (    square_file(ksq) >= FILE_E
 667             &&  square_file(s) > square_file(ksq)
 668             && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 669         {
 670             // Is there a half-open file between the king and the edge of the board?
 671             if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
 672                 ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
 673                                                 : Sign[us] *  (TrappedRookPenalty - mob * 16);
 674         }
 675         else if (    square_file(ksq) <= FILE_D
 676                  &&  square_file(s) < square_file(ksq)
 677                  && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 678         {
 679             // Is there a half-open file between the king and the edge of the board?
 680             if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
 681                 ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
 682                                                 : Sign[us] * (TrappedRookPenalty - mob * 16);
 683         }
 684     }
 685   }
 686
 687   inline Bitboard shiftRowsDown(const Bitboard& b, int num) {
 688
 689     return b >> (num << 3);
 690   }
 691
 692   // evaluate_pieces<KING>() assigns bonuses and penalties to a king of a given
 693   // color.
 694
 695   template<>
 696   void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo& ei) {
 697
 698     int shelter = 0, sign = Sign[us];
 699     Square s = p.king_square(us);
 700
 701     // King shelter
 702     if (relative_rank(us, s) <= RANK_4)
 703     {
 704         Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
 705         Rank r = square_rank(s);
 706         for (int i = 1; i < 4; i++)
 707             shelter += count_1s_8bit(shiftRowsDown(pawns, r+i*sign)) * (128>>i);
 708
 709         ei.mgValue += sign * Value(shelter);
 710     }
 711
 712     // King safety.  This is quite complicated, and is almost certainly far
 713     // from optimally tuned.
 714     Color them = opposite_color(us);
 715
 716     if (   p.piece_count(them, QUEEN) >= 1
 717         && ei.kingAttackersCount[them] >= 2
 718         && p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
 719         && ei.kingAdjacentZoneAttacksCount[them])
 720     {
 721       // Is it the attackers turn to move?
 722       bool sente = (them == p.side_to_move());
 723
 724       // Find the attacked squares around the king which has no defenders
 725       // apart from the king itself
 726       Bitboard undefended =
 727              ei.attacked_by(them)       & ~ei.attacked_by(us, PAWN)
 728           & ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP)
 729           & ~ei.attacked_by(us, ROOK)   & ~ei.attacked_by(us, QUEEN)
 730           & ei.attacked_by(us, KING);
 731
 732       Bitboard occ = p.occupied_squares(), b, b2;
 733
 734       // Initialize the 'attackUnits' variable, which is used later on as an
 735       // index to the SafetyTable[] array.  The initial value is based on the
 736       // number and types of the attacking pieces, the number of attacked and
 737       // undefended squares around the king, the square of the king, and the
 738       // quality of the pawn shelter.
 739       int attackUnits =
 740             Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
 741           + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15(undefended)) * 3
 742           + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
 743
 744       // Analyse safe queen contact checks
 745       b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them);
 746       if (b)
 747       {
 748         Bitboard attackedByOthers =
 749               ei.attacked_by(them, PAWN)   | ei.attacked_by(them, KNIGHT)
 750             | ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK);
 751
 752         b &= attackedByOthers;
 753         if (b)
 754         {
 755           // The bitboard b now contains the squares available for safe queen
 756           // contact checks.
 757           int count = count_1s_max_15(b);
 758           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
 759
 760           // Is there a mate threat?
 761           if (QueenContactMates && !p.is_check())
 762           {
 763             Bitboard escapeSquares =
 764                 p.piece_attacks<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
 765
 766             while (b)
 767             {
 768                 Square from, to = pop_1st_bit(&b);
 769                 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
 770                 {
 771                     // We have a mate, unless the queen is pinned or there
 772                     // is an X-ray attack through the queen.
 773                     for (int i = 0; i < p.piece_count(them, QUEEN); i++)
 774                     {
 775                         from = p.piece_list(them, QUEEN, i);
 776                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
 777                             && !bit_is_set(p.pinned_pieces(them), from)
 778                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
 779                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us)))
 780
 781                             ei.mateThreat[them] = make_move(from, to);
 782                     }
 783                 }
 784             }
 785           }
 786         }
 787       }
 788
 789       // Analyse safe distance checks
 790       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
 791       {
 792           b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 793
 794           // Queen checks
 795           b2 = b & ei.attacked_by(them, QUEEN);
 796           if( b2)
 797               attackUnits += QueenCheckBonus * count_1s_max_15(b2);
 798
 799           // Rook checks
 800           b2 = b & ei.attacked_by(them, ROOK);
 801           if (b2)
 802               attackUnits += RookCheckBonus * count_1s_max_15(b2);
 803       }
 804       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
 805       {
 806           b = p.piece_attacks<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 807
 808           // Queen checks
 809           b2 = b & ei.attacked_by(them, QUEEN);
 810           if (b2)
 811               attackUnits += QueenCheckBonus * count_1s_max_15(b2);
 812
 813           // Bishop checks
 814           b2 = b & ei.attacked_by(them, BISHOP);
 815           if (b2)
 816               attackUnits += BishopCheckBonus * count_1s_max_15(b2);
 817       }
 818       if (KnightCheckBonus > 0)
 819       {
 820           b = p.piece_attacks<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 821
 822           // Knight checks
 823           b2 = b & ei.attacked_by(them, KNIGHT);
 824           if (b2)
 825               attackUnits += KnightCheckBonus * count_1s_max_15(b2);
 826       }
 827
 828       // Analyse discovered checks (only for non-pawns right now, consider
 829       // adding pawns later).
 830       if (DiscoveredCheckBonus)
 831       {
 832         b = p.discovered_check_candidates(them) & ~p.pawns();
 833         if (b)
 834           attackUnits += DiscoveredCheckBonus * count_1s_max_15(b) * (sente? 2 : 1);
 835       }
 836
 837       // Has a mate threat been found?  We don't do anything here if the
 838       // side with the mating move is the side to move, because in that
 839       // case the mating side will get a huge bonus at the end of the main
 840       // evaluation function instead.
 841       if (ei.mateThreat[them] != MOVE_NONE)
 842           attackUnits += MateThreatBonus;
 843
 844       // Ensure that attackUnits is between 0 and 99, in order to avoid array
 845       // out of bounds errors:
 846       if (attackUnits < 0)
 847           attackUnits = 0;
 848
 849       if (attackUnits >= 100)
 850           attackUnits = 99;
 851
 852       // Finally, extract the king safety score from the SafetyTable[] array.
 853       // Add the score to the evaluation, and also to ei.futilityMargin.  The
 854       // reason for adding the king safety score to the futility margin is
 855       // that the king safety scores can sometimes be very big, and that
 856       // capturing a single attacking piece can therefore result in a score
 857       // change far bigger than the value of the captured piece.
 858       Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]);
 859
 860       ei.mgValue -= sign * v;
 861
 862       if (us == p.side_to_move())
 863           ei.futilityMargin += v;
 864     }
 865   }
 866
 867
 868   // evaluate_passed_pawns() evaluates the passed pawns for both sides.
 869
 870   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei) {
 871
 872     bool hasUnstoppable[2] = {false, false};
 873     int movesToGo[2] = {100, 100};
 874
 875     for (Color us = WHITE; us <= BLACK; us++)
 876     {
 877         Color them = opposite_color(us);
 878         Square ourKingSq = pos.king_square(us);
 879         Square theirKingSq = pos.king_square(them);
 880         Bitboard b = ei.pi->passed_pawns() & pos.pawns(us), b2, b3, b4;
 881
 882         while (b)
 883         {
 884             Square s = pop_1st_bit(&b);
 885
 886             assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
 887             assert(pos.pawn_is_passed(us, s));
 888
 889             int r = int(relative_rank(us, s) - RANK_2);
 890             int tr = Max(0, r * (r - 1));
 891             Square blockSq = s + pawn_push(us);
 892
 893             // Base bonus based on rank
 894             Value mbonus = Value(20 * tr);
 895             Value ebonus = Value(10 + r * r * 10);
 896
 897             // Adjust bonus based on king proximity
 898             if (tr != 0)
 899             {
 900                 ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
 901                 ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
 902                 ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
 903
 904                 // If the pawn is free to advance, increase bonus
 905                 if (pos.square_is_empty(blockSq))
 906                 {
 907                     b2 = squares_in_front_of(us, s);
 908                     b3 = b2 & ei.attacked_by(them);
 909                     b4 = b2 & ei.attacked_by(us);
 910
 911                     // If there is an enemy rook or queen attacking the pawn from behind,
 912                     // add all X-ray attacks by the rook or queen.
 913                     if (    bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
 914                         && (squares_behind(us, s) & pos.rooks_and_queens(them)))
 915                         b3 = b2;
 916
 917                     if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
 918                     {
 919                         // There are no enemy pieces in the pawn's path! Are any of the
 920                         // squares in the pawn's path attacked by the enemy?
 921                         if (b3 == EmptyBoardBB)
 922                             // No enemy attacks, huge bonus!
 923                             ebonus += Value(tr * (b2 == b4 ? 17 : 15));
 924                         else
 925                             // OK, there are enemy attacks. Are those squares which are
 926                             // attacked by the enemy also attacked by us?  If yes, big bonus
 927                             // (but smaller than when there are no enemy attacks), if no,
 928                             // somewhat smaller bonus.
 929                             ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
 930                     }
 931                     else
 932                     {
 933                         // There are some enemy pieces in the pawn's path. While this is
 934                         // sad, we still assign a moderate bonus if all squares in the path
 935                         // which are either occupied by or attacked by enemy pieces are
 936                         // also attacked by us.
 937                         if (((b3 | (b2 & pos.pieces_of_color(them))) & ~b4) == EmptyBoardBB)
 938                             ebonus += Value(tr * 6);
 939                     }
 940                     // At last, add a small bonus when there are no *friendly* pieces
 941                     // in the pawn's path.
 942                     if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
 943                         ebonus += Value(tr);
 944                 }
 945             }
 946
 947             // If the pawn is supported by a friendly pawn, increase bonus
 948             b2 = pos.pawns(us) & neighboring_files_bb(s);
 949             if (b2 & rank_bb(s))
 950                 ebonus += Value(r * 20);
 951             else if (pos.pawn_attacks(them, s) & b2)
 952                 ebonus += Value(r * 12);
 953
 954             // If the other side has only a king, check whether the pawn is
 955             // unstoppable
 956             if (pos.non_pawn_material(them) == Value(0))
 957             {
 958                 Square qsq;
 959                 int d;
 960
 961                 qsq = relative_square(us, make_square(square_file(s), RANK_8));
 962                 d =  square_distance(s, qsq)
 963                    - square_distance(theirKingSq, qsq)
 964                    + (us != pos.side_to_move());
 965
 966                 if (d < 0)
 967                 {
 968                     int mtg = RANK_8 - relative_rank(us, s);
 969                     int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
 970                     mtg += blockerCount;
 971                     d += blockerCount;
 972                     if (d < 0)
 973                     {
 974                         hasUnstoppable[us] = true;
 975                         movesToGo[us] = Min(movesToGo[us], mtg);
 976                     }
 977                 }
 978             }
 979             // Rook pawns are a special case:  They are sometimes worse, and
 980             // sometimes better than other passed pawns. It is difficult to find
 981             // good rules for determining whether they are good or bad. For now,
 982             // we try the following: Increase the value for rook pawns if the
 983             // other side has no pieces apart from a knight, and decrease the
 984             // value if the other side has a rook or queen.
 985             if (square_file(s) == FILE_A || square_file(s) == FILE_H)
 986             {
 987                 if(   pos.non_pawn_material(them) <= KnightValueMidgame
 988                    && pos.piece_count(them, KNIGHT) <= 1)
 989                     ebonus += ebonus / 4;
 990                 else if(pos.rooks_and_queens(them))
 991                     ebonus -= ebonus / 4;
 992             }
 993
 994             // Add the scores for this pawn to the middle game and endgame eval.
 995             ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
 996             ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
 997         }
 998     }
 999
1000     // Does either side have an unstoppable passed pawn?
1001     if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
1002        ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
1003     else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
1004        ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
1005     else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
1006     {
1007         // Both sides have unstoppable pawns! Try to find out who queens
1008         // first. We begin by transforming 'movesToGo' to the number of
1009         // plies until the pawn queens for both sides.
1010         movesToGo[WHITE] *= 2;
1011         movesToGo[BLACK] *= 2;
1012         movesToGo[pos.side_to_move()]--;
1013
1014         // If one side queens at least three plies before the other, that
1015         // side wins.
1016         if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
1017             ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
1018         else if(movesToGo[BLACK] <= movesToGo[WHITE] - 3)
1019             ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));
1020
1021         // We could also add some rules about the situation when one side
1022         // queens exactly one ply before the other: Does the first queen
1023         // check the opponent's king, or attack the opponent's queening square?
1024         // This is slightly tricky to get right, because it is possible that
1025         // the opponent's king has moved somewhere before the first pawn queens.
1026     }
1027   }
1028
1029
1030   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1031   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1032   // if it is.
1033
1034   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
1035                                     EvalInfo &ei) {
1036     assert(square_is_ok(s));
1037     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1038
1039     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1040     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1041
1042     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1043         && pos.see(s, b6) < 0
1044         && pos.see(s, b8) < 0)
1045     {
1046         ei.mgValue -= Sign[us] * TrappedBishopA7H7Penalty;
1047         ei.egValue -= Sign[us] * TrappedBishopA7H7Penalty;
1048     }
1049   }
1050
1051
1052   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1053   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1054   // black), and assigns a penalty if it is.  This pattern can obviously
1055   // only occur in Chess960 games.
1056
1057   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
1058                                     EvalInfo &ei) {
1059     Piece pawn = piece_of_color_and_type(us, PAWN);
1060     Square b2, b3, c3;
1061
1062     assert(Chess960);
1063     assert(square_is_ok(s));
1064     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1065
1066     if (square_file(s) == FILE_A)
1067     {
1068         b2 = relative_square(us, SQ_B2);
1069         b3 = relative_square(us, SQ_B3);
1070         c3 = relative_square(us, SQ_C3);
1071     }
1072     else
1073     {
1074         b2 = relative_square(us, SQ_G2);
1075         b3 = relative_square(us, SQ_G3);
1076         c3 = relative_square(us, SQ_F3);
1077     }
1078
1079     if (pos.piece_on(b2) == pawn)
1080     {
1081         Value penalty;
1082
1083         if (!pos.square_is_empty(b3))
1084             penalty = 2*TrappedBishopA1H1Penalty;
1085         else if (pos.piece_on(c3) == pawn)
1086             penalty = TrappedBishopA1H1Penalty;
1087         else
1088             penalty = TrappedBishopA1H1Penalty / 2;
1089
1090         ei.mgValue -= Sign[us] * penalty;
1091         ei.egValue -= Sign[us] * penalty;
1092     }
1093   }
1094
1095
1096   // evaluate_space() computes the space evaluation for a given side. The
1097   // space evaluation is a simple bonus based on the number of safe squares
1098   // available for minor pieces on the central four files on ranks 2--4. Safe
1099   // squares one, two or three squares behind a friendly pawn are counted
1100   // twice. Finally, the space bonus is scaled by a weight taken from the
1101   // material hash table.
1102
1103   void evaluate_space(const Position &pos, Color us, EvalInfo &ei) {
1104
1105     Color them = opposite_color(us);
1106
1107     // Find the safe squares for our pieces inside the area defined by
1108     // SpaceMask[us]. A square is unsafe it is attacked by an enemy
1109     // pawn, or if it is undefended and attacked by an enemy piece.
1110
1111     Bitboard safeSquares =   SpaceMask[us]
1112                           & ~pos.pawns(us)
1113                           & ~ei.attacked_by(them, PAWN)
1114                           & ~(~ei.attacked_by(us) & ei.attacked_by(them));
1115
1116     // Find all squares which are at most three squares behind some friendly
1117     // pawn.
1118     Bitboard behindFriendlyPawns = pos.pawns(us);
1119     if (us == WHITE)
1120     {
1121         behindFriendlyPawns |= (behindFriendlyPawns >> 8);
1122         behindFriendlyPawns |= (behindFriendlyPawns >> 16);
1123     }
1124     else
1125     {
1126         behindFriendlyPawns |= (behindFriendlyPawns << 8);
1127         behindFriendlyPawns |= (behindFriendlyPawns << 16);
1128     }
1129
1130     int space =  count_1s_max_15(safeSquares)
1131                + count_1s_max_15(behindFriendlyPawns & safeSquares);
1132
1133     ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
1134   }
1135
1136
1137   // apply_weight() applies an evaluation weight to a value
1138
1139   inline Value apply_weight(Value v, int w) {
1140     return (v*w) / 0x100;
1141   }
1142
1143
1144   // scale_by_game_phase() interpolates between a middle game and an endgame
1145   // score, based on game phase.  It also scales the return value by a
1146   // ScaleFactor array.
1147
1148   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
1149
1150     assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
1151     assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);
1152     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1153
1154     ev = apply_scale_factor(ev, sf[(ev > Value(0) ? WHITE : BLACK)]);
1155
1156     Value result = Value(int((mv * ph + ev * (128 - ph)) / 128));
1157     return Value(int(result) & ~(GrainSize - 1));
1158   }
1159
1160
1161   // count_1s_8bit() counts the number of nonzero bits in the 8 least
1162   // significant bits of a Bitboard. This function is used by the king
1163   // shield evaluation.
1164
1165   int count_1s_8bit(Bitboard b) {
1166     return int(BitCount8Bit[b & 0xFF]);
1167   }
1168
1169
1170   // compute_weight() computes the value of an evaluation weight, by combining
1171   // an UCI-configurable weight with an internal weight.
1172
1173   int compute_weight(int uciWeight, int internalWeight) {
1174
1175     uciWeight = (uciWeight * 0x100) / 100;
1176     return (uciWeight * internalWeight) / 0x100;
1177   }
1178
1179
1180   // helper used in read_weights()
1181   int weight_option(const std::string& opt, int weight) {
1182
1183     return compute_weight(get_option_value_int(opt), weight);
1184   }
1185
1186
1187   // init_safety() initizes the king safety evaluation, based on UCI
1188   // parameters.  It is called from read_weights().
1189
1190   void init_safety() {
1191
1192     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1193     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
1194     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
1195     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
1196     KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
1197     DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
1198     MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
1199
1200     int maxSlope = get_option_value_int("King Safety Max Slope");
1201     int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
1202     double a     = get_option_value_int("King Safety Coefficient") / 100.0;
1203     double b     = get_option_value_int("King Safety X Intercept");
1204     bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
1205     bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
1206
1207     for (int i = 0; i < 100; i++)
1208     {
1209         if (i < b)
1210             SafetyTable[i] = Value(0);
1211         else if(quad)
1212             SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1213         else if(linear)
1214             SafetyTable[i] = Value((int)(100 * a * (i - b)));
1215     }
1216
1217     for (int i = 0; i < 100; i++)
1218     {
1219         if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1220             for (int j = i + 1; j < 100; j++)
1221                 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1222
1223         if (SafetyTable[i]  > Value(peak))
1224             SafetyTable[i] = Value(peak);
1225     }
1226   }
1227 }