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

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
   4   Copyright (C) 2008 Marco Costalba
   5
   6   Stockfish is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   Stockfish is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20
  21 ////
  22 //// Includes
  23 ////
  24
  25 #include <cassert>
  26 #include <cstring>
  27
  28 #include "pawns.h"
  29
  30
  31 ////
  32 //// Local definitions
  33 ////
  34
  35 namespace {
  36
  37   /// Constants and variables
  38
  39   // Doubled pawn penalty by file, middle game.
  40   const Value DoubledPawnMidgamePenalty[8] = {
  41     Value(20), Value(30), Value(34), Value(34),
  42     Value(34), Value(34), Value(30), Value(20)
  43   };
  44
  45   // Doubled pawn penalty by file, endgame.
  46   const Value DoubledPawnEndgamePenalty[8] = {
  47     Value(35), Value(40), Value(40), Value(40),
  48     Value(40), Value(40), Value(40), Value(35)
  49   };
  50
  51   // Isolated pawn penalty by file, middle game.
  52   const Value IsolatedPawnMidgamePenalty[8] = {
  53     Value(20), Value(30), Value(34), Value(34),
  54     Value(34), Value(34), Value(30), Value(20)
  55   };
  56
  57   // Isolated pawn penalty by file, endgame.
  58   const Value IsolatedPawnEndgamePenalty[8] = {
  59     Value(35), Value(40), Value(40), Value(40),
  60     Value(40), Value(40), Value(40), Value(35)
  61   };
  62
  63   // Backward pawn penalty by file, middle game.
  64   const Value BackwardPawnMidgamePenalty[8] = {
  65     Value(16), Value(24), Value(27), Value(27),
  66     Value(27), Value(27), Value(24), Value(16)
  67   };
  68
  69   // Backward pawn penalty by file, endgame.
  70   const Value BackwardPawnEndgamePenalty[8] = {
  71     Value(28), Value(32), Value(32), Value(32),
  72     Value(32), Value(32), Value(32), Value(28)
  73   };
  74
  75   // Pawn chain membership bonus by file, middle game.
  76   const Value ChainMidgameBonus[8] = {
  77     Value(14), Value(16), Value(17), Value(18),
  78     Value(18), Value(17), Value(16), Value(14)
  79   };
  80
  81   // Pawn chain membership bonus by file, endgame.
  82   const Value ChainEndgameBonus[8] = {
  83     Value(16), Value(16), Value(16), Value(16),
  84     Value(16), Value(16), Value(16), Value(16)
  85   };
  86
  87   // Candidate passed pawn bonus by rank, middle game.
  88   const Value CandidateMidgameBonus[8] = {
  89     Value(0), Value(12), Value(12), Value(20),
  90     Value(40), Value(90), Value(0), Value(0)
  91   };
  92
  93   // Candidate passed pawn bonus by rank, endgame.
  94   const Value CandidateEndgameBonus[8] = {
  95     Value(0), Value(24), Value(24), Value(40),
  96     Value(80), Value(180), Value(0), Value(0)
  97   };
  98
  99   // Evaluate pawn storms?
 100   const bool EvaluatePawnStorms = true;
 101
 102   // Pawn storm tables for positions with opposite castling:
 103   const int QStormTable[64] = {
 104     0, 0, 0, 0, 0, 0, 0, 0,
 105     -22, -22, -22, -13, -4, 0, 0, 0,
 106     -4, -9, -9, -9, -4, 0, 0, 0,
 107     9, 18, 22, 18, 9, 0, 0, 0,
 108     22, 31, 31, 22, 0, 0, 0, 0,
 109     31, 40, 40, 31, 0, 0, 0, 0,
 110     31, 40, 40, 31, 0, 0, 0, 0,
 111     0, 0, 0, 0, 0, 0, 0, 0
 112   };
 113
 114   const int KStormTable[64] = {
 115     0, 0, 0, 0, 0, 0, 0, 0,
 116     0, 0, 0, -4, -13, -22, -27, -27,
 117     0, 0, 0, -4, -9, -13, -18, -18,
 118     0, 0, 0, 0, 9, 9, 9, 9,
 119     0, 0, 0, 0, 9, 18, 27, 27,
 120     0, 0, 0, 0, 9, 27, 40, 36,
 121     0, 0, 0, 0, 0, 31, 40, 31,
 122     0, 0, 0, 0, 0, 0, 0, 0
 123   };
 124
 125   // Pawn storm open file bonuses by file:
 126   const int KStormOpenFileBonus[8] = {
 127     45, 45, 30, 0, 0, 0, 0, 0
 128   };
 129
 130   const int QStormOpenFileBonus[8] = {
 131     0, 0, 0, 0, 0, 30, 45, 30
 132   };
 133
 134 }
 135
 136
 137 ////
 138 //// Functions
 139 ////
 140
 141 /// Constructor
 142
 143 PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
 144   size = numOfEntries;
 145   entries = new PawnInfo[size];
 146   if(entries == NULL) {
 147     std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
 148               << " bytes for pawn hash table." << std::endl;
 149     exit(EXIT_FAILURE);
 150   }
 151   this->clear();
 152 }
 153
 154
 155 /// Destructor
 156
 157 PawnInfoTable::~PawnInfoTable() {
 158   delete [] entries;
 159 }
 160
 161
 162 /// PawnInfoTable::clear() clears the pawn hash table by setting all
 163 /// entries to 0.
 164
 165 void PawnInfoTable::clear() {
 166   memset(entries, 0, size * sizeof(PawnInfo));
 167 }
 168
 169
 170 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
 171 /// a PawnInfo object, and returns a pointer to it.  The result is also
 172 /// stored in a hash table, so we don't have to recompute everything when
 173 /// the same pawn structure occurs again.
 174
 175 PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
 176   assert(pos.is_ok());
 177
 178   Key key = pos.get_pawn_key();
 179   int index = int(key & (size - 1));
 180   PawnInfo *pi = entries + index;
 181
 182   // If pi->key matches the position's pawn hash key, it means that we
 183   // have analysed this pawn structure before, and we can simply return the
 184   // information we found the last time instead of recomputing it:
 185   if(pi->key == key)
 186     return pi;
 187
 188   // Clear the PawnInfo object, and set the key:
 189   pi->clear();
 190   pi->key = key;
 191
 192   Value mgValue[2] = {Value(0), Value(0)};
 193   Value egValue[2] = {Value(0), Value(0)};
 194
 195   // Loop through the pawns for both colors:
 196   for(Color us = WHITE; us <= BLACK; us++) {
 197     Color them = opposite_color(us);
 198     Bitboard ourPawns = pos.pawns(us);
 199     Bitboard theirPawns = pos.pawns(them);
 200     Bitboard pawns = ourPawns;
 201
 202     // Initialize pawn storm scores by giving bonuses for open files:
 203     if(EvaluatePawnStorms)
 204       for(File f = FILE_A; f <= FILE_H; f++)
 205         if(pos.file_is_half_open(us, f)) {
 206           pi->ksStormValue[us] += KStormOpenFileBonus[f];
 207           pi->qsStormValue[us] += QStormOpenFileBonus[f];
 208         }
 209
 210     // Loop through all pawns of the current color and score each pawn:
 211     while(pawns) {
 212       Square s = pop_1st_bit(&pawns);
 213       File f = square_file(s);
 214       Rank r = square_rank(s);
 215       bool passed, doubled, isolated, backward, chain, candidate;
 216       int bonus;
 217
 218       assert(pos.piece_on(s) == pawn_of_color(us));
 219
 220       // The file containing the pawn is not half open:
 221       pi->halfOpenFiles[us] &= ~(1 << f);
 222
 223       // Passed, isolated or doubled pawn?
 224       passed = pos.pawn_is_passed(us, s);
 225       isolated = pos.pawn_is_isolated(us, s);
 226       doubled = pos.pawn_is_doubled(us, s);
 227
 228       if(EvaluatePawnStorms) {
 229         // We calculate kingside and queenside pawn storm
 230         // scores for both colors.  These are used when evaluating
 231         // middle game positions with opposite side castling.
 232         //
 233         // Each pawn is given a base score given by a piece square table
 234         // (KStormTable[] or QStormTable[]).  This score is increased if
 235         // there are enemy pawns on adjacent files in front of the pawn.
 236         // This is because we want to be able to open files against the
 237         // enemy king, and to avoid blocking the pawn structure (e.g. white
 238         // pawns on h6, g5, black pawns on h7, g6, f7).
 239
 240         // Kingside pawn storms:
 241         bonus = KStormTable[relative_square(us, s)];
 242         if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
 243           switch(f) {
 244
 245           case FILE_F:
 246             bonus += bonus / 4;
 247             break;
 248
 249           case FILE_G:
 250             bonus += bonus / 2 + bonus / 4;
 251             break;
 252
 253           case FILE_H:
 254             bonus += bonus / 2;
 255             break;
 256
 257           default:
 258             break;
 259           }
 260         }
 261         pi->ksStormValue[us] += bonus;
 262
 263         // Queenside pawn storms:
 264         bonus = QStormTable[relative_square(us, s)];
 265         if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
 266           switch(f) {
 267
 268           case FILE_A:
 269             bonus += bonus / 2;
 270             break;
 271
 272           case FILE_B:
 273             bonus += bonus / 2 + bonus / 4;
 274             break;
 275
 276           case FILE_C:
 277             bonus += bonus / 2;
 278             break;
 279
 280           default:
 281             break;
 282           }
 283         }
 284         pi->qsStormValue[us] += bonus;
 285       }
 286
 287       // Member of a pawn chain?  We could speed up the test a little by
 288       // introducing an array of masks indexed by color and square for doing
 289       // the test, but because everything is hashed, it probably won't make
 290       // any noticable difference.
 291       chain = (us == WHITE)?
 292         (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
 293         (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));
 294
 295
 296       // Test for backward pawn.
 297
 298       // If the pawn is isolated, passed, or member of a pawn chain, it cannot
 299       // be backward:
 300       if(passed || isolated || chain)
 301         backward = false;
 302       // If the pawn can capture an enemy pawn, it's not backward:
 303       else if(pos.pawn_attacks(us, s) & theirPawns)
 304         backward = false;
 305       // Check for friendly pawns behind on neighboring files:
 306       else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
 307         backward = false;
 308       else {
 309         // We now know that there is no friendly pawns beside or behind this
 310         // pawn on neighboring files.  We now check whether the pawn is
 311         // backward by looking in the forward direction on the neighboring
 312         // files, and seeing whether we meet a friendly or an enemy pawn first.
 313         Bitboard b;
 314         if(us == WHITE) {
 315           for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
 316           backward = (b | (b << 8)) & theirPawns;
 317         }
 318         else {
 319           for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
 320           backward = (b | (b >> 8)) & theirPawns;
 321         }
 322       }
 323
 324       // Test for candidate passed pawn.
 325       candidate =
 326         (!passed && pos.file_is_half_open(them, f) &&
 327          count_1s_max_15(neighboring_files_bb(f)
 328                          & (in_front_bb(them, r) | rank_bb(r))
 329                          & ourPawns)
 330          - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)
 331                            & theirPawns)
 332          >= 0);
 333
 334       // In order to prevent doubled passed pawns from receiving a too big
 335       // bonus, only the frontmost passed pawn on each file is considered as
 336       // a true passed pawn.
 337       if(passed && (ourPawns & squares_in_front_of(us, s))) {
 338         // candidate = true;
 339         passed = false;
 340       }
 341
 342       // Score this pawn:
 343       Value mv = Value(0), ev = Value(0);
 344       if(isolated) {
 345         mv -= IsolatedPawnMidgamePenalty[f];
 346         ev -= IsolatedPawnEndgamePenalty[f];
 347         if(pos.file_is_half_open(them, f)) {
 348           mv -= IsolatedPawnMidgamePenalty[f] / 2;
 349           ev -= IsolatedPawnEndgamePenalty[f] / 2;
 350         }
 351       }
 352       if(doubled)  {
 353         mv -= DoubledPawnMidgamePenalty[f];
 354         ev -= DoubledPawnEndgamePenalty[f];
 355       }
 356       if(backward)  {
 357         mv -= BackwardPawnMidgamePenalty[f];
 358         ev -= BackwardPawnEndgamePenalty[f];
 359         if(pos.file_is_half_open(them, f)) {
 360           mv -= BackwardPawnMidgamePenalty[f] / 2;
 361           ev -= BackwardPawnEndgamePenalty[f] / 2;
 362         }
 363       }
 364       if(chain) {
 365         mv += ChainMidgameBonus[f];
 366         ev += ChainEndgameBonus[f];
 367       }
 368       if(candidate) {
 369         mv += CandidateMidgameBonus[relative_rank(us, s)];
 370         ev += CandidateEndgameBonus[relative_rank(us, s)];
 371       }
 372
 373       mgValue[us] += mv;
 374       egValue[us] += ev;
 375
 376       // If the pawn is passed, set the square of the pawn in the passedPawns
 377       // bitboard:
 378       if(passed)
 379         set_bit(&(pi->passedPawns), s);
 380     }
 381   }
 382
 383   pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
 384   pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
 385
 386   return pi;
 387 }