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