]> git.sesse.net Git - stockfish/blob - src/pawns.cpp
Rename OnePly in ONE_PLY
[stockfish] / 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-2010 Marco Costalba, Joona Kiiski, Tord Romstad
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 "bitcount.h"
29 #include "pawns.h"
30 #include "position.h"
31
32
33 ////
34 //// Local definitions
35 ////
36
37 namespace {
38
39   /// Constants and variables
40
41   #define S(mg, eg) make_score(mg, eg)
42
43   // Doubled pawn penalty by file
44   const Score DoubledPawnPenalty[8] = {
45     S(13, 43), S(20, 48), S(23, 48), S(23, 48),
46     S(23, 48), S(23, 48), S(20, 48), S(13, 43)
47   };
48
49   // Isolated pawn penalty by file
50   const Score IsolatedPawnPenalty[8] = {
51     S(25, 30), S(36, 35), S(40, 35), S(40, 35),
52     S(40, 35), S(40, 35), S(36, 35), S(25, 30)
53   };
54
55   // Backward pawn penalty by file
56   const Score BackwardPawnPenalty[8] = {
57     S(20, 28), S(29, 31), S(33, 31), S(33, 31),
58     S(33, 31), S(33, 31), S(29, 31), S(20, 28)
59   };
60
61   // Pawn chain membership bonus by file
62   const Score ChainBonus[8] = {
63     S(11,-1), S(13,-1), S(13,-1), S(14,-1),
64     S(14,-1), S(13,-1), S(13,-1), S(11,-1)
65   };
66
67   // Candidate passed pawn bonus by rank
68   const Score CandidateBonus[8] = {
69     S( 0, 0), S( 6, 13), S(6,13), S(14,29),
70     S(34,68), S(83,166), S(0, 0), S( 0, 0)
71   };
72
73   // Pawn storm tables for positions with opposite castling
74   const int QStormTable[64] = {
75     0,  0,  0,  0, 0, 0, 0, 0,
76   -22,-22,-22,-14,-6, 0, 0, 0,
77    -6,-10,-10,-10,-6, 0, 0, 0,
78     4, 12, 16, 12, 4, 0, 0, 0,
79    16, 23, 23, 16, 0, 0, 0, 0,
80    23, 31, 31, 23, 0, 0, 0, 0,
81    23, 31, 31, 23, 0, 0, 0, 0,
82     0,  0,  0,  0, 0, 0, 0, 0
83   };
84
85   const int KStormTable[64] = {
86     0, 0, 0,  0,  0,  0,  0,  0,
87     0, 0, 0,-10,-19,-28,-33,-33,
88     0, 0, 0,-10,-15,-19,-24,-24,
89     0, 0, 0,  0,  1,  1,  1,  1,
90     0, 0, 0,  0,  1, 10, 19, 19,
91     0, 0, 0,  0,  1, 19, 31, 27,
92     0, 0, 0,  0,  0, 22, 31, 22,
93     0, 0, 0,  0,  0,  0,  0,  0
94   };
95
96   // Pawn storm open file bonuses by file
97   const int16_t QStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
98   const int16_t KStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
99
100   // Pawn storm lever bonuses by file
101   const int StormLeverBonus[8] = { -8, -8, -13, 0, 0, -13, -8, -8 };
102
103   #undef S
104 }
105
106
107 ////
108 //// Functions
109 ////
110
111 /// PawnInfoTable c'tor and d'tor instantiated one each thread
112
113 PawnInfoTable::PawnInfoTable(unsigned numOfEntries) : size(numOfEntries) {
114
115   entries = new PawnInfo[size];
116   if (!entries)
117   {
118       std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
119                 << " bytes for pawn hash table." << std::endl;
120       Application::exit_with_failure();
121   }
122 }
123
124
125 PawnInfoTable::~PawnInfoTable() {
126
127   delete [] entries;
128 }
129
130
131 /// PawnInfo::clear() resets to zero the PawnInfo entry. Note that
132 /// kingSquares[] is initialized to SQ_NONE instead.
133
134 void PawnInfo::clear() {
135
136   memset(this, 0, sizeof(PawnInfo));
137   kingSquares[WHITE] = kingSquares[BLACK] = SQ_NONE;
138 }
139
140
141 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
142 /// a PawnInfo object, and returns a pointer to it. The result is also stored
143 /// in a hash table, so we don't have to recompute everything when the same
144 /// pawn structure occurs again.
145
146 PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
147
148   assert(pos.is_ok());
149
150   Key key = pos.get_pawn_key();
151   unsigned index = unsigned(key & (size - 1));
152   PawnInfo* pi = entries + index;
153
154   // If pi->key matches the position's pawn hash key, it means that we
155   // have analysed this pawn structure before, and we can simply return
156   // the information we found the last time instead of recomputing it.
157   if (pi->key == key)
158       return pi;
159
160   // Clear the PawnInfo object, and set the key
161   pi->clear();
162   pi->key = key;
163
164   // Calculate pawn attacks
165   Bitboard whitePawns = pos.pieces(PAWN, WHITE);
166   Bitboard blackPawns = pos.pieces(PAWN, BLACK);
167   pi->pawnAttacks[WHITE] = ((whitePawns << 9) & ~FileABB) | ((whitePawns << 7) & ~FileHBB);
168   pi->pawnAttacks[BLACK] = ((blackPawns >> 7) & ~FileABB) | ((blackPawns >> 9) & ~FileHBB);
169
170   // Evaluate pawns for both colors
171   pi->value =  evaluate_pawns<WHITE>(pos, whitePawns, blackPawns, pi)
172              - evaluate_pawns<BLACK>(pos, blackPawns, whitePawns, pi);
173   return pi;
174 }
175
176
177 /// PawnInfoTable::evaluate_pawns() evaluates each pawn of the given color
178
179 template<Color Us>
180 Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
181                                     Bitboard theirPawns, PawnInfo* pi) const {
182   Bitboard b;
183   Square s;
184   File f;
185   Rank r;
186   int bonus;
187   bool passed, isolated, doubled, opposed, chain, backward, candidate;
188   Score value = make_score(0, 0);
189   const Square* ptr = pos.piece_list_begin(Us, PAWN);
190
191   // Initialize pawn storm scores by giving bonuses for open files
192   for (f = FILE_A; f <= FILE_H; f++)
193       if (!(ourPawns & file_bb(f)))
194       {
195           pi->ksStormValue[Us] += KStormOpenFileBonus[f];
196           pi->qsStormValue[Us] += QStormOpenFileBonus[f];
197           pi->halfOpenFiles[Us] |= (1 << f);
198       }
199
200   // Loop through all pawns of the current color and score each pawn
201   while ((s = *ptr++) != SQ_NONE)
202   {
203       f = square_file(s);
204       r = square_rank(s);
205
206       assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
207
208       // Calculate kingside and queenside pawn storm scores for both colors to be
209       // used when evaluating middle game positions with opposite side castling.
210       bonus = (f >= FILE_F ? evaluate_pawn_storm<Us, KingSide>(s, r, f, theirPawns) : 0);
211       pi->ksStormValue[Us] += KStormTable[relative_square(Us, s)] + bonus;
212
213       bonus = (f <= FILE_C ? evaluate_pawn_storm<Us, QueenSide>(s, r, f, theirPawns) : 0);
214       pi->qsStormValue[Us] += QStormTable[relative_square(Us, s)] + bonus;
215
216       // Our rank plus previous one. Used for chain detection.
217       b = rank_bb(r) | rank_bb(Us == WHITE ? r - 1 : r + 1);
218
219       // Passed, isolated, doubled or member of a pawn
220       // chain (but not the backward one) ?
221       passed   = !(theirPawns & passed_pawn_mask(Us, s));
222       doubled  =   ourPawns   & squares_behind(Us, s);
223       opposed  =   theirPawns & squares_in_front_of(Us, s);
224       isolated = !(ourPawns   & neighboring_files_bb(f));
225       chain    =   ourPawns   & neighboring_files_bb(f) & b;
226
227       // Test for backward pawn
228       //
229       backward = false;
230
231       // If the pawn is passed, isolated, or member of a pawn chain
232       // it cannot be backward. If can capture an enemy pawn or if
233       // there are friendly pawns behind on neighboring files it cannot
234       // be backward either.
235       if (   !(passed | isolated | chain)
236           && !(ourPawns & attack_span_mask(opposite_color(Us), s))
237           && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
238       {
239           // We now know that there are no friendly pawns beside or behind this
240           // pawn on neighboring files. We now check whether the pawn is
241           // backward by looking in the forward direction on the neighboring
242           // files, and seeing whether we meet a friendly or an enemy pawn first.
243           b = pos.attacks_from<PAWN>(s, Us);
244
245           // Note that we are sure to find something because pawn is not passed
246           // nor isolated, so loop is potentially infinite, but it isn't.
247           while (!(b & (ourPawns | theirPawns)))
248               Us == WHITE ? b <<= 8 : b >>= 8;
249
250           // The friendly pawn needs to be at least two ranks closer than the enemy
251           // pawn in order to help the potentially backward pawn advance.
252           backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
253       }
254
255       assert(passed | opposed | (attack_span_mask(Us, s) & theirPawns));
256
257       // Test for candidate passed pawn
258       candidate =   !(opposed | passed)
259                  && (b = attack_span_mask(opposite_color(Us), s + pawn_push(Us)) & ourPawns) != EmptyBoardBB
260                  &&  count_1s_max_15(b) >= count_1s_max_15(attack_span_mask(Us, s) & theirPawns);
261
262       // In order to prevent doubled passed pawns from receiving a too big
263       // bonus, only the frontmost passed pawn on each file is considered as
264       // a true passed pawn.
265       if (passed && (ourPawns & squares_in_front_of(Us, s)))
266           passed = false;
267
268       // Mark the pawn as passed. Pawn will be properly scored in evaluation
269       // because we need full attack info to evaluate passed pawns.
270       if (passed)
271           set_bit(&(pi->passedPawns), s);
272
273       // Score this pawn
274       if (isolated)
275       {
276           value -= IsolatedPawnPenalty[f];
277           if (!opposed)
278               value -= IsolatedPawnPenalty[f] / 2;
279       }
280       if (doubled)
281           value -= DoubledPawnPenalty[f];
282
283       if (backward)
284       {
285           value -= BackwardPawnPenalty[f];
286           if (!opposed)
287               value -= BackwardPawnPenalty[f] / 2;
288       }
289       if (chain)
290           value += ChainBonus[f];
291
292       if (candidate)
293           value += CandidateBonus[relative_rank(Us, s)];
294   }
295
296   return value;
297 }
298
299
300 /// PawnInfoTable::evaluate_pawn_storm() evaluates each pawn which seems
301 /// to have good chances of creating an open file by exchanging itself
302 /// against an enemy pawn on an adjacent file.
303
304 template<Color Us, PawnInfoTable::SideType Side>
305 int PawnInfoTable::evaluate_pawn_storm(Square s, Rank r, File f, Bitboard theirPawns) const {
306
307   const Bitboard StormFilesBB = (Side == KingSide ? FileFBB | FileGBB | FileHBB
308                                                   : FileABB | FileBBB | FileCBB);
309   const int K = (Side == KingSide ? 2 : 4);
310   const File RookFile = (Side == KingSide ? FILE_H : FILE_A);
311
312   Bitboard b = attack_span_mask(Us, s) & theirPawns & StormFilesBB;
313   int bonus = 0;
314
315   while (b)
316   {
317       // Give a bonus according to the distance of the nearest enemy pawn
318       Square s2 = pop_1st_bit(&b);
319       Rank r2 = square_rank(s2);
320       int v = StormLeverBonus[f] - K * rank_distance(r, r2);
321
322       // If enemy pawn has no pawn beside itself is particularly vulnerable.
323       // Big bonus, especially against a weakness on the rook file
324       if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
325           v *= (square_file(s2) == RookFile ? 4 : 2);
326
327       bonus += v;
328   }
329   return bonus;
330 }
331
332
333 /// PawnInfo::updateShelter calculates and caches king shelter. It is called
334 /// only when king square changes, about 20% of total get_king_shelter() calls.
335 int PawnInfo::updateShelter(const Position& pos, Color c, Square ksq) {
336
337   Bitboard pawns = pos.pieces(PAWN, c) & this_and_neighboring_files_bb(ksq);
338   unsigned shelter = 0;
339   unsigned r = ksq & (7 << 3);
340
341   for (int i = 1, k = (c ? -8 : 8); i < 4; i++)
342   {
343       r += k;
344       shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
345   }
346   kingSquares[c] = ksq;
347   kingShelters[c] = shelter;
348   return shelter;
349 }