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