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
 597     for (int i = 0; i < pos.piece_count(us, Piece); i++)
 598     {
 599         Square s = pos.piece_list(us, Piece, i);
 600
 601         if (Piece == KNIGHT || Piece == QUEEN)
 602             b = pos.piece_attacks<Piece>(s);
 603         else if (Piece == BISHOP)
 604             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.queens(us));
 605         else if (Piece == ROOK)
 606             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
 607
 608         // Attacks, mobility and outposts
 609         int mob = evaluate_common<Piece>(pos, b, us, ei, s);
 610
 611         // Special patterns: trapped bishops on a7/h7/a2/h2
 612         // and trapped bishops on a1/h1/a8/h8 in Chess960.
 613         if (Piece == BISHOP)
 614         {
 615             if (bit_is_set(MaskA7H7[us], s))
 616                 evaluate_trapped_bishop_a7h7(pos, s, us, ei);
 617
 618             if (Chess960 && bit_is_set(MaskA1H1[us], s))
 619                 evaluate_trapped_bishop_a1h1(pos, s, us, ei);
 620         }
 621
 622         if (Piece != ROOK && Piece != QUEEN)
 623             continue;
 624
 625         // Queen or rook on 7th rank
 626         Color them = opposite_color(us);
 627
 628         if (   relative_rank(us, s) == RANK_7
 629             && relative_rank(us, pos.king_square(them)) == RANK_8)
 630         {
 631             ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
 632             ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
 633         }
 634
 635         // Special extra evaluation for rooks
 636         if (Piece != ROOK)
 637             continue;
 638
 639         // Open and half-open files
 640         File f = square_file(s);
 641         if (ei.pi->file_is_half_open(us, f))
 642         {
 643             if (ei.pi->file_is_half_open(them, f))
 644             {
 645                 ei.mgValue += Sign[us] * RookOpenFileBonus;
 646                 ei.egValue += Sign[us] * RookOpenFileBonus;
 647             }
 648             else
 649             {
 650                 ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
 651                 ei.egValue += Sign[us] * RookHalfOpenFileBonus;
 652             }
 653         }
 654
 655         // Penalize rooks which are trapped inside a king. Penalize more if
 656         // king has lost right to castle.
 657         if (mob > 6 || ei.pi->file_is_half_open(us, f))
 658             continue;
 659
 660         Square ksq = pos.king_square(us);
 661
 662         if (    square_file(ksq) >= FILE_E
 663             &&  square_file(s) > square_file(ksq)
 664             && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 665         {
 666             // Is there a half-open file between the king and the edge of the board?
 667             if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
 668                 ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
 669                                                 : Sign[us] *  (TrappedRookPenalty - mob * 16);
 670         }
 671         else if (    square_file(ksq) <= FILE_D
 672                  &&  square_file(s) < square_file(ksq)
 673                  && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
 674         {
 675             // Is there a half-open file between the king and the edge of the board?
 676             if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
 677                 ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
 678                                                 : Sign[us] * (TrappedRookPenalty - mob * 16);
 679         }
 680     }
 681   }
 682
 683   inline Bitboard shiftRowsDown(const Bitboard& b, int num) {
 684
 685     return b >> (num << 3);
 686   }
 687
 688   // evaluate_pieces<KING>() assigns bonuses and penalties to a king of a given
 689   // color.
 690
 691   template<>
 692   void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo& ei) {
 693
 694     int shelter = 0, sign = Sign[us];
 695     Square s = p.king_square(us);
 696
 697     // King shelter
 698     if (relative_rank(us, s) <= RANK_4)
 699     {
 700         Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
 701         Rank r = square_rank(s);
 702         for (int i = 1; i < 4; i++)
 703             shelter += count_1s_8bit(shiftRowsDown(pawns, r+i*sign)) * (128>>i);
 704
 705         ei.mgValue += sign * Value(shelter);
 706     }
 707
 708     // King safety.  This is quite complicated, and is almost certainly far
 709     // from optimally tuned.
 710     Color them = opposite_color(us);
 711
 712     if (   p.piece_count(them, QUEEN) >= 1
 713         && ei.kingAttackersCount[them] >= 2
 714         && p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
 715         && ei.kingAdjacentZoneAttacksCount[them])
 716     {
 717       // Is it the attackers turn to move?
 718       bool sente = (them == p.side_to_move());
 719
 720       // Find the attacked squares around the king which has no defenders
 721       // apart from the king itself
 722       Bitboard undefended =
 723              ei.attacked_by(them)       & ~ei.attacked_by(us, PAWN)
 724           & ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP)
 725           & ~ei.attacked_by(us, ROOK)   & ~ei.attacked_by(us, QUEEN)
 726           & ei.attacked_by(us, KING);
 727
 728       Bitboard occ = p.occupied_squares(), b, b2;
 729
 730       // Initialize the 'attackUnits' variable, which is used later on as an
 731       // index to the SafetyTable[] array.  The initial value is based on the
 732       // number and types of the attacking pieces, the number of attacked and
 733       // undefended squares around the king, the square of the king, and the
 734       // quality of the pawn shelter.
 735       int attackUnits =
 736             Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
 737           + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15(undefended)) * 3
 738           + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
 739
 740       // Analyse safe queen contact checks
 741       b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them);
 742       if (b)
 743       {
 744         Bitboard attackedByOthers =
 745               ei.attacked_by(them, PAWN)   | ei.attacked_by(them, KNIGHT)
 746             | ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK);
 747
 748         b &= attackedByOthers;
 749         if (b)
 750         {
 751           // The bitboard b now contains the squares available for safe queen
 752           // contact checks.
 753           int count = count_1s_max_15(b);
 754           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
 755
 756           // Is there a mate threat?
 757           if (QueenContactMates && !p.is_check())
 758           {
 759             Bitboard escapeSquares =
 760                 p.piece_attacks<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
 761
 762             while (b)
 763             {
 764                 Square from, to = pop_1st_bit(&b);
 765                 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
 766                 {
 767                     // We have a mate, unless the queen is pinned or there
 768                     // is an X-ray attack through the queen.
 769                     for (int i = 0; i < p.piece_count(them, QUEEN); i++)
 770                     {
 771                         from = p.piece_list(them, QUEEN, i);
 772                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
 773                             && !bit_is_set(p.pinned_pieces(them), from)
 774                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
 775                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us)))
 776
 777                             ei.mateThreat[them] = make_move(from, to);
 778                     }
 779                 }
 780             }
 781           }
 782         }
 783       }
 784
 785       // Analyse safe distance checks
 786       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
 787       {
 788           b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 789
 790           // Queen checks
 791           b2 = b & ei.attacked_by(them, QUEEN);
 792           if( b2)
 793               attackUnits += QueenCheckBonus * count_1s_max_15(b2);
 794
 795           // Rook checks
 796           b2 = b & ei.attacked_by(them, ROOK);
 797           if (b2)
 798               attackUnits += RookCheckBonus * count_1s_max_15(b2);
 799       }
 800       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
 801       {
 802           b = p.piece_attacks<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 803
 804           // Queen checks
 805           b2 = b & ei.attacked_by(them, QUEEN);
 806           if (b2)
 807               attackUnits += QueenCheckBonus * count_1s_max_15(b2);
 808
 809           // Bishop checks
 810           b2 = b & ei.attacked_by(them, BISHOP);
 811           if (b2)
 812               attackUnits += BishopCheckBonus * count_1s_max_15(b2);
 813       }
 814       if (KnightCheckBonus > 0)
 815       {
 816           b = p.piece_attacks<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
 817
 818           // Knight checks
 819           b2 = b & ei.attacked_by(them, KNIGHT);
 820           if (b2)
 821               attackUnits += KnightCheckBonus * count_1s_max_15(b2);
 822       }
 823
 824       // Analyse discovered checks (only for non-pawns right now, consider
 825       // adding pawns later).
 826       if (DiscoveredCheckBonus)
 827       {
 828         b = p.discovered_check_candidates(them) & ~p.pawns();
 829         if (b)
 830           attackUnits += DiscoveredCheckBonus * count_1s_max_15(b) * (sente? 2 : 1);
 831       }
 832
 833       // Has a mate threat been found?  We don't do anything here if the
 834       // side with the mating move is the side to move, because in that
 835       // case the mating side will get a huge bonus at the end of the main
 836       // evaluation function instead.
 837       if (ei.mateThreat[them] != MOVE_NONE)
 838           attackUnits += MateThreatBonus;
 839
 840       // Ensure that attackUnits is between 0 and 99, in order to avoid array
 841       // out of bounds errors:
 842       if (attackUnits < 0)
 843           attackUnits = 0;
 844
 845       if (attackUnits >= 100)
 846           attackUnits = 99;
 847
 848       // Finally, extract the king safety score from the SafetyTable[] array.
 849       // Add the score to the evaluation, and also to ei.futilityMargin.  The
 850       // reason for adding the king safety score to the futility margin is
 851       // that the king safety scores can sometimes be very big, and that
 852       // capturing a single attacking piece can therefore result in a score
 853       // change far bigger than the value of the captured piece.
 854       Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]);
 855
 856       ei.mgValue -= sign * v;
 857
 858       if (us == p.side_to_move())
 859           ei.futilityMargin += v;
 860     }
 861   }
 862
 863
 864   // evaluate_passed_pawns() evaluates the passed pawns for both sides.
 865
 866   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei) {
 867
 868     bool hasUnstoppable[2] = {false, false};
 869     int movesToGo[2] = {100, 100};
 870
 871     for (Color us = WHITE; us <= BLACK; us++)
 872     {
 873         Color them = opposite_color(us);
 874         Square ourKingSq = pos.king_square(us);
 875         Square theirKingSq = pos.king_square(them);
 876         Bitboard b = ei.pi->passed_pawns() & pos.pawns(us), b2, b3, b4;
 877
 878         while (b)
 879         {
 880             Square s = pop_1st_bit(&b);
 881
 882             assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
 883             assert(pos.pawn_is_passed(us, s));
 884
 885             int r = int(relative_rank(us, s) - RANK_2);
 886             int tr = Max(0, r * (r - 1));
 887             Square blockSq = s + pawn_push(us);
 888
 889             // Base bonus based on rank
 890             Value mbonus = Value(20 * tr);
 891             Value ebonus = Value(10 + r * r * 10);
 892
 893             // Adjust bonus based on king proximity
 894             if (tr != 0)
 895             {
 896                 ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
 897                 ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
 898                 ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
 899
 900                 // If the pawn is free to advance, increase bonus
 901                 if (pos.square_is_empty(blockSq))
 902                 {
 903                     b2 = squares_in_front_of(us, s);
 904                     b3 = b2 & ei.attacked_by(them);
 905                     b4 = b2 & ei.attacked_by(us);
 906
 907                     // If there is an enemy rook or queen attacking the pawn from behind,
 908                     // add all X-ray attacks by the rook or queen.
 909                     if (    bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
 910                         && (squares_behind(us, s) & pos.rooks_and_queens(them)))
 911                         b3 = b2;
 912
 913                     if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
 914                     {
 915                         // There are no enemy pieces in the pawn's path! Are any of the
 916                         // squares in the pawn's path attacked by the enemy?
 917                         if (b3 == EmptyBoardBB)
 918                             // No enemy attacks, huge bonus!
 919                             ebonus += Value(tr * (b2 == b4 ? 17 : 15));
 920                         else
 921                             // OK, there are enemy attacks. Are those squares which are
 922                             // attacked by the enemy also attacked by us?  If yes, big bonus
 923                             // (but smaller than when there are no enemy attacks), if no,
 924                             // somewhat smaller bonus.
 925                             ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
 926                     }
 927                     else
 928                     {
 929                         // There are some enemy pieces in the pawn's path. While this is
 930                         // sad, we still assign a moderate bonus if all squares in the path
 931                         // which are either occupied by or attacked by enemy pieces are
 932                         // also attacked by us.
 933                         if (((b3 | (b2 & pos.pieces_of_color(them))) & ~b4) == EmptyBoardBB)
 934                             ebonus += Value(tr * 6);
 935                     }
 936                     // At last, add a small bonus when there are no *friendly* pieces
 937                     // in the pawn's path.
 938                     if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
 939                         ebonus += Value(tr);
 940                 }
 941             }
 942
 943             // If the pawn is supported by a friendly pawn, increase bonus
 944             b2 = pos.pawns(us) & neighboring_files_bb(s);
 945             if (b2 & rank_bb(s))
 946                 ebonus += Value(r * 20);
 947             else if (pos.pawn_attacks(them, s) & b2)
 948                 ebonus += Value(r * 12);
 949
 950             // If the other side has only a king, check whether the pawn is
 951             // unstoppable
 952             if (pos.non_pawn_material(them) == Value(0))
 953             {
 954                 Square qsq;
 955                 int d;
 956
 957                 qsq = relative_square(us, make_square(square_file(s), RANK_8));
 958                 d =  square_distance(s, qsq)
 959                    - square_distance(theirKingSq, qsq)
 960                    + (us != pos.side_to_move());
 961
 962                 if (d < 0)
 963                 {
 964                     int mtg = RANK_8 - relative_rank(us, s);
 965                     int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
 966                     mtg += blockerCount;
 967                     d += blockerCount;
 968                     if (d < 0)
 969                     {
 970                         hasUnstoppable[us] = true;
 971                         movesToGo[us] = Min(movesToGo[us], mtg);
 972                     }
 973                 }
 974             }
 975             // Rook pawns are a special case:  They are sometimes worse, and
 976             // sometimes better than other passed pawns. It is difficult to find
 977             // good rules for determining whether they are good or bad. For now,
 978             // we try the following: Increase the value for rook pawns if the
 979             // other side has no pieces apart from a knight, and decrease the
 980             // value if the other side has a rook or queen.
 981             if (square_file(s) == FILE_A || square_file(s) == FILE_H)
 982             {
 983                 if(   pos.non_pawn_material(them) <= KnightValueMidgame
 984                    && pos.piece_count(them, KNIGHT) <= 1)
 985                     ebonus += ebonus / 4;
 986                 else if(pos.rooks_and_queens(them))
 987                     ebonus -= ebonus / 4;
 988             }
 989
 990             // Add the scores for this pawn to the middle game and endgame eval.
 991             ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
 992             ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
 993         }
 994     }
 995
 996     // Does either side have an unstoppable passed pawn?
 997     if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
 998        ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
 999     else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
1000        ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
1001     else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
1002     {
1003         // Both sides have unstoppable pawns! Try to find out who queens
1004         // first. We begin by transforming 'movesToGo' to the number of
1005         // plies until the pawn queens for both sides.
1006         movesToGo[WHITE] *= 2;
1007         movesToGo[BLACK] *= 2;
1008         movesToGo[pos.side_to_move()]--;
1009
1010         // If one side queens at least three plies before the other, that
1011         // side wins.
1012         if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
1013             ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
1014         else if(movesToGo[BLACK] <= movesToGo[WHITE] - 3)
1015             ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));
1016
1017         // We could also add some rules about the situation when one side
1018         // queens exactly one ply before the other: Does the first queen
1019         // check the opponent's king, or attack the opponent's queening square?
1020         // This is slightly tricky to get right, because it is possible that
1021         // the opponent's king has moved somewhere before the first pawn queens.
1022     }
1023   }
1024
1025
1026   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1027   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1028   // if it is.
1029
1030   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
1031                                     EvalInfo &ei) {
1032     assert(square_is_ok(s));
1033     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1034
1035     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1036     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1037
1038     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1039         && pos.see(s, b6) < 0
1040         && pos.see(s, b8) < 0)
1041     {
1042         ei.mgValue -= Sign[us] * TrappedBishopA7H7Penalty;
1043         ei.egValue -= Sign[us] * TrappedBishopA7H7Penalty;
1044     }
1045   }
1046
1047
1048   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1049   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1050   // black), and assigns a penalty if it is.  This pattern can obviously
1051   // only occur in Chess960 games.
1052
1053   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
1054                                     EvalInfo &ei) {
1055     Piece pawn = piece_of_color_and_type(us, PAWN);
1056     Square b2, b3, c3;
1057
1058     assert(Chess960);
1059     assert(square_is_ok(s));
1060     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1061
1062     if (square_file(s) == FILE_A)
1063     {
1064         b2 = relative_square(us, SQ_B2);
1065         b3 = relative_square(us, SQ_B3);
1066         c3 = relative_square(us, SQ_C3);
1067     }
1068     else
1069     {
1070         b2 = relative_square(us, SQ_G2);
1071         b3 = relative_square(us, SQ_G3);
1072         c3 = relative_square(us, SQ_F3);
1073     }
1074
1075     if (pos.piece_on(b2) == pawn)
1076     {
1077         Value penalty;
1078
1079         if (!pos.square_is_empty(b3))
1080             penalty = 2*TrappedBishopA1H1Penalty;
1081         else if (pos.piece_on(c3) == pawn)
1082             penalty = TrappedBishopA1H1Penalty;
1083         else
1084             penalty = TrappedBishopA1H1Penalty / 2;
1085
1086         ei.mgValue -= Sign[us] * penalty;
1087         ei.egValue -= Sign[us] * penalty;
1088     }
1089   }
1090
1091
1092   // evaluate_space() computes the space evaluation for a given side. The
1093   // space evaluation is a simple bonus based on the number of safe squares
1094   // available for minor pieces on the central four files on ranks 2--4. Safe
1095   // squares one, two or three squares behind a friendly pawn are counted
1096   // twice. Finally, the space bonus is scaled by a weight taken from the
1097   // material hash table.
1098
1099   void evaluate_space(const Position &pos, Color us, EvalInfo &ei) {
1100
1101     Color them = opposite_color(us);
1102
1103     // Find the safe squares for our pieces inside the area defined by
1104     // SpaceMask[us]. A square is unsafe it is attacked by an enemy
1105     // pawn, or if it is undefended and attacked by an enemy piece.
1106
1107     Bitboard safeSquares =   SpaceMask[us]
1108                           & ~pos.pawns(us)
1109                           & ~ei.attacked_by(them, PAWN)
1110                           & ~(~ei.attacked_by(us) & ei.attacked_by(them));
1111
1112     // Find all squares which are at most three squares behind some friendly
1113     // pawn.
1114     Bitboard behindFriendlyPawns = pos.pawns(us);
1115     if (us == WHITE)
1116     {
1117         behindFriendlyPawns |= (behindFriendlyPawns >> 8);
1118         behindFriendlyPawns |= (behindFriendlyPawns >> 16);
1119     }
1120     else
1121     {
1122         behindFriendlyPawns |= (behindFriendlyPawns << 8);
1123         behindFriendlyPawns |= (behindFriendlyPawns << 16);
1124     }
1125
1126     int space =  count_1s_max_15(safeSquares)
1127                + count_1s_max_15(behindFriendlyPawns & safeSquares);
1128
1129     ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
1130   }
1131
1132
1133   // apply_weight() applies an evaluation weight to a value
1134
1135   inline Value apply_weight(Value v, int w) {
1136     return (v*w) / 0x100;
1137   }
1138
1139
1140   // scale_by_game_phase() interpolates between a middle game and an endgame
1141   // score, based on game phase.  It also scales the return value by a
1142   // ScaleFactor array.
1143
1144   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
1145
1146     assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
1147     assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);
1148     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1149
1150     ev = apply_scale_factor(ev, sf[(ev > Value(0) ? WHITE : BLACK)]);
1151
1152     Value result = Value(int((mv * ph + ev * (128 - ph)) / 128));
1153     return Value(int(result) & ~(GrainSize - 1));
1154   }
1155
1156
1157   // count_1s_8bit() counts the number of nonzero bits in the 8 least
1158   // significant bits of a Bitboard. This function is used by the king
1159   // shield evaluation.
1160
1161   int count_1s_8bit(Bitboard b) {
1162     return int(BitCount8Bit[b & 0xFF]);
1163   }
1164
1165
1166   // compute_weight() computes the value of an evaluation weight, by combining
1167   // an UCI-configurable weight with an internal weight.
1168
1169   int compute_weight(int uciWeight, int internalWeight) {
1170
1171     uciWeight = (uciWeight * 0x100) / 100;
1172     return (uciWeight * internalWeight) / 0x100;
1173   }
1174
1175
1176   // helper used in read_weights()
1177   int weight_option(const std::string& opt, int weight) {
1178
1179     return compute_weight(get_option_value_int(opt), weight);
1180   }
1181
1182
1183   // init_safety() initizes the king safety evaluation, based on UCI
1184   // parameters.  It is called from read_weights().
1185
1186   void init_safety() {
1187
1188     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1189     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
1190     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
1191     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
1192     KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
1193     DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
1194     MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
1195
1196     int maxSlope = get_option_value_int("King Safety Max Slope");
1197     int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
1198     double a     = get_option_value_int("King Safety Coefficient") / 100.0;
1199     double b     = get_option_value_int("King Safety X Intercept");
1200     bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
1201     bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
1202
1203     for (int i = 0; i < 100; i++)
1204     {
1205         if (i < b)
1206             SafetyTable[i] = Value(0);
1207         else if(quad)
1208             SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1209         else if(linear)
1210             SafetyTable[i] = Value((int)(100 * a * (i - b)));
1211     }
1212
1213     for (int i = 0; i < 100; i++)
1214     {
1215         if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1216             for (int j = i + 1; j < 100; j++)
1217                 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1218
1219         if (SafetyTable[i]  > Value(peak))
1220             SafetyTable[i] = Value(peak);
1221     }
1222   }
1223 }