git.sesse.net Git - stockfish/blob - src/evaluate.cpp

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