dcd3eb2485316441a986f785b761588cbe0b77d2
[stockfish] / src / position.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-2014 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 #include <algorithm>
21 #include <cassert>
22 #include <cstring>
23 #include <iomanip>
24 #include <sstream>
25
26 #include "bitcount.h"
27 #include "movegen.h"
28 #include "notation.h"
29 #include "position.h"
30 #include "psqtab.h"
31 #include "rkiss.h"
32 #include "thread.h"
33 #include "tt.h"
34
35 using std::string;
36
37 static const string PieceToChar(" PNBRQK  pnbrqk");
38
39 CACHE_LINE_ALIGNMENT
40
41 Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
42 Value PieceValue[PHASE_NB][PIECE_NB] = {
43 { VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
44 { VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } };
45
46 namespace Zobrist {
47
48   Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
49   Key enpassant[FILE_NB];
50   Key castling[CASTLING_FLAG_NB];
51   Key side;
52   Key exclusion;
53 }
54
55 Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion;}
56
57 namespace {
58
59 // min_attacker() is a helper function used by see() to locate the least
60 // valuable attacker for the side to move, remove the attacker we just found
61 // from the bitboards and scan for new X-ray attacks behind it.
62
63 template<int Pt> FORCE_INLINE
64 PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers,
65                        Bitboard& occupied, Bitboard& attackers) {
66
67   Bitboard b = stmAttackers & bb[Pt];
68   if (!b)
69       return min_attacker<Pt+1>(bb, to, stmAttackers, occupied, attackers);
70
71   occupied ^= b & ~(b - 1);
72
73   if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
74       attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
75
76   if (Pt == ROOK || Pt == QUEEN)
77       attackers |= attacks_bb<ROOK>(to, occupied) & (bb[ROOK] | bb[QUEEN]);
78
79   attackers &= occupied; // After X-ray that may add already processed pieces
80   return (PieceType)Pt;
81 }
82
83 template<> FORCE_INLINE
84 PieceType min_attacker<KING>(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) {
85   return KING; // No need to update bitboards: it is the last cycle
86 }
87
88 } // namespace
89
90
91 /// CheckInfo c'tor
92
93 CheckInfo::CheckInfo(const Position& pos) {
94
95   Color them = ~pos.side_to_move();
96   ksq = pos.king_square(them);
97
98   pinned = pos.pinned_pieces(pos.side_to_move());
99   dcCandidates = pos.discovered_check_candidates();
100
101   checkSq[PAWN]   = pos.attacks_from<PAWN>(ksq, them);
102   checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
103   checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
104   checkSq[ROOK]   = pos.attacks_from<ROOK>(ksq);
105   checkSq[QUEEN]  = checkSq[BISHOP] | checkSq[ROOK];
106   checkSq[KING]   = 0;
107 }
108
109
110 /// Position::init() initializes at startup the various arrays used to compute
111 /// hash keys and the piece square tables. The latter is a two-step operation:
112 /// Firstly, the white halves of the tables are copied from PSQT[] tables.
113 /// Secondly, the black halves of the tables are initialized by flipping and
114 /// changing the sign of the white scores.
115
116 void Position::init() {
117
118   RKISS rk;
119
120   for (Color c = WHITE; c <= BLACK; ++c)
121       for (PieceType pt = PAWN; pt <= KING; ++pt)
122           for (Square s = SQ_A1; s <= SQ_H8; ++s)
123               Zobrist::psq[c][pt][s] = rk.rand<Key>();
124
125   for (File f = FILE_A; f <= FILE_H; ++f)
126       Zobrist::enpassant[f] = rk.rand<Key>();
127
128   for (int cf = NO_CASTLING; cf <= ANY_CASTLING; ++cf)
129   {
130       Bitboard b = cf;
131       while (b)
132       {
133           Key k = Zobrist::castling[1ULL << pop_lsb(&b)];
134           Zobrist::castling[cf] ^= k ? k : rk.rand<Key>();
135       }
136   }
137
138   Zobrist::side = rk.rand<Key>();
139   Zobrist::exclusion  = rk.rand<Key>();
140
141   for (PieceType pt = PAWN; pt <= KING; ++pt)
142   {
143       PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
144       PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
145
146       Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
147
148       for (Square s = SQ_A1; s <= SQ_H8; ++s)
149       {
150          psq[WHITE][pt][ s] =  (v + PSQT[pt][s]);
151          psq[BLACK][pt][~s] = -(v + PSQT[pt][s]);
152       }
153   }
154 }
155
156
157 /// Position::operator=() creates a copy of 'pos'. We want the new born Position
158 /// object to not depend on any external data so we detach state pointer from
159 /// the source one.
160
161 Position& Position::operator=(const Position& pos) {
162
163   std::memcpy(this, &pos, sizeof(Position));
164   startState = *st;
165   st = &startState;
166   nodes = 0;
167
168   assert(pos_is_ok());
169
170   return *this;
171 }
172
173
174 /// Position::set() initializes the position object with the given FEN string.
175 /// This function is not very robust - make sure that input FENs are correct,
176 /// this is assumed to be the responsibility of the GUI.
177
178 void Position::set(const string& fenStr, bool isChess960, Thread* th) {
179 /*
180    A FEN string defines a particular position using only the ASCII character set.
181
182    A FEN string contains six fields separated by a space. The fields are:
183
184    1) Piece placement (from white's perspective). Each rank is described, starting
185       with rank 8 and ending with rank 1. Within each rank, the contents of each
186       square are described from file A through file H. Following the Standard
187       Algebraic Notation (SAN), each piece is identified by a single letter taken
188       from the standard English names. White pieces are designated using upper-case
189       letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are
190       noted using digits 1 through 8 (the number of blank squares), and "/"
191       separates ranks.
192
193    2) Active color. "w" means white moves next, "b" means black.
194
195    3) Castling availability. If neither side can castle, this is "-". Otherwise,
196       this has one or more letters: "K" (White can castle kingside), "Q" (White
197       can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
198       can castle queenside).
199
200    4) En passant target square (in algebraic notation). If there's no en passant
201       target square, this is "-". If a pawn has just made a 2-square move, this
202       is the position "behind" the pawn. This is recorded regardless of whether
203       there is a pawn in position to make an en passant capture.
204
205    5) Halfmove clock. This is the number of halfmoves since the last pawn advance
206       or capture. This is used to determine if a draw can be claimed under the
207       fifty-move rule.
208
209    6) Fullmove number. The number of the full move. It starts at 1, and is
210       incremented after Black's move.
211 */
212
213   char col, row, token;
214   size_t idx;
215   Square sq = SQ_A8;
216   std::istringstream ss(fenStr);
217
218   clear();
219   ss >> std::noskipws;
220
221   // 1. Piece placement
222   while ((ss >> token) && !isspace(token))
223   {
224       if (isdigit(token))
225           sq += Square(token - '0'); // Advance the given number of files
226
227       else if (token == '/')
228           sq -= Square(16);
229
230       else if ((idx = PieceToChar.find(token)) != string::npos)
231       {
232           put_piece(sq, color_of(Piece(idx)), type_of(Piece(idx)));
233           ++sq;
234       }
235   }
236
237   // 2. Active color
238   ss >> token;
239   sideToMove = (token == 'w' ? WHITE : BLACK);
240   ss >> token;
241
242   // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
243   // Shredder-FEN that uses the letters of the columns on which the rooks began
244   // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
245   // if an inner rook is associated with the castling right, the castling tag is
246   // replaced by the file letter of the involved rook, as for the Shredder-FEN.
247   while ((ss >> token) && !isspace(token))
248   {
249       Square rsq;
250       Color c = islower(token) ? BLACK : WHITE;
251
252       token = char(toupper(token));
253
254       if (token == 'K')
255           for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {}
256
257       else if (token == 'Q')
258           for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {}
259
260       else if (token >= 'A' && token <= 'H')
261           rsq = File(token - 'A') | relative_rank(c, RANK_1);
262
263       else
264           continue;
265
266       set_castling_flag(c, rsq);
267   }
268
269   // 4. En passant square. Ignore if no pawn capture is possible
270   if (   ((ss >> col) && (col >= 'a' && col <= 'h'))
271       && ((ss >> row) && (row == '3' || row == '6')))
272   {
273       st->epSquare = File(col - 'a') | Rank(row - '1');
274
275       if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
276           st->epSquare = SQ_NONE;
277   }
278
279   // 5-6. Halfmove clock and fullmove number
280   ss >> std::skipws >> st->rule50 >> gamePly;
281
282   // Convert from fullmove starting from 1 to ply starting from 0,
283   // handle also common incorrect FEN with fullmove = 0.
284   gamePly = std::max(2 * (gamePly - 1), 0) + int(sideToMove == BLACK);
285
286   st->key = compute_key();
287   st->pawnKey = compute_pawn_key();
288   st->materialKey = compute_material_key();
289   st->psq = compute_psq_score();
290   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
291   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
292   st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
293   chess960 = isChess960;
294   thisThread = th;
295
296   assert(pos_is_ok());
297 }
298
299
300 /// Position::set_castling_flag() is a helper function used to set castling
301 /// flags given the corresponding color and the rook starting square.
302
303 void Position::set_castling_flag(Color c, Square rfrom) {
304
305   Square kfrom = king_square(c);
306   CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
307   CastlingFlag cf = (c | cs);
308
309   st->castlingFlags |= cf;
310   castlingFlagsMask[kfrom] |= cf;
311   castlingFlagsMask[rfrom] |= cf;
312   castlingRookSquare[cf] = rfrom;
313
314   Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
315   Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
316
317   for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
318       if (s != kfrom && s != rfrom)
319           castlingPath[cf] |= s;
320
321   for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
322       if (s != kfrom && s != rfrom)
323           castlingPath[cf] |= s;
324 }
325
326
327 /// Position::fen() returns a FEN representation of the position. In case of
328 /// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
329
330 const string Position::fen() const {
331
332   int emptyCnt;
333   std::ostringstream ss;
334
335   for (Rank rank = RANK_8; rank >= RANK_1; --rank)
336   {
337       for (File file = FILE_A; file <= FILE_H; ++file)
338       {
339           for (emptyCnt = 0; file <= FILE_H && empty(file | rank); ++file)
340               ++emptyCnt;
341
342           if (emptyCnt)
343               ss << emptyCnt;
344
345           if (file <= FILE_H)
346               ss << PieceToChar[piece_on(file | rank)];
347       }
348
349       if (rank > RANK_1)
350           ss << '/';
351   }
352
353   ss << (sideToMove == WHITE ? " w " : " b ");
354
355   if (can_castle(WHITE_OO))
356       ss << (chess960 ? to_char(file_of(castling_rook_square(WHITE |  KING_SIDE)), false) : 'K');
357
358   if (can_castle(WHITE_OOO))
359       ss << (chess960 ? to_char(file_of(castling_rook_square(WHITE | QUEEN_SIDE)), false) : 'Q');
360
361   if (can_castle(BLACK_OO))
362       ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK |  KING_SIDE)),  true) : 'k');
363
364   if (can_castle(BLACK_OOO))
365       ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK | QUEEN_SIDE)),  true) : 'q');
366
367   if (!can_castle(WHITE) && !can_castle(BLACK))
368       ss << '-';
369
370   ss << (ep_square() == SQ_NONE ? " - " : " " + to_string(ep_square()) + " ")
371      << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
372
373   return ss.str();
374 }
375
376
377 /// Position::pretty() returns an ASCII representation of the position to be
378 /// printed to the standard output together with the move's san notation.
379
380 const string Position::pretty(Move move) const {
381
382   const string dottedLine =            "\n+---+---+---+---+---+---+---+---+";
383   const string twoRows =  dottedLine + "\n|   | . |   | . |   | . |   | . |"
384                         + dottedLine + "\n| . |   | . |   | . |   | . |   |";
385
386   string brd = twoRows + twoRows + twoRows + twoRows + dottedLine;
387
388   for (Bitboard b = pieces(); b; )
389   {
390       Square s = pop_lsb(&b);
391       brd[513 - 68 * rank_of(s) + 4 * file_of(s)] = PieceToChar[piece_on(s)];
392   }
393
394   std::ostringstream ss;
395
396   if (move)
397       ss << "\nMove: " << (sideToMove == BLACK ? ".." : "")
398          << move_to_san(*const_cast<Position*>(this), move);
399
400   ss << brd << "\nFen: " << fen() << "\nKey: " << std::hex << std::uppercase
401      << std::setfill('0') << std::setw(16) << st->key << "\nCheckers: ";
402
403   for (Bitboard b = checkers(); b; )
404       ss << to_string(pop_lsb(&b)) << " ";
405
406   ss << "\nLegal moves: ";
407   for (MoveList<LEGAL> it(*this); *it; ++it)
408       ss << move_to_san(*const_cast<Position*>(this), *it) << " ";
409
410   return ss.str();
411 }
412
413
414 /// Position::check_blockers() returns a bitboard of all the pieces with color
415 /// 'c' that are blocking check on the king with color 'kingColor'. A piece
416 /// blocks a check if removing that piece from the board would result in a
417 /// position where the king is in check. A check blocking piece can be either a
418 /// pinned or a discovered check piece, according if its color 'c' is the same
419 /// or the opposite of 'kingColor'.
420
421 Bitboard Position::check_blockers(Color c, Color kingColor) const {
422
423   Bitboard b, pinners, result = 0;
424   Square ksq = king_square(kingColor);
425
426   // Pinners are sliders that give check when a pinned piece is removed
427   pinners = (  (pieces(  ROOK, QUEEN) & PseudoAttacks[ROOK  ][ksq])
428              | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(~kingColor);
429
430   while (pinners)
431   {
432       b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
433
434       if (!more_than_one(b))
435           result |= b & pieces(c);
436   }
437   return result;
438 }
439
440
441 /// Position::attackers_to() computes a bitboard of all pieces which attack a
442 /// given square. Slider attacks use the occ bitboard to indicate occupancy.
443
444 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
445
446   return  (attacks_from<PAWN>(s, BLACK) & pieces(WHITE, PAWN))
447         | (attacks_from<PAWN>(s, WHITE) & pieces(BLACK, PAWN))
448         | (attacks_from<KNIGHT>(s)      & pieces(KNIGHT))
449         | (attacks_bb<ROOK>(s, occ)     & pieces(ROOK, QUEEN))
450         | (attacks_bb<BISHOP>(s, occ)   & pieces(BISHOP, QUEEN))
451         | (attacks_from<KING>(s)        & pieces(KING));
452 }
453
454
455 /// Position::legal() tests whether a pseudo-legal move is legal
456
457 bool Position::legal(Move m, Bitboard pinned) const {
458
459   assert(is_ok(m));
460   assert(pinned == pinned_pieces(sideToMove));
461
462   Color us = sideToMove;
463   Square from = from_sq(m);
464
465   assert(color_of(moved_piece(m)) == us);
466   assert(piece_on(king_square(us)) == make_piece(us, KING));
467
468   // En passant captures are a tricky special case. Because they are rather
469   // uncommon, we do it simply by testing whether the king is attacked after
470   // the move is made.
471   if (type_of(m) == ENPASSANT)
472   {
473       Color them = ~us;
474       Square to = to_sq(m);
475       Square capsq = to + pawn_push(them);
476       Square ksq = king_square(us);
477       Bitboard b = (pieces() ^ from ^ capsq) | to;
478
479       assert(to == ep_square());
480       assert(moved_piece(m) == make_piece(us, PAWN));
481       assert(piece_on(capsq) == make_piece(them, PAWN));
482       assert(piece_on(to) == NO_PIECE);
483
484       return   !(attacks_bb<  ROOK>(ksq, b) & pieces(them, QUEEN, ROOK))
485             && !(attacks_bb<BISHOP>(ksq, b) & pieces(them, QUEEN, BISHOP));
486   }
487
488   // If the moving piece is a king, check whether the destination
489   // square is attacked by the opponent. Castling moves are checked
490   // for legality during move generation.
491   if (type_of(piece_on(from)) == KING)
492       return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
493
494   // A non-king move is legal if and only if it is not pinned or it
495   // is moving along the ray towards or away from the king.
496   return   !pinned
497         || !(pinned & from)
498         ||  aligned(from, to_sq(m), king_square(us));
499 }
500
501
502 /// Position::pseudo_legal() takes a random move and tests whether the move is
503 /// pseudo legal. It is used to validate moves from TT that can be corrupted
504 /// due to SMP concurrent access or hash position key aliasing.
505
506 bool Position::pseudo_legal(const Move m) const {
507
508   Color us = sideToMove;
509   Square from = from_sq(m);
510   Square to = to_sq(m);
511   Piece pc = moved_piece(m);
512
513   // Use a slower but simpler function for uncommon cases
514   if (type_of(m) != NORMAL)
515       return MoveList<LEGAL>(*this).contains(m);
516
517   // Is not a promotion, so promotion piece must be empty
518   if (promotion_type(m) - 2 != NO_PIECE_TYPE)
519       return false;
520
521   // If the 'from' square is not occupied by a piece belonging to the side to
522   // move, the move is obviously not legal.
523   if (pc == NO_PIECE || color_of(pc) != us)
524       return false;
525
526   // The destination square cannot be occupied by a friendly piece
527   if (pieces(us) & to)
528       return false;
529
530   // Handle the special case of a pawn move
531   if (type_of(pc) == PAWN)
532   {
533       // Move direction must be compatible with pawn color
534       int direction = to - from;
535       if ((us == WHITE) != (direction > 0))
536           return false;
537
538       // We have already handled promotion moves, so destination
539       // cannot be on the 8th/1st rank.
540       if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
541           return false;
542
543       // Proceed according to the square delta between the origin and
544       // destination squares.
545       switch (direction)
546       {
547       case DELTA_NW:
548       case DELTA_NE:
549       case DELTA_SW:
550       case DELTA_SE:
551       // Capture. The destination square must be occupied by an enemy
552       // piece (en passant captures was handled earlier).
553       if (piece_on(to) == NO_PIECE || color_of(piece_on(to)) != ~us)
554           return false;
555
556       // From and to files must be one file apart, avoids a7h5
557       if (abs(file_of(from) - file_of(to)) != 1)
558           return false;
559       break;
560
561       case DELTA_N:
562       case DELTA_S:
563       // Pawn push. The destination square must be empty.
564       if (!empty(to))
565           return false;
566       break;
567
568       case DELTA_NN:
569       // Double white pawn push. The destination square must be on the fourth
570       // rank, and both the destination square and the square between the
571       // source and destination squares must be empty.
572       if (    rank_of(to) != RANK_4
573           || !empty(to)
574           || !empty(from + DELTA_N))
575           return false;
576       break;
577
578       case DELTA_SS:
579       // Double black pawn push. The destination square must be on the fifth
580       // rank, and both the destination square and the square between the
581       // source and destination squares must be empty.
582       if (    rank_of(to) != RANK_5
583           || !empty(to)
584           || !empty(from + DELTA_S))
585           return false;
586       break;
587
588       default:
589           return false;
590       }
591   }
592   else if (!(attacks_from(pc, from) & to))
593       return false;
594
595   // Evasions generator already takes care to avoid some kind of illegal moves
596   // and pl_move_is_legal() relies on this. We therefore have to take care that
597   // the same kind of moves are filtered out here.
598   if (checkers())
599   {
600       if (type_of(pc) != KING)
601       {
602           // Double check? In this case a king move is required
603           if (more_than_one(checkers()))
604               return false;
605
606           // Our move must be a blocking evasion or a capture of the checking piece
607           if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to))
608               return false;
609       }
610       // In case of king moves under check we have to remove king so as to catch
611       // invalid moves like b1a1 when opposite queen is on c1.
612       else if (attackers_to(to, pieces() ^ from) & pieces(~us))
613           return false;
614   }
615
616   return true;
617 }
618
619
620 /// Position::gives_check() tests whether a pseudo-legal move gives a check
621
622 bool Position::gives_check(Move m, const CheckInfo& ci) const {
623
624   assert(is_ok(m));
625   assert(ci.dcCandidates == discovered_check_candidates());
626   assert(color_of(moved_piece(m)) == sideToMove);
627
628   Square from = from_sq(m);
629   Square to = to_sq(m);
630   PieceType pt = type_of(piece_on(from));
631
632   // Is there a direct check?
633   if (ci.checkSq[pt] & to)
634       return true;
635
636   // Is there a discovered check?
637   if (   unlikely(ci.dcCandidates)
638       && (ci.dcCandidates & from)
639       && !aligned(from, to, ci.ksq))
640       return true;
641
642   // Can we skip the ugly special cases?
643   if (type_of(m) == NORMAL)
644       return false;
645
646   switch (type_of(m))
647   {
648   case PROMOTION:
649       return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ci.ksq;
650
651   // En passant capture with check? We have already handled the case
652   // of direct checks and ordinary discovered check, so the only case we
653   // need to handle is the unusual case of a discovered check through
654   // the captured pawn.
655   case ENPASSANT:
656   {
657       Square capsq = file_of(to) | rank_of(from);
658       Bitboard b = (pieces() ^ from ^ capsq) | to;
659
660       return  (attacks_bb<  ROOK>(ci.ksq, b) & pieces(sideToMove, QUEEN, ROOK))
661             | (attacks_bb<BISHOP>(ci.ksq, b) & pieces(sideToMove, QUEEN, BISHOP));
662   }
663   case CASTLING:
664   {
665       Square kfrom = from;
666       Square rfrom = to; // Castling is encoded as 'King captures the rook'
667       Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1);
668       Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1);
669
670       return   (PseudoAttacks[ROOK][rto] & ci.ksq)
671             && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ci.ksq);
672   }
673   default:
674       assert(false);
675       return false;
676   }
677 }
678
679
680 /// Position::do_move() makes a move, and saves all information necessary
681 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
682 /// moves should be filtered out before this function is called.
683
684 void Position::do_move(Move m, StateInfo& newSt) {
685
686   CheckInfo ci(*this);
687   do_move(m, newSt, ci, gives_check(m, ci));
688 }
689
690 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
691
692   assert(is_ok(m));
693   assert(&newSt != st);
694
695   ++nodes;
696   Key k = st->key;
697
698   // Copy some fields of the old state to our new StateInfo object except the
699   // ones which are going to be recalculated from scratch anyway and then switch
700   // our state pointer to point to the new (ready to be updated) state.
701   std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t));
702
703   newSt.previous = st;
704   st = &newSt;
705
706   // Update side to move
707   k ^= Zobrist::side;
708
709   // Increment ply counters. In particular, rule50 will be reset to zero later on
710   // in case of a capture or a pawn move.
711   ++gamePly;
712   ++st->rule50;
713   ++st->pliesFromNull;
714
715   Color us = sideToMove;
716   Color them = ~us;
717   Square from = from_sq(m);
718   Square to = to_sq(m);
719   Piece pc = piece_on(from);
720   PieceType pt = type_of(pc);
721   PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
722
723   assert(color_of(pc) == us);
724   assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING);
725   assert(captured != KING);
726
727   if (type_of(m) == CASTLING)
728   {
729       assert(pc == make_piece(us, KING));
730
731       bool kingSide = to > from;
732       Square rfrom = to; // Castling is encoded as "king captures friendly rook"
733       Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
734       to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
735       captured = NO_PIECE_TYPE;
736
737       do_castling(from, to, rfrom, rto);
738
739       st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom];
740       k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
741   }
742
743   if (captured)
744   {
745       Square capsq = to;
746
747       // If the captured piece is a pawn, update pawn hash key, otherwise
748       // update non-pawn material.
749       if (captured == PAWN)
750       {
751           if (type_of(m) == ENPASSANT)
752           {
753               capsq += pawn_push(them);
754
755               assert(pt == PAWN);
756               assert(to == st->epSquare);
757               assert(relative_rank(us, to) == RANK_6);
758               assert(piece_on(to) == NO_PIECE);
759               assert(piece_on(capsq) == make_piece(them, PAWN));
760
761               board[capsq] = NO_PIECE;
762           }
763
764           st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
765       }
766       else
767           st->npMaterial[them] -= PieceValue[MG][captured];
768
769       // Update board and piece lists
770       remove_piece(capsq, them, captured);
771
772       // Update material hash key and prefetch access to materialTable
773       k ^= Zobrist::psq[them][captured][capsq];
774       st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]];
775       prefetch((char*)thisThread->materialTable[st->materialKey]);
776
777       // Update incremental scores
778       st->psq -= psq[them][captured][capsq];
779
780       // Reset rule 50 counter
781       st->rule50 = 0;
782   }
783
784   // Update hash key
785   k ^= Zobrist::psq[us][pt][from] ^ Zobrist::psq[us][pt][to];
786
787   // Reset en passant square
788   if (st->epSquare != SQ_NONE)
789   {
790       k ^= Zobrist::enpassant[file_of(st->epSquare)];
791       st->epSquare = SQ_NONE;
792   }
793
794   // Update castling flags if needed
795   if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to]))
796   {
797       int cf = castlingFlagsMask[from] | castlingFlagsMask[to];
798       k ^= Zobrist::castling[st->castlingFlags & cf];
799       st->castlingFlags &= ~cf;
800   }
801
802   // Prefetch TT access as soon as we know the new hash key
803   prefetch((char*)TT.first_entry(k));
804
805   // Move the piece. The tricky Chess960 castling is handled earlier
806   if (type_of(m) != CASTLING)
807       move_piece(from, to, us, pt);
808
809   // If the moving piece is a pawn do some special extra work
810   if (pt == PAWN)
811   {
812       // Set en-passant square if the moved pawn can be captured
813       if (   (int(to) ^ int(from)) == 16
814           && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
815       {
816           st->epSquare = Square((from + to) / 2);
817           k ^= Zobrist::enpassant[file_of(st->epSquare)];
818       }
819
820       if (type_of(m) == PROMOTION)
821       {
822           PieceType promotion = promotion_type(m);
823
824           assert(relative_rank(us, to) == RANK_8);
825           assert(promotion >= KNIGHT && promotion <= QUEEN);
826
827           remove_piece(to, us, PAWN);
828           put_piece(to, us, promotion);
829
830           // Update hash keys
831           k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to];
832           st->pawnKey ^= Zobrist::psq[us][PAWN][to];
833           st->materialKey ^=  Zobrist::psq[us][promotion][pieceCount[us][promotion]-1]
834                             ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
835
836           // Update incremental score
837           st->psq += psq[us][promotion][to] - psq[us][PAWN][to];
838
839           // Update material
840           st->npMaterial[us] += PieceValue[MG][promotion];
841       }
842
843       // Update pawn hash key and prefetch access to pawnsTable
844       st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to];
845       prefetch((char*)thisThread->pawnsTable[st->pawnKey]);
846
847       // Reset rule 50 draw counter
848       st->rule50 = 0;
849   }
850
851   // Update incremental scores
852   st->psq += psq[us][pt][to] - psq[us][pt][from];
853
854   // Set capture piece
855   st->capturedType = captured;
856
857   // Update the key with the final value
858   st->key = k;
859
860   // Update checkers bitboard: piece must be already moved
861   st->checkersBB = 0;
862
863   if (moveIsCheck)
864   {
865       if (type_of(m) != NORMAL)
866           st->checkersBB = attackers_to(king_square(them)) & pieces(us);
867       else
868       {
869           // Direct checks
870           if (ci.checkSq[pt] & to)
871               st->checkersBB |= to;
872
873           // Discovered checks
874           if (ci.dcCandidates && (ci.dcCandidates & from))
875           {
876               if (pt != ROOK)
877                   st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(us, QUEEN, ROOK);
878
879               if (pt != BISHOP)
880                   st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(us, QUEEN, BISHOP);
881           }
882       }
883   }
884
885   sideToMove = ~sideToMove;
886
887   assert(pos_is_ok());
888 }
889
890
891 /// Position::undo_move() unmakes a move. When it returns, the position should
892 /// be restored to exactly the same state as before the move was made.
893
894 void Position::undo_move(Move m) {
895
896   assert(is_ok(m));
897
898   sideToMove = ~sideToMove;
899
900   Color us = sideToMove;
901   Color them = ~us;
902   Square from = from_sq(m);
903   Square to = to_sq(m);
904   PieceType pt = type_of(piece_on(to));
905   PieceType captured = st->capturedType;
906
907   assert(empty(from) || type_of(m) == CASTLING);
908   assert(captured != KING);
909
910   if (type_of(m) == PROMOTION)
911   {
912       PieceType promotion = promotion_type(m);
913
914       assert(promotion == pt);
915       assert(relative_rank(us, to) == RANK_8);
916       assert(promotion >= KNIGHT && promotion <= QUEEN);
917
918       remove_piece(to, us, promotion);
919       put_piece(to, us, PAWN);
920       pt = PAWN;
921   }
922
923   if (type_of(m) == CASTLING)
924   {
925       bool kingSide = to > from;
926       Square rfrom = to; // Castling is encoded as "king captures friendly rook"
927       Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
928       to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
929       captured = NO_PIECE_TYPE;
930       pt = KING;
931       do_castling(to, from, rto, rfrom);
932   }
933   else
934       move_piece(to, from, us, pt); // Put the piece back at the source square
935
936   if (captured)
937   {
938       Square capsq = to;
939
940       if (type_of(m) == ENPASSANT)
941       {
942           capsq -= pawn_push(us);
943
944           assert(pt == PAWN);
945           assert(to == st->previous->epSquare);
946           assert(relative_rank(us, to) == RANK_6);
947           assert(piece_on(capsq) == NO_PIECE);
948       }
949
950       put_piece(capsq, them, captured); // Restore the captured piece
951   }
952
953   // Finally point our state pointer back to the previous state
954   st = st->previous;
955   --gamePly;
956
957   assert(pos_is_ok());
958 }
959
960
961 /// Position::do_castling() is a helper used to do/undo a castling move. This
962 /// is a bit tricky, especially in Chess960.
963
964 void Position::do_castling(Square kfrom, Square kto, Square rfrom, Square rto) {
965
966   // Remove both pieces first since squares could overlap in Chess960
967   remove_piece(kfrom, sideToMove, KING);
968   remove_piece(rfrom, sideToMove, ROOK);
969   board[kfrom] = board[rfrom] = NO_PIECE; // Since remove_piece doesn't do it for us
970   put_piece(kto, sideToMove, KING);
971   put_piece(rto, sideToMove, ROOK);
972 }
973
974
975 /// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips
976 /// the side to move without executing any move on the board.
977
978 void Position::do_null_move(StateInfo& newSt) {
979
980   assert(!checkers());
981
982   std::memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here
983
984   newSt.previous = st;
985   st = &newSt;
986
987   if (st->epSquare != SQ_NONE)
988   {
989       st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
990       st->epSquare = SQ_NONE;
991   }
992
993   st->key ^= Zobrist::side;
994   prefetch((char*)TT.first_entry(st->key));
995
996   ++st->rule50;
997   st->pliesFromNull = 0;
998
999   sideToMove = ~sideToMove;
1000
1001   assert(pos_is_ok());
1002 }
1003
1004 void Position::undo_null_move() {
1005
1006   assert(!checkers());
1007
1008   st = st->previous;
1009   sideToMove = ~sideToMove;
1010 }
1011
1012
1013 /// Position::see() is a static exchange evaluator: It tries to estimate the
1014 /// material gain or loss resulting from a move.
1015
1016 Value Position::see_sign(Move m) const {
1017
1018   assert(is_ok(m));
1019
1020   // Early return if SEE cannot be negative because captured piece value
1021   // is not less then capturing one. Note that king moves always return
1022   // here because king midgame value is set to 0.
1023   if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))])
1024       return VALUE_KNOWN_WIN;
1025
1026   return see(m);
1027 }
1028
1029 Value Position::see(Move m) const {
1030
1031   Square from, to;
1032   Bitboard occupied, attackers, stmAttackers;
1033   Value swapList[32];
1034   int slIndex = 1;
1035   PieceType captured;
1036   Color stm;
1037
1038   assert(is_ok(m));
1039
1040   from = from_sq(m);
1041   to = to_sq(m);
1042   swapList[0] = PieceValue[MG][piece_on(to)];
1043   stm = color_of(piece_on(from));
1044   occupied = pieces() ^ from;
1045
1046   // Castling moves are implemented as king capturing the rook so cannot be
1047   // handled correctly. Simply return 0 that is always the correct value
1048   // unless in the rare case the rook ends up under attack.
1049   if (type_of(m) == CASTLING)
1050       return VALUE_ZERO;
1051
1052   if (type_of(m) == ENPASSANT)
1053   {
1054       occupied ^= to - pawn_push(stm); // Remove the captured pawn
1055       swapList[0] = PieceValue[MG][PAWN];
1056   }
1057
1058   // Find all attackers to the destination square, with the moving piece
1059   // removed, but possibly an X-ray attacker added behind it.
1060   attackers = attackers_to(to, occupied) & occupied;
1061
1062   // If the opponent has no attackers we are finished
1063   stm = ~stm;
1064   stmAttackers = attackers & pieces(stm);
1065   if (!stmAttackers)
1066       return swapList[0];
1067
1068   // The destination square is defended, which makes things rather more
1069   // difficult to compute. We proceed by building up a "swap list" containing
1070   // the material gain or loss at each stop in a sequence of captures to the
1071   // destination square, where the sides alternately capture, and always
1072   // capture with the least valuable piece. After each capture, we look for
1073   // new X-ray attacks from behind the capturing piece.
1074   captured = type_of(piece_on(from));
1075
1076   do {
1077       assert(slIndex < 32);
1078
1079       // Add the new entry to the swap list
1080       swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured];
1081
1082       // Locate and remove the next least valuable attacker
1083       captured = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
1084
1085       // Stop before processing a king capture
1086       if (captured == KING)
1087       {
1088           if (stmAttackers == attackers)
1089               ++slIndex;
1090
1091           break;
1092       }
1093
1094       stm = ~stm;
1095       stmAttackers = attackers & pieces(stm);
1096       ++slIndex;
1097
1098   } while (stmAttackers);
1099
1100   // Having built the swap list, we negamax through it to find the best
1101   // achievable score from the point of view of the side to move.
1102   while (--slIndex)
1103       swapList[slIndex - 1] = std::min(-swapList[slIndex], swapList[slIndex - 1]);
1104
1105   return swapList[0];
1106 }
1107
1108
1109 /// Position::clear() erases the position object to a pristine state, with an
1110 /// empty board, white to move, and no castling rights.
1111
1112 void Position::clear() {
1113
1114   std::memset(this, 0, sizeof(Position));
1115   startState.epSquare = SQ_NONE;
1116   st = &startState;
1117
1118   for (int i = 0; i < PIECE_TYPE_NB; ++i)
1119       for (int j = 0; j < 16; ++j)
1120           pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE;
1121 }
1122
1123
1124 /// Position::compute_key() computes the hash key of the position. The hash
1125 /// key is usually updated incrementally as moves are made and unmade. The
1126 /// compute_key() function is only used when a new position is set up, and
1127 /// to verify the correctness of the hash key when running in debug mode.
1128
1129 Key Position::compute_key() const {
1130
1131   Key k = Zobrist::castling[st->castlingFlags];
1132
1133   for (Bitboard b = pieces(); b; )
1134   {
1135       Square s = pop_lsb(&b);
1136       k ^= Zobrist::psq[color_of(piece_on(s))][type_of(piece_on(s))][s];
1137   }
1138
1139   if (ep_square() != SQ_NONE)
1140       k ^= Zobrist::enpassant[file_of(ep_square())];
1141
1142   if (sideToMove == BLACK)
1143       k ^= Zobrist::side;
1144
1145   return k;
1146 }
1147
1148
1149 /// Position::compute_pawn_key() computes the hash key of the position. The
1150 /// hash key is usually updated incrementally as moves are made and unmade.
1151 /// The compute_pawn_key() function is only used when a new position is set
1152 /// up, and to verify the correctness of the pawn hash key when running in
1153 /// debug mode.
1154
1155 Key Position::compute_pawn_key() const {
1156
1157   Key k = 0;
1158
1159   for (Bitboard b = pieces(PAWN); b; )
1160   {
1161       Square s = pop_lsb(&b);
1162       k ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s];
1163   }
1164
1165   return k;
1166 }
1167
1168
1169 /// Position::compute_material_key() computes the hash key of the position.
1170 /// The hash key is usually updated incrementally as moves are made and unmade.
1171 /// The compute_material_key() function is only used when a new position is set
1172 /// up, and to verify the correctness of the material hash key when running in
1173 /// debug mode.
1174
1175 Key Position::compute_material_key() const {
1176
1177   Key k = 0;
1178
1179   for (Color c = WHITE; c <= BLACK; ++c)
1180       for (PieceType pt = PAWN; pt <= KING; ++pt)
1181           for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt)
1182               k ^= Zobrist::psq[c][pt][cnt];
1183
1184   return k;
1185 }
1186
1187
1188 /// Position::compute_psq_score() computes the incremental scores for the middlegame
1189 /// and the endgame. These functions are used to initialize the incremental scores
1190 /// when a new position is set up, and to verify that the scores are correctly
1191 /// updated by do_move and undo_move when the program is running in debug mode.
1192
1193 Score Position::compute_psq_score() const {
1194
1195   Score score = SCORE_ZERO;
1196
1197   for (Bitboard b = pieces(); b; )
1198   {
1199       Square s = pop_lsb(&b);
1200       Piece pc = piece_on(s);
1201       score += psq[color_of(pc)][type_of(pc)][s];
1202   }
1203
1204   return score;
1205 }
1206
1207
1208 /// Position::compute_non_pawn_material() computes the total non-pawn middlegame
1209 /// material value for the given side. Material values are updated incrementally
1210 /// during the search. This function is only used when initializing a new Position
1211 /// object.
1212
1213 Value Position::compute_non_pawn_material(Color c) const {
1214
1215   Value value = VALUE_ZERO;
1216
1217   for (PieceType pt = KNIGHT; pt <= QUEEN; ++pt)
1218       value += pieceCount[c][pt] * PieceValue[MG][pt];
1219
1220   return value;
1221 }
1222
1223
1224 /// Position::is_draw() tests whether the position is drawn by material, 50 moves
1225 /// rule or repetition. It does not detect stalemates.
1226
1227 bool Position::is_draw() const {
1228
1229   if (   !pieces(PAWN)
1230       && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg))
1231       return true;
1232
1233   if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
1234       return true;
1235
1236   StateInfo* stp = st;
1237   for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2)
1238   {
1239       stp = stp->previous->previous;
1240
1241       if (stp->key == st->key)
1242           return true; // Draw at first repetition
1243   }
1244
1245   return false;
1246 }
1247
1248
1249 /// Position::flip() flips position with the white and black sides reversed. This
1250 /// is only useful for debugging e.g. for finding evaluation symmetry bugs.
1251
1252 static char toggle_case(char c) {
1253   return char(islower(c) ? toupper(c) : tolower(c));
1254 }
1255
1256 void Position::flip() {
1257
1258   string f, token;
1259   std::stringstream ss(fen());
1260
1261   for (Rank rank = RANK_8; rank >= RANK_1; --rank) // Piece placement
1262   {
1263       std::getline(ss, token, rank > RANK_1 ? '/' : ' ');
1264       f.insert(0, token + (f.empty() ? " " : "/"));
1265   }
1266
1267   ss >> token; // Active color
1268   f += (token == "w" ? "B " : "W "); // Will be lowercased later
1269
1270   ss >> token; // Castling availability
1271   f += token + " ";
1272
1273   std::transform(f.begin(), f.end(), f.begin(), toggle_case);
1274
1275   ss >> token; // En passant square
1276   f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
1277
1278   std::getline(ss, token); // Half and full moves
1279   f += token;
1280
1281   set(f, is_chess960(), this_thread());
1282
1283   assert(pos_is_ok());
1284 }
1285
1286
1287 /// Position::pos_is_ok() performs some consistency checks for the position object.
1288 /// This is meant to be helpful when debugging.
1289
1290 bool Position::pos_is_ok(int* failedStep) const {
1291
1292   int dummy, *step = failedStep ? failedStep : &dummy;
1293
1294   // What features of the position should be verified?
1295   const bool all = false;
1296
1297   const bool debugBitboards       = all || false;
1298   const bool debugKingCount       = all || false;
1299   const bool debugKingCapture     = all || false;
1300   const bool debugCheckerCount    = all || false;
1301   const bool debugKey             = all || false;
1302   const bool debugMaterialKey     = all || false;
1303   const bool debugPawnKey         = all || false;
1304   const bool debugIncrementalEval = all || false;
1305   const bool debugNonPawnMaterial = all || false;
1306   const bool debugPieceCounts     = all || false;
1307   const bool debugPieceList       = all || false;
1308   const bool debugCastlingSquares = all || false;
1309
1310   *step = 1;
1311
1312   if (sideToMove != WHITE && sideToMove != BLACK)
1313       return false;
1314
1315   if ((*step)++, piece_on(king_square(WHITE)) != W_KING)
1316       return false;
1317
1318   if ((*step)++, piece_on(king_square(BLACK)) != B_KING)
1319       return false;
1320
1321   if ((*step)++, debugKingCount)
1322   {
1323       int kingCount[COLOR_NB] = {};
1324
1325       for (Square s = SQ_A1; s <= SQ_H8; ++s)
1326           if (type_of(piece_on(s)) == KING)
1327               ++kingCount[color_of(piece_on(s))];
1328
1329       if (kingCount[0] != 1 || kingCount[1] != 1)
1330           return false;
1331   }
1332
1333   if ((*step)++, debugKingCapture)
1334       if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove))
1335           return false;
1336
1337   if ((*step)++, debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1338       return false;
1339
1340   if ((*step)++, debugBitboards)
1341   {
1342       // The intersection of the white and black pieces must be empty
1343       if (pieces(WHITE) & pieces(BLACK))
1344           return false;
1345
1346       // The union of the white and black pieces must be equal to all
1347       // occupied squares
1348       if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1349           return false;
1350
1351       // Separate piece type bitboards must have empty intersections
1352       for (PieceType p1 = PAWN; p1 <= KING; ++p1)
1353           for (PieceType p2 = PAWN; p2 <= KING; ++p2)
1354               if (p1 != p2 && (pieces(p1) & pieces(p2)))
1355                   return false;
1356   }
1357
1358   if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)
1359       return false;
1360
1361   if ((*step)++, debugKey && st->key != compute_key())
1362       return false;
1363
1364   if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key())
1365       return false;
1366
1367   if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())
1368       return false;
1369
1370   if ((*step)++, debugIncrementalEval && st->psq != compute_psq_score())
1371       return false;
1372
1373   if ((*step)++, debugNonPawnMaterial)
1374       if (   st->npMaterial[WHITE] != compute_non_pawn_material(WHITE)
1375           || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1376           return false;
1377
1378   if ((*step)++, debugPieceCounts)
1379       for (Color c = WHITE; c <= BLACK; ++c)
1380           for (PieceType pt = PAWN; pt <= KING; ++pt)
1381               if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
1382                   return false;
1383
1384   if ((*step)++, debugPieceList)
1385       for (Color c = WHITE; c <= BLACK; ++c)
1386           for (PieceType pt = PAWN; pt <= KING; ++pt)
1387               for (int i = 0; i < pieceCount[c][pt];  ++i)
1388                   if (   board[pieceList[c][pt][i]] != make_piece(c, pt)
1389                       || index[pieceList[c][pt][i]] != i)
1390                       return false;
1391
1392   if ((*step)++, debugCastlingSquares)
1393       for (Color c = WHITE; c <= BLACK; ++c)
1394           for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
1395           {
1396               if (!can_castle(c | s))
1397                   continue;
1398
1399               if (  (castlingFlagsMask[king_square(c)] & (c | s)) != (c | s)
1400                   || piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
1401                   || castlingFlagsMask[castlingRookSquare[c | s]] != (c | s))
1402                   return false;
1403           }
1404
1405   *step = 0;
1406   return true;
1407 }