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-2012 Marco Costalba, Joona Kiiski, Tord Romstad
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.
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.
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/>.
39 // To convert a Piece to and from a FEN char
40 static const string PieceToChar(" PNBRQK pnbrqk");
42 // Material values arrays, indexed by Piece
43 const Value PieceValueMidgame[17] = {
45 PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
46 RookValueMidgame, QueenValueMidgame,
47 VALUE_ZERO, VALUE_ZERO, VALUE_ZERO,
48 PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
49 RookValueMidgame, QueenValueMidgame
52 const Value PieceValueEndgame[17] = {
54 PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
55 RookValueEndgame, QueenValueEndgame,
56 VALUE_ZERO, VALUE_ZERO, VALUE_ZERO,
57 PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
58 RookValueEndgame, QueenValueEndgame
63 Score pieceSquareTable[16][64];
67 Key psq[2][8][64]; // [color][pieceType][square]/[piece count]
68 Key enpassant[8]; // [file]
69 Key castle[16]; // [castleRight]
73 /// init() initializes at startup the various arrays used to compute hash keys
74 /// and the piece square tables. The latter is a two-step operation: First, the
75 /// white halves of the tables are copied from PSQT[] tables. Second, the black
76 /// halves of the tables are initialized by flipping and changing the sign of
83 for (Color c = WHITE; c <= BLACK; c++)
84 for (PieceType pt = PAWN; pt <= KING; pt++)
85 for (Square s = SQ_A1; s <= SQ_H8; s++)
86 psq[c][pt][s] = rk.rand<Key>();
88 for (File f = FILE_A; f <= FILE_H; f++)
89 enpassant[f] = rk.rand<Key>();
91 for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
96 Key k = castle[1ULL << pop_lsb(&b)];
97 castle[cr] ^= k ? k : rk.rand<Key>();
101 side = rk.rand<Key>();
102 exclusion = rk.rand<Key>();
104 for (PieceType pt = PAWN; pt <= KING; pt++)
106 Score v = make_score(PieceValueMidgame[pt], PieceValueEndgame[pt]);
108 for (Square s = SQ_A1; s <= SQ_H8; s++)
110 pieceSquareTable[make_piece(WHITE, pt)][ s] = (v + PSQT[pt][s]);
111 pieceSquareTable[make_piece(BLACK, pt)][~s] = -(v + PSQT[pt][s]);
116 } // namespace Zobrist
121 CheckInfo::CheckInfo(const Position& pos) {
123 Color them = ~pos.side_to_move();
124 ksq = pos.king_square(them);
126 pinned = pos.pinned_pieces();
127 dcCandidates = pos.discovered_check_candidates();
129 checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
130 checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
131 checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
132 checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
133 checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
138 /// Position::operator=() creates a copy of 'pos'. We want the new born Position
139 /// object do not depend on any external data so we detach state pointer from
142 Position& Position::operator=(const Position& pos) {
144 memcpy(this, &pos, sizeof(Position));
155 /// Position::from_fen() initializes the position object with the given FEN
156 /// string. This function is not very robust - make sure that input FENs are
157 /// correct (this is assumed to be the responsibility of the GUI).
159 void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) {
161 A FEN string defines a particular position using only the ASCII character set.
163 A FEN string contains six fields separated by a space. The fields are:
165 1) Piece placement (from white's perspective). Each rank is described, starting
166 with rank 8 and ending with rank 1; within each rank, the contents of each
167 square are described from file A through file H. Following the Standard
168 Algebraic Notation (SAN), each piece is identified by a single letter taken
169 from the standard English names. White pieces are designated using upper-case
170 letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
171 noted using digits 1 through 8 (the number of blank squares), and "/"
174 2) Active color. "w" means white moves next, "b" means black.
176 3) Castling availability. If neither side can castle, this is "-". Otherwise,
177 this has one or more letters: "K" (White can castle kingside), "Q" (White
178 can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
179 can castle queenside).
181 4) En passant target square (in algebraic notation). If there's no en passant
182 target square, this is "-". If a pawn has just made a 2-square move, this
183 is the position "behind" the pawn. This is recorded regardless of whether
184 there is a pawn in position to make an en passant capture.
186 5) Halfmove clock. This is the number of halfmoves since the last pawn advance
187 or capture. This is used to determine if a draw can be claimed under the
190 6) Fullmove number. The number of the full move. It starts at 1, and is
191 incremented after Black's move.
194 char col, row, token;
197 std::istringstream fen(fenStr);
200 fen >> std::noskipws;
202 // 1. Piece placement
203 while ((fen >> token) && !isspace(token))
206 sq += Square(token - '0'); // Advance the given number of files
208 else if (token == '/')
211 else if ((p = PieceToChar.find(token)) != string::npos)
213 put_piece(Piece(p), sq);
220 sideToMove = (token == 'w' ? WHITE : BLACK);
223 // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
224 // Shredder-FEN that uses the letters of the columns on which the rooks began
225 // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
226 // if an inner rook is associated with the castling right, the castling tag is
227 // replaced by the file letter of the involved rook, as for the Shredder-FEN.
228 while ((fen >> token) && !isspace(token))
231 Color c = islower(token) ? BLACK : WHITE;
233 token = char(toupper(token));
236 for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
238 else if (token == 'Q')
239 for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
241 else if (token >= 'A' && token <= 'H')
242 rsq = File(token - 'A') | relative_rank(c, RANK_1);
247 set_castle_right(c, rsq);
250 // 4. En passant square. Ignore if no pawn capture is possible
251 if ( ((fen >> col) && (col >= 'a' && col <= 'h'))
252 && ((fen >> row) && (row == '3' || row == '6')))
254 st->epSquare = File(col - 'a') | Rank(row - '1');
256 if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
257 st->epSquare = SQ_NONE;
260 // 5-6. Halfmove clock and fullmove number
261 fen >> std::skipws >> st->rule50 >> startPosPly;
263 // Convert from fullmove starting from 1 to ply starting from 0,
264 // handle also common incorrect FEN with fullmove = 0.
265 startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
267 st->key = compute_key();
268 st->pawnKey = compute_pawn_key();
269 st->materialKey = compute_material_key();
270 st->psqScore = compute_psq_score();
271 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
272 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
273 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
274 chess960 = isChess960;
281 /// Position::set_castle_right() is an helper function used to set castling
282 /// rights given the corresponding color and the rook starting square.
284 void Position::set_castle_right(Color c, Square rfrom) {
286 Square kfrom = king_square(c);
287 CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
288 CastleRight cr = make_castle_right(c, cs);
290 st->castleRights |= cr;
291 castleRightsMask[kfrom] |= cr;
292 castleRightsMask[rfrom] |= cr;
293 castleRookSquare[c][cs] = rfrom;
295 Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
296 Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
298 for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
299 if (s != kfrom && s != rfrom)
300 castlePath[c][cs] |= s;
302 for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
303 if (s != kfrom && s != rfrom)
304 castlePath[c][cs] |= s;
308 /// Position::to_fen() returns a FEN representation of the position. In case
309 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
311 const string Position::to_fen() const {
313 std::ostringstream fen;
317 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
321 for (File file = FILE_A; file <= FILE_H; file++)
334 fen << PieceToChar[piece_on(sq)];
345 fen << (sideToMove == WHITE ? " w " : " b ");
347 if (can_castle(WHITE_OO))
348 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K');
350 if (can_castle(WHITE_OOO))
351 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q');
353 if (can_castle(BLACK_OO))
354 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k');
356 if (can_castle(BLACK_OOO))
357 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q');
359 if (st->castleRights == CASTLES_NONE)
362 fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
363 << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2;
369 /// Position::print() prints an ASCII representation of the position to
370 /// the standard output. If a move is given then also the san is printed.
372 void Position::print(Move move) const {
374 const string dottedLine = "\n+---+---+---+---+---+---+---+---+";
375 const string twoRows = dottedLine + "\n| | . | | . | | . | | . |"
376 + dottedLine + "\n| . | | . | | . | | . | |";
378 string brd = twoRows + twoRows + twoRows + twoRows + dottedLine;
383 cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
386 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
387 if (piece_on(sq) != NO_PIECE)
388 brd[513 - 68*rank_of(sq) + 4*file_of(sq)] = PieceToChar[piece_on(sq)];
390 cout << brd << "\nFen is: " << to_fen() << "\nKey is: " << st->key << endl;
394 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
395 /// king) pieces for the given color. Or, when template parameter FindPinned is
396 /// false, the function return the pieces of the given color candidate for a
397 /// discovery check against the enemy king.
398 template<bool FindPinned>
399 Bitboard Position::hidden_checkers() const {
401 // Pinned pieces protect our king, dicovery checks attack the enemy king
402 Bitboard b, result = 0;
403 Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
404 Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
406 // Pinners are sliders, that give check when candidate pinned is removed
407 pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
408 | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
412 b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
414 if (b && !more_than_one(b) && (b & pieces(sideToMove)))
420 // Explicit template instantiations
421 template Bitboard Position::hidden_checkers<true>() const;
422 template Bitboard Position::hidden_checkers<false>() const;
425 /// Position::attackers_to() computes a bitboard of all pieces which attack a
426 /// given square. Slider attacks use occ bitboard as occupancy.
428 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
430 return (attacks_from<PAWN>(s, BLACK) & pieces(WHITE, PAWN))
431 | (attacks_from<PAWN>(s, WHITE) & pieces(BLACK, PAWN))
432 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
433 | (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN))
434 | (attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN))
435 | (attacks_from<KING>(s) & pieces(KING));
439 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
440 /// put in a given square. Slider attacks use occ bitboard as occupancy.
442 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
448 case BISHOP: return attacks_bb<BISHOP>(s, occ);
449 case ROOK : return attacks_bb<ROOK>(s, occ);
450 case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
451 default : return StepAttacksBB[p][s];
456 /// Position::move_attacks_square() tests whether a move from the current
457 /// position attacks a given square.
459 bool Position::move_attacks_square(Move m, Square s) const {
465 Square from = from_sq(m);
466 Square to = to_sq(m);
467 Piece piece = piece_moved(m);
469 assert(!is_empty(from));
471 // Update occupancy as if the piece is moving
472 occ = pieces() ^ from ^ to;
474 // The piece moved in 'to' attacks the square 's' ?
475 if (attacks_from(piece, to, occ) & s)
478 // Scan for possible X-ray attackers behind the moved piece
479 xray = (attacks_bb< ROOK>(s, occ) & pieces(color_of(piece), QUEEN, ROOK))
480 | (attacks_bb<BISHOP>(s, occ) & pieces(color_of(piece), QUEEN, BISHOP));
482 // Verify attackers are triggered by our move and not already existing
483 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
487 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
489 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
492 assert(pinned == pinned_pieces());
494 Color us = sideToMove;
495 Square from = from_sq(m);
497 assert(color_of(piece_moved(m)) == us);
498 assert(piece_on(king_square(us)) == make_piece(us, KING));
500 // En passant captures are a tricky special case. Because they are rather
501 // uncommon, we do it simply by testing whether the king is attacked after
503 if (type_of(m) == ENPASSANT)
506 Square to = to_sq(m);
507 Square capsq = to + pawn_push(them);
508 Square ksq = king_square(us);
509 Bitboard b = (pieces() ^ from ^ capsq) | to;
511 assert(to == ep_square());
512 assert(piece_moved(m) == make_piece(us, PAWN));
513 assert(piece_on(capsq) == make_piece(them, PAWN));
514 assert(piece_on(to) == NO_PIECE);
516 return !(attacks_bb< ROOK>(ksq, b) & pieces(them, QUEEN, ROOK))
517 && !(attacks_bb<BISHOP>(ksq, b) & pieces(them, QUEEN, BISHOP));
520 // If the moving piece is a king, check whether the destination
521 // square is attacked by the opponent. Castling moves are checked
522 // for legality during move generation.
523 if (type_of(piece_on(from)) == KING)
524 return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us));
526 // A non-king move is legal if and only if it is not pinned or it
527 // is moving along the ray towards or away from the king.
530 || squares_aligned(from, to_sq(m), king_square(us));
534 /// Position::move_is_legal() takes a random move and tests whether the move
535 /// is legal. This version is not very fast and should be used only in non
536 /// time-critical paths.
538 bool Position::move_is_legal(const Move m) const {
540 for (MoveList<LEGAL> ml(*this); !ml.end(); ++ml)
548 /// Position::is_pseudo_legal() takes a random move and tests whether the move
549 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
550 /// due to SMP concurrent access or hash position key aliasing.
552 bool Position::is_pseudo_legal(const Move m) const {
554 Color us = sideToMove;
555 Color them = ~sideToMove;
556 Square from = from_sq(m);
557 Square to = to_sq(m);
558 Piece pc = piece_moved(m);
560 // Use a slower but simpler function for uncommon cases
561 if (type_of(m) != NORMAL)
562 return move_is_legal(m);
564 // Is not a promotion, so promotion piece must be empty
565 if (promotion_type(m) - 2 != NO_PIECE_TYPE)
568 // If the from square is not occupied by a piece belonging to the side to
569 // move, the move is obviously not legal.
570 if (pc == NO_PIECE || color_of(pc) != us)
573 // The destination square cannot be occupied by a friendly piece
574 if (color_of(piece_on(to)) == us)
577 // Handle the special case of a pawn move
578 if (type_of(pc) == PAWN)
580 // Move direction must be compatible with pawn color
581 int direction = to - from;
582 if ((us == WHITE) != (direction > 0))
585 // We have already handled promotion moves, so destination
586 // cannot be on the 8/1th rank.
587 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
590 // Proceed according to the square delta between the origin and
591 // destination squares.
598 // Capture. The destination square must be occupied by an enemy
599 // piece (en passant captures was handled earlier).
600 if (color_of(piece_on(to)) != them)
603 // From and to files must be one file apart, avoids a7h5
604 if (abs(file_of(from) - file_of(to)) != 1)
610 // Pawn push. The destination square must be empty.
616 // Double white pawn push. The destination square must be on the fourth
617 // rank, and both the destination square and the square between the
618 // source and destination squares must be empty.
619 if ( rank_of(to) != RANK_4
621 || !is_empty(from + DELTA_N))
626 // Double black pawn push. The destination square must be on the fifth
627 // rank, and both the destination square and the square between the
628 // source and destination squares must be empty.
629 if ( rank_of(to) != RANK_5
631 || !is_empty(from + DELTA_S))
639 else if (!(attacks_from(pc, from) & to))
642 // Evasions generator already takes care to avoid some kind of illegal moves
643 // and pl_move_is_legal() relies on this. So we have to take care that the
644 // same kind of moves are filtered out here.
647 if (type_of(pc) != KING)
649 Bitboard b = checkers();
650 Square checksq = pop_lsb(&b);
652 if (b) // double check ? In this case a king move is required
655 // Our move must be a blocking evasion or a capture of the checking piece
656 if (!((between_bb(checksq, king_square(us)) | checkers()) & to))
659 // In case of king moves under check we have to remove king so to catch
660 // as invalid moves like b1a1 when opposite queen is on c1.
661 else if (attackers_to(to, pieces() ^ from) & pieces(~us))
669 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
671 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
674 assert(ci.dcCandidates == discovered_check_candidates());
675 assert(color_of(piece_moved(m)) == sideToMove);
677 Square from = from_sq(m);
678 Square to = to_sq(m);
679 PieceType pt = type_of(piece_on(from));
682 if (ci.checkSq[pt] & to)
686 if (ci.dcCandidates && (ci.dcCandidates & from))
688 // For pawn and king moves we need to verify also direction
689 if ( (pt != PAWN && pt != KING)
690 || !squares_aligned(from, to, king_square(~sideToMove)))
694 // Can we skip the ugly special cases ?
695 if (type_of(m) == NORMAL)
698 Color us = sideToMove;
699 Square ksq = king_square(~us);
701 // Promotion with check ?
702 if (type_of(m) == PROMOTION)
703 return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
705 // En passant capture with check ? We have already handled the case
706 // of direct checks and ordinary discovered check, the only case we
707 // need to handle is the unusual case of a discovered check through
708 // the captured pawn.
709 if (type_of(m) == ENPASSANT)
711 Square capsq = file_of(to) | rank_of(from);
712 Bitboard b = (pieces() ^ from ^ capsq) | to;
714 return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
715 | (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
718 // Castling with check ?
719 if (type_of(m) == CASTLE)
722 Square rfrom = to; // 'King captures the rook' notation
723 Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
724 Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
725 Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
727 return attacks_bb<ROOK>(rto, b) & ksq;
734 /// Position::do_move() makes a move, and saves all information necessary
735 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
736 /// moves should be filtered out before this function is called.
738 void Position::do_move(Move m, StateInfo& newSt) {
741 do_move(m, newSt, ci, move_gives_check(m, ci));
744 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
747 assert(&newSt != st);
752 // Copy some fields of old state to our new StateInfo object except the ones
753 // which are recalculated from scratch anyway, then switch our state pointer
754 // to point to the new, ready to be updated, state.
755 memcpy(&newSt, st, sizeof(ReducedStateInfo));
760 // Update side to move
763 // Increment the 50 moves rule draw counter. Resetting it to zero in the
764 // case of a capture or a pawn move is taken care of later.
768 if (type_of(m) == CASTLE)
771 do_castle_move<true>(m);
775 Color us = sideToMove;
777 Square from = from_sq(m);
778 Square to = to_sq(m);
779 Piece piece = piece_on(from);
780 PieceType pt = type_of(piece);
781 PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
783 assert(color_of(piece) == us);
784 assert(color_of(piece_on(to)) != us);
785 assert(capture != KING);
791 // If the captured piece is a pawn, update pawn hash key, otherwise
792 // update non-pawn material.
795 if (type_of(m) == ENPASSANT)
797 capsq += pawn_push(them);
800 assert(to == st->epSquare);
801 assert(relative_rank(us, to) == RANK_6);
802 assert(piece_on(to) == NO_PIECE);
803 assert(piece_on(capsq) == make_piece(them, PAWN));
805 board[capsq] = NO_PIECE;
808 st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
811 st->npMaterial[them] -= PieceValueMidgame[capture];
813 // Remove the captured piece
814 byTypeBB[ALL_PIECES] ^= capsq;
815 byTypeBB[capture] ^= capsq;
816 byColorBB[them] ^= capsq;
818 // Update piece list, move the last piece at index[capsq] position and
821 // WARNING: This is a not revresible operation. When we will reinsert the
822 // captured piece in undo_move() we will put it at the end of the list and
823 // not in its original place, it means index[] and pieceList[] are not
824 // guaranteed to be invariant to a do_move() + undo_move() sequence.
825 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
826 index[lastSquare] = index[capsq];
827 pieceList[them][capture][index[lastSquare]] = lastSquare;
828 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
831 k ^= Zobrist::psq[them][capture][capsq];
832 st->materialKey ^= Zobrist::psq[them][capture][pieceCount[them][capture]];
834 // Update incremental scores
835 st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq];
837 // Reset rule 50 counter
842 k ^= Zobrist::psq[us][pt][from] ^ Zobrist::psq[us][pt][to];
844 // Reset en passant square
845 if (st->epSquare != SQ_NONE)
847 k ^= Zobrist::enpassant[file_of(st->epSquare)];
848 st->epSquare = SQ_NONE;
851 // Update castle rights if needed
852 if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
854 int cr = castleRightsMask[from] | castleRightsMask[to];
855 k ^= Zobrist::castle[st->castleRights & cr];
856 st->castleRights &= ~cr;
859 // Prefetch TT access as soon as we know key is updated
860 prefetch((char*)TT.first_entry(k));
863 Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
864 byTypeBB[ALL_PIECES] ^= from_to_bb;
865 byTypeBB[pt] ^= from_to_bb;
866 byColorBB[us] ^= from_to_bb;
868 board[to] = board[from];
869 board[from] = NO_PIECE;
871 // Update piece lists, index[from] is not updated and becomes stale. This
872 // works as long as index[] is accessed just by known occupied squares.
873 index[to] = index[from];
874 pieceList[us][pt][index[to]] = to;
876 // If the moving piece is a pawn do some special extra work
879 // Set en-passant square, only if moved pawn can be captured
880 if ( (int(to) ^ int(from)) == 16
881 && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
883 st->epSquare = Square((from + to) / 2);
884 k ^= Zobrist::enpassant[file_of(st->epSquare)];
887 if (type_of(m) == PROMOTION)
889 PieceType promotion = promotion_type(m);
891 assert(relative_rank(us, to) == RANK_8);
892 assert(promotion >= KNIGHT && promotion <= QUEEN);
894 // Replace the pawn with the promoted piece
895 byTypeBB[PAWN] ^= to;
896 byTypeBB[promotion] |= to;
897 board[to] = make_piece(us, promotion);
899 // Update piece lists, move the last pawn at index[to] position
900 // and shrink the list. Add a new promotion piece to the list.
901 Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
902 index[lastSquare] = index[to];
903 pieceList[us][PAWN][index[lastSquare]] = lastSquare;
904 pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
905 index[to] = pieceCount[us][promotion];
906 pieceList[us][promotion][index[to]] = to;
909 k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to];
910 st->pawnKey ^= Zobrist::psq[us][PAWN][to];
911 st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]++]
912 ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
914 // Update incremental score
915 st->psqScore += pieceSquareTable[make_piece(us, promotion)][to]
916 - pieceSquareTable[make_piece(us, PAWN)][to];
919 st->npMaterial[us] += PieceValueMidgame[promotion];
922 // Update pawn hash key
923 st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to];
925 // Reset rule 50 draw counter
929 // Prefetch pawn and material hash tables
930 prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]);
931 prefetch((char*)thisThread->materialTable.entries[st->materialKey]);
933 // Update incremental scores
934 st->psqScore += psq_delta(piece, from, to);
937 st->capturedType = capture;
939 // Update the key with the final value
942 // Update checkers bitboard, piece must be already moved
947 if (type_of(m) != NORMAL)
948 st->checkersBB = attackers_to(king_square(them)) & pieces(us);
952 if (ci.checkSq[pt] & to)
953 st->checkersBB |= to;
956 if (ci.dcCandidates && (ci.dcCandidates & from))
959 st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(us, QUEEN, ROOK);
962 st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(us, QUEEN, BISHOP);
967 sideToMove = ~sideToMove;
973 /// Position::undo_move() unmakes a move. When it returns, the position should
974 /// be restored to exactly the same state as before the move was made.
976 void Position::undo_move(Move m) {
980 sideToMove = ~sideToMove;
982 if (type_of(m) == CASTLE)
984 do_castle_move<false>(m);
988 Color us = sideToMove;
990 Square from = from_sq(m);
991 Square to = to_sq(m);
992 Piece piece = piece_on(to);
993 PieceType pt = type_of(piece);
994 PieceType capture = st->capturedType;
996 assert(is_empty(from));
997 assert(color_of(piece) == us);
998 assert(capture != KING);
1000 if (type_of(m) == PROMOTION)
1002 PieceType promotion = promotion_type(m);
1004 assert(promotion == pt);
1005 assert(relative_rank(us, to) == RANK_8);
1006 assert(promotion >= KNIGHT && promotion <= QUEEN);
1008 // Replace the promoted piece with the pawn
1009 byTypeBB[promotion] ^= to;
1010 byTypeBB[PAWN] |= to;
1011 board[to] = make_piece(us, PAWN);
1013 // Update piece lists, move the last promoted piece at index[to] position
1014 // and shrink the list. Add a new pawn to the list.
1015 Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
1016 index[lastSquare] = index[to];
1017 pieceList[us][promotion][index[lastSquare]] = lastSquare;
1018 pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
1019 index[to] = pieceCount[us][PAWN]++;
1020 pieceList[us][PAWN][index[to]] = to;
1025 // Put the piece back at the source square
1026 Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
1027 byTypeBB[ALL_PIECES] ^= from_to_bb;
1028 byTypeBB[pt] ^= from_to_bb;
1029 byColorBB[us] ^= from_to_bb;
1031 board[from] = board[to];
1032 board[to] = NO_PIECE;
1034 // Update piece lists, index[to] is not updated and becomes stale. This
1035 // works as long as index[] is accessed just by known occupied squares.
1036 index[from] = index[to];
1037 pieceList[us][pt][index[from]] = from;
1043 if (type_of(m) == ENPASSANT)
1045 capsq -= pawn_push(us);
1048 assert(to == st->previous->epSquare);
1049 assert(relative_rank(us, to) == RANK_6);
1050 assert(piece_on(capsq) == NO_PIECE);
1053 // Restore the captured piece
1054 byTypeBB[ALL_PIECES] |= capsq;
1055 byTypeBB[capture] |= capsq;
1056 byColorBB[them] |= capsq;
1058 board[capsq] = make_piece(them, capture);
1060 // Update piece list, add a new captured piece in capsq square
1061 index[capsq] = pieceCount[them][capture]++;
1062 pieceList[them][capture][index[capsq]] = capsq;
1065 // Finally point our state pointer back to the previous state
1068 assert(pos_is_ok());
1072 /// Position::do_castle_move() is a private method used to do/undo a castling
1073 /// move. Note that castling moves are encoded as "king captures friendly rook"
1074 /// moves, for instance white short castling in a non-Chess960 game is encoded
1077 void Position::do_castle_move(Move m) {
1080 assert(type_of(m) == CASTLE);
1082 Square kto, kfrom, rfrom, rto, kAfter, rAfter;
1084 Color us = sideToMove;
1085 Square kBefore = from_sq(m);
1086 Square rBefore = to_sq(m);
1088 // Find after-castle squares for king and rook
1089 if (rBefore > kBefore) // O-O
1091 kAfter = relative_square(us, SQ_G1);
1092 rAfter = relative_square(us, SQ_F1);
1096 kAfter = relative_square(us, SQ_C1);
1097 rAfter = relative_square(us, SQ_D1);
1100 kfrom = Do ? kBefore : kAfter;
1101 rfrom = Do ? rBefore : rAfter;
1103 kto = Do ? kAfter : kBefore;
1104 rto = Do ? rAfter : rBefore;
1106 assert(piece_on(kfrom) == make_piece(us, KING));
1107 assert(piece_on(rfrom) == make_piece(us, ROOK));
1109 // Move the pieces, with some care; in chess960 could be kto == rfrom
1110 Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto];
1111 Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto];
1112 byTypeBB[KING] ^= k_from_to_bb;
1113 byTypeBB[ROOK] ^= r_from_to_bb;
1114 byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb;
1115 byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb;
1118 Piece king = make_piece(us, KING);
1119 Piece rook = make_piece(us, ROOK);
1120 board[kfrom] = board[rfrom] = NO_PIECE;
1124 // Update piece lists
1125 pieceList[us][KING][index[kfrom]] = kto;
1126 pieceList[us][ROOK][index[rfrom]] = rto;
1127 int tmp = index[rfrom]; // In Chess960 could be kto == rfrom
1128 index[kto] = index[kfrom];
1133 // Reset capture field
1134 st->capturedType = NO_PIECE_TYPE;
1136 // Update incremental scores
1137 st->psqScore += psq_delta(king, kfrom, kto);
1138 st->psqScore += psq_delta(rook, rfrom, rto);
1141 st->key ^= Zobrist::psq[us][KING][kfrom] ^ Zobrist::psq[us][KING][kto];
1142 st->key ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
1144 // Clear en passant square
1145 if (st->epSquare != SQ_NONE)
1147 st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
1148 st->epSquare = SQ_NONE;
1151 // Update castling rights
1152 st->key ^= Zobrist::castle[st->castleRights & castleRightsMask[kfrom]];
1153 st->castleRights &= ~castleRightsMask[kfrom];
1155 // Update checkers BB
1156 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1158 sideToMove = ~sideToMove;
1161 // Undo: point our state pointer back to the previous state
1164 assert(pos_is_ok());
1168 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1169 /// to move and updates the hash key without executing any move on the board.
1171 void Position::do_null_move(StateInfo& backupSt) {
1173 assert(!in_check());
1175 // Back up the information necessary to undo the null move to the supplied
1176 // StateInfo object. Note that differently from normal case here backupSt
1177 // is actually used as a backup storage not as the new state. This reduces
1178 // the number of fields to be copied.
1179 StateInfo* src = Do ? st : &backupSt;
1180 StateInfo* dst = Do ? &backupSt : st;
1182 dst->key = src->key;
1183 dst->epSquare = src->epSquare;
1184 dst->psqScore = src->psqScore;
1185 dst->rule50 = src->rule50;
1186 dst->pliesFromNull = src->pliesFromNull;
1188 sideToMove = ~sideToMove;
1192 if (st->epSquare != SQ_NONE)
1193 st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
1195 st->key ^= Zobrist::side;
1196 prefetch((char*)TT.first_entry(st->key));
1198 st->epSquare = SQ_NONE;
1200 st->pliesFromNull = 0;
1203 assert(pos_is_ok());
1206 // Explicit template instantiations
1207 template void Position::do_null_move<false>(StateInfo& backupSt);
1208 template void Position::do_null_move<true>(StateInfo& backupSt);
1211 /// Position::see() is a static exchange evaluator: It tries to estimate the
1212 /// material gain or loss resulting from a move. There are three versions of
1213 /// this function: One which takes a destination square as input, one takes a
1214 /// move, and one which takes a 'from' and a 'to' square. The function does
1215 /// not yet understand promotions captures.
1217 int Position::see_sign(Move m) const {
1221 // Early return if SEE cannot be negative because captured piece value
1222 // is not less then capturing one. Note that king moves always return
1223 // here because king midgame value is set to 0.
1224 if (PieceValueMidgame[piece_on(to_sq(m))] >= PieceValueMidgame[piece_moved(m)])
1230 int Position::see(Move m) const {
1233 Bitboard occ, attackers, stmAttackers, b;
1234 int swapList[32], slIndex = 1;
1235 PieceType capturedType, pt;
1240 // As castle moves are implemented as capturing the rook, they have
1241 // SEE == RookValueMidgame most of the times (unless the rook is under
1243 if (type_of(m) == CASTLE)
1248 capturedType = type_of(piece_on(to));
1251 // Handle en passant moves
1252 if (type_of(m) == ENPASSANT)
1254 Square capQq = to - pawn_push(sideToMove);
1256 assert(!capturedType);
1257 assert(type_of(piece_on(capQq)) == PAWN);
1259 // Remove the captured pawn
1261 capturedType = PAWN;
1264 // Find all attackers to the destination square, with the moving piece
1265 // removed, but possibly an X-ray attacker added behind it.
1267 attackers = attackers_to(to, occ);
1269 // If the opponent has no attackers we are finished
1270 stm = ~color_of(piece_on(from));
1271 stmAttackers = attackers & pieces(stm);
1273 return PieceValueMidgame[capturedType];
1275 // The destination square is defended, which makes things rather more
1276 // difficult to compute. We proceed by building up a "swap list" containing
1277 // the material gain or loss at each stop in a sequence of captures to the
1278 // destination square, where the sides alternately capture, and always
1279 // capture with the least valuable piece. After each capture, we look for
1280 // new X-ray attacks from behind the capturing piece.
1281 swapList[0] = PieceValueMidgame[capturedType];
1282 capturedType = type_of(piece_on(from));
1285 // Locate the least valuable attacker for the side to move. The loop
1286 // below looks like it is potentially infinite, but it isn't. We know
1287 // that the side to move still has at least one attacker left.
1288 for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
1291 // Remove the attacker we just found from the 'occupied' bitboard,
1292 // and scan for new X-ray attacks behind the attacker.
1293 b = stmAttackers & pieces(pt);
1294 occ ^= (b & (~b + 1));
1295 attackers |= (attacks_bb<ROOK>(to, occ) & pieces(ROOK, QUEEN))
1296 | (attacks_bb<BISHOP>(to, occ) & pieces(BISHOP, QUEEN));
1298 attackers &= occ; // Cut out pieces we've already done
1300 // Add the new entry to the swap list
1301 assert(slIndex < 32);
1302 swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
1305 // Remember the value of the capturing piece, and change the side to
1306 // move before beginning the next iteration.
1309 stmAttackers = attackers & pieces(stm);
1311 // Stop before processing a king capture
1312 if (capturedType == KING && stmAttackers)
1314 assert(slIndex < 32);
1315 swapList[slIndex++] = QueenValueMidgame*10;
1318 } while (stmAttackers);
1320 // Having built the swap list, we negamax through it to find the best
1321 // achievable score from the point of view of the side to move.
1323 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1329 /// Position::clear() erases the position object to a pristine state, with an
1330 /// empty board, white to move, and no castling rights.
1332 void Position::clear() {
1334 memset(this, 0, sizeof(Position));
1335 startState.epSquare = SQ_NONE;
1338 for (int i = 0; i < 8; i++)
1339 for (int j = 0; j < 16; j++)
1340 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1342 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1343 board[sq] = NO_PIECE;
1347 /// Position::put_piece() puts a piece on the given square of the board,
1348 /// updating the board array, pieces list, bitboards, and piece counts.
1350 void Position::put_piece(Piece p, Square s) {
1352 Color c = color_of(p);
1353 PieceType pt = type_of(p);
1356 index[s] = pieceCount[c][pt]++;
1357 pieceList[c][pt][index[s]] = s;
1359 byTypeBB[ALL_PIECES] |= s;
1365 /// Position::compute_key() computes the hash key of the position. The hash
1366 /// key is usually updated incrementally as moves are made and unmade, the
1367 /// compute_key() function is only used when a new position is set up, and
1368 /// to verify the correctness of the hash key when running in debug mode.
1370 Key Position::compute_key() const {
1372 Key k = Zobrist::castle[st->castleRights];
1374 for (Bitboard b = pieces(); b; )
1376 Square s = pop_lsb(&b);
1377 k ^= Zobrist::psq[color_of(piece_on(s))][type_of(piece_on(s))][s];
1380 if (ep_square() != SQ_NONE)
1381 k ^= Zobrist::enpassant[file_of(ep_square())];
1383 if (sideToMove == BLACK)
1390 /// Position::compute_pawn_key() computes the hash key of the position. The
1391 /// hash key is usually updated incrementally as moves are made and unmade,
1392 /// the compute_pawn_key() function is only used when a new position is set
1393 /// up, and to verify the correctness of the pawn hash key when running in
1396 Key Position::compute_pawn_key() const {
1400 for (Bitboard b = pieces(PAWN); b; )
1402 Square s = pop_lsb(&b);
1403 k ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s];
1410 /// Position::compute_material_key() computes the hash key of the position.
1411 /// The hash key is usually updated incrementally as moves are made and unmade,
1412 /// the compute_material_key() function is only used when a new position is set
1413 /// up, and to verify the correctness of the material hash key when running in
1416 Key Position::compute_material_key() const {
1420 for (Color c = WHITE; c <= BLACK; c++)
1421 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1422 for (int cnt = 0; cnt < piece_count(c, pt); cnt++)
1423 k ^= Zobrist::psq[c][pt][cnt];
1429 /// Position::compute_psq_score() computes the incremental scores for the middle
1430 /// game and the endgame. These functions are used to initialize the incremental
1431 /// scores when a new position is set up, and to verify that the scores are correctly
1432 /// updated by do_move and undo_move when the program is running in debug mode.
1433 Score Position::compute_psq_score() const {
1435 Score score = SCORE_ZERO;
1437 for (Bitboard b = pieces(); b; )
1439 Square s = pop_lsb(&b);
1440 score += pieceSquareTable[piece_on(s)][s];
1447 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1448 /// game material value for the given side. Material values are updated
1449 /// incrementally during the search, this function is only used while
1450 /// initializing a new Position object.
1452 Value Position::compute_non_pawn_material(Color c) const {
1454 Value value = VALUE_ZERO;
1456 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1457 value += piece_count(c, pt) * PieceValueMidgame[pt];
1463 /// Position::is_draw() tests whether the position is drawn by material,
1464 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1465 /// must be done by the search.
1466 template<bool SkipRepetition>
1467 bool Position::is_draw() const {
1469 // Draw by material?
1471 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMidgame))
1474 // Draw by the 50 moves rule?
1475 if (st->rule50 > 99 && (!in_check() || MoveList<LEGAL>(*this).size()))
1478 // Draw by repetition?
1479 if (!SkipRepetition)
1481 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1485 StateInfo* stp = st->previous->previous;
1488 stp = stp->previous->previous;
1490 if (stp->key == st->key)
1502 // Explicit template instantiations
1503 template bool Position::is_draw<false>() const;
1504 template bool Position::is_draw<true>() const;
1507 /// Position::flip() flips position with the white and black sides reversed. This
1508 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1510 void Position::flip() {
1512 const Position pos(*this);
1516 sideToMove = ~pos.side_to_move();
1517 thisThread = pos.this_thread();
1518 nodes = pos.nodes_searched();
1519 chess960 = pos.is_chess960();
1520 startPosPly = pos.startpos_ply_counter();
1522 for (Square s = SQ_A1; s <= SQ_H8; s++)
1523 if (!pos.is_empty(s))
1524 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1526 if (pos.can_castle(WHITE_OO))
1527 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
1528 if (pos.can_castle(WHITE_OOO))
1529 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
1530 if (pos.can_castle(BLACK_OO))
1531 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
1532 if (pos.can_castle(BLACK_OOO))
1533 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
1535 if (pos.st->epSquare != SQ_NONE)
1536 st->epSquare = ~pos.st->epSquare;
1538 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1540 st->key = compute_key();
1541 st->pawnKey = compute_pawn_key();
1542 st->materialKey = compute_material_key();
1543 st->psqScore = compute_psq_score();
1544 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1545 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1547 assert(pos_is_ok());
1551 /// Position::pos_is_ok() performs some consitency checks for the position object.
1552 /// This is meant to be helpful when debugging.
1554 bool Position::pos_is_ok(int* failedStep) const {
1556 int dummy, *step = failedStep ? failedStep : &dummy;
1558 // What features of the position should be verified?
1559 const bool all = false;
1561 const bool debugBitboards = all || false;
1562 const bool debugKingCount = all || false;
1563 const bool debugKingCapture = all || false;
1564 const bool debugCheckerCount = all || false;
1565 const bool debugKey = all || false;
1566 const bool debugMaterialKey = all || false;
1567 const bool debugPawnKey = all || false;
1568 const bool debugIncrementalEval = all || false;
1569 const bool debugNonPawnMaterial = all || false;
1570 const bool debugPieceCounts = all || false;
1571 const bool debugPieceList = all || false;
1572 const bool debugCastleSquares = all || false;
1576 if (sideToMove != WHITE && sideToMove != BLACK)
1579 if ((*step)++, piece_on(king_square(WHITE)) != W_KING)
1582 if ((*step)++, piece_on(king_square(BLACK)) != B_KING)
1585 if ((*step)++, debugKingCount)
1587 int kingCount[2] = {};
1589 for (Square s = SQ_A1; s <= SQ_H8; s++)
1590 if (type_of(piece_on(s)) == KING)
1591 kingCount[color_of(piece_on(s))]++;
1593 if (kingCount[0] != 1 || kingCount[1] != 1)
1597 if ((*step)++, debugKingCapture)
1598 if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove))
1601 if ((*step)++, debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1604 if ((*step)++, debugBitboards)
1606 // The intersection of the white and black pieces must be empty
1607 if (pieces(WHITE) & pieces(BLACK))
1610 // The union of the white and black pieces must be equal to all
1612 if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1615 // Separate piece type bitboards must have empty intersections
1616 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1617 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1618 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1622 if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)
1625 if ((*step)++, debugKey && st->key != compute_key())
1628 if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key())
1631 if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())
1634 if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score())
1637 if ((*step)++, debugNonPawnMaterial)
1639 if ( st->npMaterial[WHITE] != compute_non_pawn_material(WHITE)
1640 || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1644 if ((*step)++, debugPieceCounts)
1645 for (Color c = WHITE; c <= BLACK; c++)
1646 for (PieceType pt = PAWN; pt <= KING; pt++)
1647 if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
1650 if ((*step)++, debugPieceList)
1651 for (Color c = WHITE; c <= BLACK; c++)
1652 for (PieceType pt = PAWN; pt <= KING; pt++)
1653 for (int i = 0; i < pieceCount[c][pt]; i++)
1655 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1658 if (index[piece_list(c, pt)[i]] != i)
1662 if ((*step)++, debugCastleSquares)
1663 for (Color c = WHITE; c <= BLACK; c++)
1664 for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
1666 CastleRight cr = make_castle_right(c, s);
1668 if (!can_castle(cr))
1671 if ((castleRightsMask[king_square(c)] & cr) != cr)
1674 if ( piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
1675 || castleRightsMask[castleRookSquare[c][s]] != cr)