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/>.
38 Key Position::zobrist[2][8][64];
39 Key Position::zobEp[8];
40 Key Position::zobCastle[16];
41 Key Position::zobSideToMove;
42 Key Position::zobExclusion;
44 Score Position::pieceSquareTable[16][64];
46 // Material values arrays, indexed by Piece
47 const Value PieceValueMidgame[17] = {
49 PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
50 RookValueMidgame, QueenValueMidgame,
51 VALUE_ZERO, VALUE_ZERO, VALUE_ZERO,
52 PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
53 RookValueMidgame, QueenValueMidgame
56 const Value PieceValueEndgame[17] = {
58 PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
59 RookValueEndgame, QueenValueEndgame,
60 VALUE_ZERO, VALUE_ZERO, VALUE_ZERO,
61 PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
62 RookValueEndgame, QueenValueEndgame
65 // To convert a Piece to and from a FEN char
66 static const string PieceToChar(" PNBRQK pnbrqk");
71 CheckInfo::CheckInfo(const Position& pos) {
73 Color them = ~pos.side_to_move();
74 ksq = pos.king_square(them);
76 pinned = pos.pinned_pieces();
77 dcCandidates = pos.discovered_check_candidates();
79 checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
80 checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
81 checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
82 checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
83 checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
88 /// Position::operator=() creates a copy of 'pos'. We want the new born Position
89 /// object do not depend on any external data so we detach state pointer from
92 Position& Position::operator=(const Position& pos) {
94 memcpy(this, &pos, sizeof(Position));
105 /// Position::from_fen() initializes the position object with the given FEN
106 /// string. This function is not very robust - make sure that input FENs are
107 /// correct (this is assumed to be the responsibility of the GUI).
109 void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) {
111 A FEN string defines a particular position using only the ASCII character set.
113 A FEN string contains six fields separated by a space. The fields are:
115 1) Piece placement (from white's perspective). Each rank is described, starting
116 with rank 8 and ending with rank 1; within each rank, the contents of each
117 square are described from file A through file H. Following the Standard
118 Algebraic Notation (SAN), each piece is identified by a single letter taken
119 from the standard English names. White pieces are designated using upper-case
120 letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
121 noted using digits 1 through 8 (the number of blank squares), and "/"
124 2) Active color. "w" means white moves next, "b" means black.
126 3) Castling availability. If neither side can castle, this is "-". Otherwise,
127 this has one or more letters: "K" (White can castle kingside), "Q" (White
128 can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
129 can castle queenside).
131 4) En passant target square (in algebraic notation). If there's no en passant
132 target square, this is "-". If a pawn has just made a 2-square move, this
133 is the position "behind" the pawn. This is recorded regardless of whether
134 there is a pawn in position to make an en passant capture.
136 5) Halfmove clock. This is the number of halfmoves since the last pawn advance
137 or capture. This is used to determine if a draw can be claimed under the
140 6) Fullmove number. The number of the full move. It starts at 1, and is
141 incremented after Black's move.
144 char col, row, token;
147 std::istringstream fen(fenStr);
150 fen >> std::noskipws;
152 // 1. Piece placement
153 while ((fen >> token) && !isspace(token))
156 sq += Square(token - '0'); // Advance the given number of files
158 else if (token == '/')
161 else if ((p = PieceToChar.find(token)) != string::npos)
163 put_piece(Piece(p), sq);
170 sideToMove = (token == 'w' ? WHITE : BLACK);
173 // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
174 // Shredder-FEN that uses the letters of the columns on which the rooks began
175 // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
176 // if an inner rook is associated with the castling right, the castling tag is
177 // replaced by the file letter of the involved rook, as for the Shredder-FEN.
178 while ((fen >> token) && !isspace(token))
181 Color c = islower(token) ? BLACK : WHITE;
183 token = char(toupper(token));
186 for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
188 else if (token == 'Q')
189 for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
191 else if (token >= 'A' && token <= 'H')
192 rsq = File(token - 'A') | relative_rank(c, RANK_1);
197 set_castle_right(c, rsq);
200 // 4. En passant square. Ignore if no pawn capture is possible
201 if ( ((fen >> col) && (col >= 'a' && col <= 'h'))
202 && ((fen >> row) && (row == '3' || row == '6')))
204 st->epSquare = File(col - 'a') | Rank(row - '1');
206 if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
207 st->epSquare = SQ_NONE;
210 // 5-6. Halfmove clock and fullmove number
211 fen >> std::skipws >> st->rule50 >> startPosPly;
213 // Convert from fullmove starting from 1 to ply starting from 0,
214 // handle also common incorrect FEN with fullmove = 0.
215 startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
217 st->key = compute_key();
218 st->pawnKey = compute_pawn_key();
219 st->materialKey = compute_material_key();
220 st->psqScore = compute_psq_score();
221 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
222 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
223 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
224 chess960 = isChess960;
231 /// Position::set_castle_right() is an helper function used to set castling
232 /// rights given the corresponding color and the rook starting square.
234 void Position::set_castle_right(Color c, Square rfrom) {
236 Square kfrom = king_square(c);
237 CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
238 CastleRight cr = make_castle_right(c, cs);
240 st->castleRights |= cr;
241 castleRightsMask[kfrom] |= cr;
242 castleRightsMask[rfrom] |= cr;
243 castleRookSquare[c][cs] = rfrom;
245 Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
246 Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
248 for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
249 if (s != kfrom && s != rfrom)
250 castlePath[c][cs] |= s;
252 for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
253 if (s != kfrom && s != rfrom)
254 castlePath[c][cs] |= s;
258 /// Position::to_fen() returns a FEN representation of the position. In case
259 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
261 const string Position::to_fen() const {
263 std::ostringstream fen;
267 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
271 for (File file = FILE_A; file <= FILE_H; file++)
284 fen << PieceToChar[piece_on(sq)];
295 fen << (sideToMove == WHITE ? " w " : " b ");
297 if (can_castle(WHITE_OO))
298 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K');
300 if (can_castle(WHITE_OOO))
301 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q');
303 if (can_castle(BLACK_OO))
304 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k');
306 if (can_castle(BLACK_OOO))
307 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q');
309 if (st->castleRights == CASTLES_NONE)
312 fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
313 << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2;
319 /// Position::print() prints an ASCII representation of the position to
320 /// the standard output. If a move is given then also the san is printed.
322 void Position::print(Move move) const {
324 const string dottedLine = "\n+---+---+---+---+---+---+---+---+";
325 const string twoRows = dottedLine + "\n| | . | | . | | . | | . |"
326 + dottedLine + "\n| . | | . | | . | | . | |";
328 string brd = twoRows + twoRows + twoRows + twoRows + dottedLine;
333 cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
336 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
337 if (piece_on(sq) != NO_PIECE)
338 brd[513 - 68*rank_of(sq) + 4*file_of(sq)] = PieceToChar[piece_on(sq)];
340 cout << brd << "\nFen is: " << to_fen() << "\nKey is: " << st->key << endl;
344 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
345 /// king) pieces for the given color. Or, when template parameter FindPinned is
346 /// false, the function return the pieces of the given color candidate for a
347 /// discovery check against the enemy king.
348 template<bool FindPinned>
349 Bitboard Position::hidden_checkers() const {
351 // Pinned pieces protect our king, dicovery checks attack the enemy king
352 Bitboard b, result = 0;
353 Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
354 Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
356 // Pinners are sliders, that give check when candidate pinned is removed
357 pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
358 | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
362 b = between_bb(ksq, pop_1st_bit(&pinners)) & pieces();
364 if (b && !more_than_one(b) && (b & pieces(sideToMove)))
370 // Explicit template instantiations
371 template Bitboard Position::hidden_checkers<true>() const;
372 template Bitboard Position::hidden_checkers<false>() const;
375 /// Position::attackers_to() computes a bitboard of all pieces which attack a
376 /// given square. Slider attacks use occ bitboard as occupancy.
378 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
380 return (attacks_from<PAWN>(s, BLACK) & pieces(WHITE, PAWN))
381 | (attacks_from<PAWN>(s, WHITE) & pieces(BLACK, PAWN))
382 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
383 | (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN))
384 | (attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN))
385 | (attacks_from<KING>(s) & pieces(KING));
389 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
390 /// put in a given square. Slider attacks use occ bitboard as occupancy.
392 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
398 case BISHOP: return attacks_bb<BISHOP>(s, occ);
399 case ROOK : return attacks_bb<ROOK>(s, occ);
400 case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
401 default : return StepAttacksBB[p][s];
406 /// Position::move_attacks_square() tests whether a move from the current
407 /// position attacks a given square.
409 bool Position::move_attacks_square(Move m, Square s) const {
415 Square from = from_sq(m);
416 Square to = to_sq(m);
417 Piece piece = piece_moved(m);
419 assert(!is_empty(from));
421 // Update occupancy as if the piece is moving
422 occ = pieces() ^ from ^ to;
424 // The piece moved in 'to' attacks the square 's' ?
425 if (attacks_from(piece, to, occ) & s)
428 // Scan for possible X-ray attackers behind the moved piece
429 xray = (attacks_bb< ROOK>(s, occ) & pieces(color_of(piece), QUEEN, ROOK))
430 | (attacks_bb<BISHOP>(s, occ) & pieces(color_of(piece), QUEEN, BISHOP));
432 // Verify attackers are triggered by our move and not already existing
433 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
437 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
439 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
442 assert(pinned == pinned_pieces());
444 Color us = sideToMove;
445 Square from = from_sq(m);
447 assert(color_of(piece_moved(m)) == us);
448 assert(piece_on(king_square(us)) == make_piece(us, KING));
450 // En passant captures are a tricky special case. Because they are rather
451 // uncommon, we do it simply by testing whether the king is attacked after
453 if (type_of(m) == ENPASSANT)
456 Square to = to_sq(m);
457 Square capsq = to + pawn_push(them);
458 Square ksq = king_square(us);
459 Bitboard b = (pieces() ^ from ^ capsq) | to;
461 assert(to == ep_square());
462 assert(piece_moved(m) == make_piece(us, PAWN));
463 assert(piece_on(capsq) == make_piece(them, PAWN));
464 assert(piece_on(to) == NO_PIECE);
466 return !(attacks_bb< ROOK>(ksq, b) & pieces(them, QUEEN, ROOK))
467 && !(attacks_bb<BISHOP>(ksq, b) & pieces(them, QUEEN, BISHOP));
470 // If the moving piece is a king, check whether the destination
471 // square is attacked by the opponent. Castling moves are checked
472 // for legality during move generation.
473 if (type_of(piece_on(from)) == KING)
474 return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us));
476 // A non-king move is legal if and only if it is not pinned or it
477 // is moving along the ray towards or away from the king.
480 || squares_aligned(from, to_sq(m), king_square(us));
484 /// Position::move_is_legal() takes a random move and tests whether the move
485 /// is legal. This version is not very fast and should be used only in non
486 /// time-critical paths.
488 bool Position::move_is_legal(const Move m) const {
490 for (MoveList<LEGAL> ml(*this); !ml.end(); ++ml)
498 /// Position::is_pseudo_legal() takes a random move and tests whether the move
499 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
500 /// due to SMP concurrent access or hash position key aliasing.
502 bool Position::is_pseudo_legal(const Move m) const {
504 Color us = sideToMove;
505 Color them = ~sideToMove;
506 Square from = from_sq(m);
507 Square to = to_sq(m);
508 Piece pc = piece_moved(m);
510 // Use a slower but simpler function for uncommon cases
511 if (type_of(m) != NORMAL)
512 return move_is_legal(m);
514 // Is not a promotion, so promotion piece must be empty
515 if (promotion_type(m) - 2 != NO_PIECE_TYPE)
518 // If the from square is not occupied by a piece belonging to the side to
519 // move, the move is obviously not legal.
520 if (pc == NO_PIECE || color_of(pc) != us)
523 // The destination square cannot be occupied by a friendly piece
524 if (color_of(piece_on(to)) == us)
527 // Handle the special case of a pawn move
528 if (type_of(pc) == PAWN)
530 // Move direction must be compatible with pawn color
531 int direction = to - from;
532 if ((us == WHITE) != (direction > 0))
535 // We have already handled promotion moves, so destination
536 // cannot be on the 8/1th rank.
537 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
540 // Proceed according to the square delta between the origin and
541 // destination squares.
548 // Capture. The destination square must be occupied by an enemy
549 // piece (en passant captures was handled earlier).
550 if (color_of(piece_on(to)) != them)
553 // From and to files must be one file apart, avoids a7h5
554 if (abs(file_of(from) - file_of(to)) != 1)
560 // Pawn push. The destination square must be empty.
566 // Double white pawn push. The destination square must be on the fourth
567 // rank, and both the destination square and the square between the
568 // source and destination squares must be empty.
569 if ( rank_of(to) != RANK_4
571 || !is_empty(from + DELTA_N))
576 // Double black pawn push. The destination square must be on the fifth
577 // rank, and both the destination square and the square between the
578 // source and destination squares must be empty.
579 if ( rank_of(to) != RANK_5
581 || !is_empty(from + DELTA_S))
589 else if (!(attacks_from(pc, from) & to))
592 // Evasions generator already takes care to avoid some kind of illegal moves
593 // and pl_move_is_legal() relies on this. So we have to take care that the
594 // same kind of moves are filtered out here.
597 if (type_of(pc) != KING)
599 Bitboard b = checkers();
600 Square checksq = pop_1st_bit(&b);
602 if (b) // double check ? In this case a king move is required
605 // Our move must be a blocking evasion or a capture of the checking piece
606 if (!((between_bb(checksq, king_square(us)) | checkers()) & to))
609 // In case of king moves under check we have to remove king so to catch
610 // as invalid moves like b1a1 when opposite queen is on c1.
611 else if (attackers_to(to, pieces() ^ from) & pieces(~us))
619 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
621 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
624 assert(ci.dcCandidates == discovered_check_candidates());
625 assert(color_of(piece_moved(m)) == sideToMove);
627 Square from = from_sq(m);
628 Square to = to_sq(m);
629 PieceType pt = type_of(piece_on(from));
632 if (ci.checkSq[pt] & to)
636 if (ci.dcCandidates && (ci.dcCandidates & from))
638 // For pawn and king moves we need to verify also direction
639 if ( (pt != PAWN && pt != KING)
640 || !squares_aligned(from, to, king_square(~sideToMove)))
644 // Can we skip the ugly special cases ?
645 if (type_of(m) == NORMAL)
648 Color us = sideToMove;
649 Square ksq = king_square(~us);
651 // Promotion with check ?
652 if (type_of(m) == PROMOTION)
653 return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
655 // En passant capture with check ? We have already handled the case
656 // of direct checks and ordinary discovered check, the only case we
657 // need to handle is the unusual case of a discovered check through
658 // the captured pawn.
659 if (type_of(m) == ENPASSANT)
661 Square capsq = file_of(to) | rank_of(from);
662 Bitboard b = (pieces() ^ from ^ capsq) | to;
664 return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
665 | (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
668 // Castling with check ?
669 if (type_of(m) == CASTLE)
672 Square rfrom = to; // 'King captures the rook' notation
673 Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
674 Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
675 Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
677 return attacks_bb<ROOK>(rto, b) & ksq;
684 /// Position::do_move() makes a move, and saves all information necessary
685 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
686 /// moves should be filtered out before this function is called.
688 void Position::do_move(Move m, StateInfo& newSt) {
691 do_move(m, newSt, ci, move_gives_check(m, ci));
694 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
697 assert(&newSt != st);
702 // Copy some fields of old state to our new StateInfo object except the ones
703 // which are recalculated from scratch anyway, then switch our state pointer
704 // to point to the new, ready to be updated, state.
705 memcpy(&newSt, st, sizeof(ReducedStateInfo));
710 // Update side to move
713 // Increment the 50 moves rule draw counter. Resetting it to zero in the
714 // case of a capture or a pawn move is taken care of later.
718 if (type_of(m) == CASTLE)
721 do_castle_move<true>(m);
725 Color us = sideToMove;
727 Square from = from_sq(m);
728 Square to = to_sq(m);
729 Piece piece = piece_on(from);
730 PieceType pt = type_of(piece);
731 PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
733 assert(color_of(piece) == us);
734 assert(color_of(piece_on(to)) != us);
735 assert(capture != KING);
741 // If the captured piece is a pawn, update pawn hash key, otherwise
742 // update non-pawn material.
745 if (type_of(m) == ENPASSANT)
747 capsq += pawn_push(them);
750 assert(to == st->epSquare);
751 assert(relative_rank(us, to) == RANK_6);
752 assert(piece_on(to) == NO_PIECE);
753 assert(piece_on(capsq) == make_piece(them, PAWN));
755 board[capsq] = NO_PIECE;
758 st->pawnKey ^= zobrist[them][PAWN][capsq];
761 st->npMaterial[them] -= PieceValueMidgame[capture];
763 // Remove the captured piece
764 byTypeBB[ALL_PIECES] ^= capsq;
765 byTypeBB[capture] ^= capsq;
766 byColorBB[them] ^= capsq;
768 // Update piece list, move the last piece at index[capsq] position and
771 // WARNING: This is a not revresible operation. When we will reinsert the
772 // captured piece in undo_move() we will put it at the end of the list and
773 // not in its original place, it means index[] and pieceList[] are not
774 // guaranteed to be invariant to a do_move() + undo_move() sequence.
775 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
776 index[lastSquare] = index[capsq];
777 pieceList[them][capture][index[lastSquare]] = lastSquare;
778 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
781 k ^= zobrist[them][capture][capsq];
782 st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
784 // Update incremental scores
785 st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq];
787 // Reset rule 50 counter
792 k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
794 // Reset en passant square
795 if (st->epSquare != SQ_NONE)
797 k ^= zobEp[file_of(st->epSquare)];
798 st->epSquare = SQ_NONE;
801 // Update castle rights if needed
802 if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
804 int cr = castleRightsMask[from] | castleRightsMask[to];
805 k ^= zobCastle[st->castleRights & cr];
806 st->castleRights &= ~cr;
809 // Prefetch TT access as soon as we know key is updated
810 prefetch((char*)TT.first_entry(k));
813 Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
814 byTypeBB[ALL_PIECES] ^= from_to_bb;
815 byTypeBB[pt] ^= from_to_bb;
816 byColorBB[us] ^= from_to_bb;
818 board[to] = board[from];
819 board[from] = NO_PIECE;
821 // Update piece lists, index[from] is not updated and becomes stale. This
822 // works as long as index[] is accessed just by known occupied squares.
823 index[to] = index[from];
824 pieceList[us][pt][index[to]] = to;
826 // If the moving piece is a pawn do some special extra work
829 // Set en-passant square, only if moved pawn can be captured
830 if ( (int(to) ^ int(from)) == 16
831 && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
833 st->epSquare = Square((from + to) / 2);
834 k ^= zobEp[file_of(st->epSquare)];
837 if (type_of(m) == PROMOTION)
839 PieceType promotion = promotion_type(m);
841 assert(relative_rank(us, to) == RANK_8);
842 assert(promotion >= KNIGHT && promotion <= QUEEN);
844 // Replace the pawn with the promoted piece
845 byTypeBB[PAWN] ^= to;
846 byTypeBB[promotion] |= to;
847 board[to] = make_piece(us, promotion);
849 // Update piece lists, move the last pawn at index[to] position
850 // and shrink the list. Add a new promotion piece to the list.
851 Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
852 index[lastSquare] = index[to];
853 pieceList[us][PAWN][index[lastSquare]] = lastSquare;
854 pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
855 index[to] = pieceCount[us][promotion];
856 pieceList[us][promotion][index[to]] = to;
859 k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
860 st->pawnKey ^= zobrist[us][PAWN][to];
861 st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]++]
862 ^ zobrist[us][PAWN][pieceCount[us][PAWN]];
864 // Update incremental score
865 st->psqScore += pieceSquareTable[make_piece(us, promotion)][to]
866 - pieceSquareTable[make_piece(us, PAWN)][to];
869 st->npMaterial[us] += PieceValueMidgame[promotion];
872 // Update pawn hash key
873 st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
875 // Reset rule 50 draw counter
879 // Prefetch pawn and material hash tables
880 prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]);
881 prefetch((char*)thisThread->materialTable.entries[st->materialKey]);
883 // Update incremental scores
884 st->psqScore += psq_delta(piece, from, to);
887 st->capturedType = capture;
889 // Update the key with the final value
892 // Update checkers bitboard, piece must be already moved
897 if (type_of(m) != NORMAL)
898 st->checkersBB = attackers_to(king_square(them)) & pieces(us);
902 if (ci.checkSq[pt] & to)
903 st->checkersBB |= to;
906 if (ci.dcCandidates && (ci.dcCandidates & from))
909 st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(us, QUEEN, ROOK);
912 st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(us, QUEEN, BISHOP);
917 sideToMove = ~sideToMove;
923 /// Position::undo_move() unmakes a move. When it returns, the position should
924 /// be restored to exactly the same state as before the move was made.
926 void Position::undo_move(Move m) {
930 sideToMove = ~sideToMove;
932 if (type_of(m) == CASTLE)
934 do_castle_move<false>(m);
938 Color us = sideToMove;
940 Square from = from_sq(m);
941 Square to = to_sq(m);
942 Piece piece = piece_on(to);
943 PieceType pt = type_of(piece);
944 PieceType capture = st->capturedType;
946 assert(is_empty(from));
947 assert(color_of(piece) == us);
948 assert(capture != KING);
950 if (type_of(m) == PROMOTION)
952 PieceType promotion = promotion_type(m);
954 assert(promotion == pt);
955 assert(relative_rank(us, to) == RANK_8);
956 assert(promotion >= KNIGHT && promotion <= QUEEN);
958 // Replace the promoted piece with the pawn
959 byTypeBB[promotion] ^= to;
960 byTypeBB[PAWN] |= to;
961 board[to] = make_piece(us, PAWN);
963 // Update piece lists, move the last promoted piece at index[to] position
964 // and shrink the list. Add a new pawn to the list.
965 Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
966 index[lastSquare] = index[to];
967 pieceList[us][promotion][index[lastSquare]] = lastSquare;
968 pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
969 index[to] = pieceCount[us][PAWN]++;
970 pieceList[us][PAWN][index[to]] = to;
975 // Put the piece back at the source square
976 Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
977 byTypeBB[ALL_PIECES] ^= from_to_bb;
978 byTypeBB[pt] ^= from_to_bb;
979 byColorBB[us] ^= from_to_bb;
981 board[from] = board[to];
982 board[to] = NO_PIECE;
984 // Update piece lists, index[to] is not updated and becomes stale. This
985 // works as long as index[] is accessed just by known occupied squares.
986 index[from] = index[to];
987 pieceList[us][pt][index[from]] = from;
993 if (type_of(m) == ENPASSANT)
995 capsq -= pawn_push(us);
998 assert(to == st->previous->epSquare);
999 assert(relative_rank(us, to) == RANK_6);
1000 assert(piece_on(capsq) == NO_PIECE);
1003 // Restore the captured piece
1004 byTypeBB[ALL_PIECES] |= capsq;
1005 byTypeBB[capture] |= capsq;
1006 byColorBB[them] |= capsq;
1008 board[capsq] = make_piece(them, capture);
1010 // Update piece list, add a new captured piece in capsq square
1011 index[capsq] = pieceCount[them][capture]++;
1012 pieceList[them][capture][index[capsq]] = capsq;
1015 // Finally point our state pointer back to the previous state
1018 assert(pos_is_ok());
1022 /// Position::do_castle_move() is a private method used to do/undo a castling
1023 /// move. Note that castling moves are encoded as "king captures friendly rook"
1024 /// moves, for instance white short castling in a non-Chess960 game is encoded
1027 void Position::do_castle_move(Move m) {
1030 assert(type_of(m) == CASTLE);
1032 Square kto, kfrom, rfrom, rto, kAfter, rAfter;
1034 Color us = sideToMove;
1035 Square kBefore = from_sq(m);
1036 Square rBefore = to_sq(m);
1038 // Find after-castle squares for king and rook
1039 if (rBefore > kBefore) // O-O
1041 kAfter = relative_square(us, SQ_G1);
1042 rAfter = relative_square(us, SQ_F1);
1046 kAfter = relative_square(us, SQ_C1);
1047 rAfter = relative_square(us, SQ_D1);
1050 kfrom = Do ? kBefore : kAfter;
1051 rfrom = Do ? rBefore : rAfter;
1053 kto = Do ? kAfter : kBefore;
1054 rto = Do ? rAfter : rBefore;
1056 assert(piece_on(kfrom) == make_piece(us, KING));
1057 assert(piece_on(rfrom) == make_piece(us, ROOK));
1059 // Move the pieces, with some care; in chess960 could be kto == rfrom
1060 Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto];
1061 Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto];
1062 byTypeBB[KING] ^= k_from_to_bb;
1063 byTypeBB[ROOK] ^= r_from_to_bb;
1064 byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb;
1065 byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb;
1068 Piece king = make_piece(us, KING);
1069 Piece rook = make_piece(us, ROOK);
1070 board[kfrom] = board[rfrom] = NO_PIECE;
1074 // Update piece lists
1075 pieceList[us][KING][index[kfrom]] = kto;
1076 pieceList[us][ROOK][index[rfrom]] = rto;
1077 int tmp = index[rfrom]; // In Chess960 could be kto == rfrom
1078 index[kto] = index[kfrom];
1083 // Reset capture field
1084 st->capturedType = NO_PIECE_TYPE;
1086 // Update incremental scores
1087 st->psqScore += psq_delta(king, kfrom, kto);
1088 st->psqScore += psq_delta(rook, rfrom, rto);
1091 st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
1092 st->key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto];
1094 // Clear en passant square
1095 if (st->epSquare != SQ_NONE)
1097 st->key ^= zobEp[file_of(st->epSquare)];
1098 st->epSquare = SQ_NONE;
1101 // Update castling rights
1102 st->key ^= zobCastle[st->castleRights & castleRightsMask[kfrom]];
1103 st->castleRights &= ~castleRightsMask[kfrom];
1105 // Update checkers BB
1106 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1108 sideToMove = ~sideToMove;
1111 // Undo: point our state pointer back to the previous state
1114 assert(pos_is_ok());
1118 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1119 /// to move and updates the hash key without executing any move on the board.
1121 void Position::do_null_move(StateInfo& backupSt) {
1123 assert(!in_check());
1125 // Back up the information necessary to undo the null move to the supplied
1126 // StateInfo object. Note that differently from normal case here backupSt
1127 // is actually used as a backup storage not as the new state. This reduces
1128 // the number of fields to be copied.
1129 StateInfo* src = Do ? st : &backupSt;
1130 StateInfo* dst = Do ? &backupSt : st;
1132 dst->key = src->key;
1133 dst->epSquare = src->epSquare;
1134 dst->psqScore = src->psqScore;
1135 dst->rule50 = src->rule50;
1136 dst->pliesFromNull = src->pliesFromNull;
1138 sideToMove = ~sideToMove;
1142 if (st->epSquare != SQ_NONE)
1143 st->key ^= zobEp[file_of(st->epSquare)];
1145 st->key ^= zobSideToMove;
1146 prefetch((char*)TT.first_entry(st->key));
1148 st->epSquare = SQ_NONE;
1150 st->pliesFromNull = 0;
1153 assert(pos_is_ok());
1156 // Explicit template instantiations
1157 template void Position::do_null_move<false>(StateInfo& backupSt);
1158 template void Position::do_null_move<true>(StateInfo& backupSt);
1161 /// Position::see() is a static exchange evaluator: It tries to estimate the
1162 /// material gain or loss resulting from a move. There are three versions of
1163 /// this function: One which takes a destination square as input, one takes a
1164 /// move, and one which takes a 'from' and a 'to' square. The function does
1165 /// not yet understand promotions captures.
1167 int Position::see_sign(Move m) const {
1171 // Early return if SEE cannot be negative because captured piece value
1172 // is not less then capturing one. Note that king moves always return
1173 // here because king midgame value is set to 0.
1174 if (PieceValueMidgame[piece_on(to_sq(m))] >= PieceValueMidgame[piece_moved(m)])
1180 int Position::see(Move m) const {
1183 Bitboard occ, attackers, stmAttackers, b;
1184 int swapList[32], slIndex = 1;
1185 PieceType capturedType, pt;
1190 // As castle moves are implemented as capturing the rook, they have
1191 // SEE == RookValueMidgame most of the times (unless the rook is under
1193 if (type_of(m) == CASTLE)
1198 capturedType = type_of(piece_on(to));
1201 // Handle en passant moves
1202 if (type_of(m) == ENPASSANT)
1204 Square capQq = to - pawn_push(sideToMove);
1206 assert(!capturedType);
1207 assert(type_of(piece_on(capQq)) == PAWN);
1209 // Remove the captured pawn
1211 capturedType = PAWN;
1214 // Find all attackers to the destination square, with the moving piece
1215 // removed, but possibly an X-ray attacker added behind it.
1217 attackers = attackers_to(to, occ);
1219 // If the opponent has no attackers we are finished
1220 stm = ~color_of(piece_on(from));
1221 stmAttackers = attackers & pieces(stm);
1223 return PieceValueMidgame[capturedType];
1225 // The destination square is defended, which makes things rather more
1226 // difficult to compute. We proceed by building up a "swap list" containing
1227 // the material gain or loss at each stop in a sequence of captures to the
1228 // destination square, where the sides alternately capture, and always
1229 // capture with the least valuable piece. After each capture, we look for
1230 // new X-ray attacks from behind the capturing piece.
1231 swapList[0] = PieceValueMidgame[capturedType];
1232 capturedType = type_of(piece_on(from));
1235 // Locate the least valuable attacker for the side to move. The loop
1236 // below looks like it is potentially infinite, but it isn't. We know
1237 // that the side to move still has at least one attacker left.
1238 for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
1241 // Remove the attacker we just found from the 'occupied' bitboard,
1242 // and scan for new X-ray attacks behind the attacker.
1243 b = stmAttackers & pieces(pt);
1244 occ ^= (b & (~b + 1));
1245 attackers |= (attacks_bb<ROOK>(to, occ) & pieces(ROOK, QUEEN))
1246 | (attacks_bb<BISHOP>(to, occ) & pieces(BISHOP, QUEEN));
1248 attackers &= occ; // Cut out pieces we've already done
1250 // Add the new entry to the swap list
1251 assert(slIndex < 32);
1252 swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
1255 // Remember the value of the capturing piece, and change the side to
1256 // move before beginning the next iteration.
1259 stmAttackers = attackers & pieces(stm);
1261 // Stop before processing a king capture
1262 if (capturedType == KING && stmAttackers)
1264 assert(slIndex < 32);
1265 swapList[slIndex++] = QueenValueMidgame*10;
1268 } while (stmAttackers);
1270 // Having built the swap list, we negamax through it to find the best
1271 // achievable score from the point of view of the side to move.
1273 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1279 /// Position::clear() erases the position object to a pristine state, with an
1280 /// empty board, white to move, and no castling rights.
1282 void Position::clear() {
1284 memset(this, 0, sizeof(Position));
1285 startState.epSquare = SQ_NONE;
1288 for (int i = 0; i < 8; i++)
1289 for (int j = 0; j < 16; j++)
1290 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1292 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1293 board[sq] = NO_PIECE;
1297 /// Position::put_piece() puts a piece on the given square of the board,
1298 /// updating the board array, pieces list, bitboards, and piece counts.
1300 void Position::put_piece(Piece p, Square s) {
1302 Color c = color_of(p);
1303 PieceType pt = type_of(p);
1306 index[s] = pieceCount[c][pt]++;
1307 pieceList[c][pt][index[s]] = s;
1309 byTypeBB[ALL_PIECES] |= s;
1315 /// Position::compute_key() computes the hash key of the position. The hash
1316 /// key is usually updated incrementally as moves are made and unmade, the
1317 /// compute_key() function is only used when a new position is set up, and
1318 /// to verify the correctness of the hash key when running in debug mode.
1320 Key Position::compute_key() const {
1322 Key k = zobCastle[st->castleRights];
1324 for (Bitboard b = pieces(); b; )
1326 Square s = pop_1st_bit(&b);
1327 k ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
1330 if (ep_square() != SQ_NONE)
1331 k ^= zobEp[file_of(ep_square())];
1333 if (sideToMove == BLACK)
1340 /// Position::compute_pawn_key() computes the hash key of the position. The
1341 /// hash key is usually updated incrementally as moves are made and unmade,
1342 /// the compute_pawn_key() function is only used when a new position is set
1343 /// up, and to verify the correctness of the pawn hash key when running in
1346 Key Position::compute_pawn_key() const {
1350 for (Bitboard b = pieces(PAWN); b; )
1352 Square s = pop_1st_bit(&b);
1353 k ^= zobrist[color_of(piece_on(s))][PAWN][s];
1360 /// Position::compute_material_key() computes the hash key of the position.
1361 /// The hash key is usually updated incrementally as moves are made and unmade,
1362 /// the compute_material_key() function is only used when a new position is set
1363 /// up, and to verify the correctness of the material hash key when running in
1366 Key Position::compute_material_key() const {
1370 for (Color c = WHITE; c <= BLACK; c++)
1371 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1372 for (int cnt = 0; cnt < piece_count(c, pt); cnt++)
1373 k ^= zobrist[c][pt][cnt];
1379 /// Position::compute_psq_score() computes the incremental scores for the middle
1380 /// game and the endgame. These functions are used to initialize the incremental
1381 /// scores when a new position is set up, and to verify that the scores are correctly
1382 /// updated by do_move and undo_move when the program is running in debug mode.
1383 Score Position::compute_psq_score() const {
1385 Score score = SCORE_ZERO;
1387 for (Bitboard b = pieces(); b; )
1389 Square s = pop_1st_bit(&b);
1390 score += pieceSquareTable[piece_on(s)][s];
1397 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1398 /// game material value for the given side. Material values are updated
1399 /// incrementally during the search, this function is only used while
1400 /// initializing a new Position object.
1402 Value Position::compute_non_pawn_material(Color c) const {
1404 Value value = VALUE_ZERO;
1406 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1407 value += piece_count(c, pt) * PieceValueMidgame[pt];
1413 /// Position::is_draw() tests whether the position is drawn by material,
1414 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1415 /// must be done by the search.
1416 template<bool SkipRepetition>
1417 bool Position::is_draw() const {
1419 // Draw by material?
1421 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMidgame))
1424 // Draw by the 50 moves rule?
1425 if (st->rule50 > 99 && (!in_check() || MoveList<LEGAL>(*this).size()))
1428 // Draw by repetition?
1429 if (!SkipRepetition)
1431 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1435 StateInfo* stp = st->previous->previous;
1438 stp = stp->previous->previous;
1440 if (stp->key == st->key)
1452 // Explicit template instantiations
1453 template bool Position::is_draw<false>() const;
1454 template bool Position::is_draw<true>() const;
1457 /// Position::init() is a static member function which initializes at startup
1458 /// the various arrays used to compute hash keys and the piece square tables.
1459 /// The latter is a two-step operation: First, the white halves of the tables
1460 /// are copied from PSQT[] tables. Second, the black halves of the tables are
1461 /// initialized by flipping and changing the sign of the white scores.
1463 void Position::init() {
1467 for (Color c = WHITE; c <= BLACK; c++)
1468 for (PieceType pt = PAWN; pt <= KING; pt++)
1469 for (Square s = SQ_A1; s <= SQ_H8; s++)
1470 zobrist[c][pt][s] = rk.rand<Key>();
1472 for (File f = FILE_A; f <= FILE_H; f++)
1473 zobEp[f] = rk.rand<Key>();
1475 for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
1480 Key k = zobCastle[1ULL << pop_1st_bit(&b)];
1481 zobCastle[cr] ^= k ? k : rk.rand<Key>();
1485 zobSideToMove = rk.rand<Key>();
1486 zobExclusion = rk.rand<Key>();
1488 for (PieceType pt = PAWN; pt <= KING; pt++)
1490 Score v = make_score(PieceValueMidgame[pt], PieceValueEndgame[pt]);
1492 for (Square s = SQ_A1; s <= SQ_H8; s++)
1494 pieceSquareTable[make_piece(WHITE, pt)][ s] = (v + PSQT[pt][s]);
1495 pieceSquareTable[make_piece(BLACK, pt)][~s] = -(v + PSQT[pt][s]);
1501 /// Position::flip() flips position with the white and black sides reversed. This
1502 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1504 void Position::flip() {
1506 const Position pos(*this);
1510 sideToMove = ~pos.side_to_move();
1511 thisThread = pos.this_thread();
1512 nodes = pos.nodes_searched();
1513 chess960 = pos.is_chess960();
1514 startPosPly = pos.startpos_ply_counter();
1516 for (Square s = SQ_A1; s <= SQ_H8; s++)
1517 if (!pos.is_empty(s))
1518 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1520 if (pos.can_castle(WHITE_OO))
1521 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
1522 if (pos.can_castle(WHITE_OOO))
1523 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
1524 if (pos.can_castle(BLACK_OO))
1525 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
1526 if (pos.can_castle(BLACK_OOO))
1527 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
1529 if (pos.st->epSquare != SQ_NONE)
1530 st->epSquare = ~pos.st->epSquare;
1532 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1534 st->key = compute_key();
1535 st->pawnKey = compute_pawn_key();
1536 st->materialKey = compute_material_key();
1537 st->psqScore = compute_psq_score();
1538 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1539 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1541 assert(pos_is_ok());
1545 /// Position::pos_is_ok() performs some consitency checks for the position object.
1546 /// This is meant to be helpful when debugging.
1548 bool Position::pos_is_ok(int* failedStep) const {
1550 int dummy, *step = failedStep ? failedStep : &dummy;
1552 // What features of the position should be verified?
1553 const bool all = false;
1555 const bool debugBitboards = all || false;
1556 const bool debugKingCount = all || false;
1557 const bool debugKingCapture = all || false;
1558 const bool debugCheckerCount = all || false;
1559 const bool debugKey = all || false;
1560 const bool debugMaterialKey = all || false;
1561 const bool debugPawnKey = all || false;
1562 const bool debugIncrementalEval = all || false;
1563 const bool debugNonPawnMaterial = all || false;
1564 const bool debugPieceCounts = all || false;
1565 const bool debugPieceList = all || false;
1566 const bool debugCastleSquares = all || false;
1570 if (sideToMove != WHITE && sideToMove != BLACK)
1573 if ((*step)++, piece_on(king_square(WHITE)) != W_KING)
1576 if ((*step)++, piece_on(king_square(BLACK)) != B_KING)
1579 if ((*step)++, debugKingCount)
1581 int kingCount[2] = {};
1583 for (Square s = SQ_A1; s <= SQ_H8; s++)
1584 if (type_of(piece_on(s)) == KING)
1585 kingCount[color_of(piece_on(s))]++;
1587 if (kingCount[0] != 1 || kingCount[1] != 1)
1591 if ((*step)++, debugKingCapture)
1592 if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove))
1595 if ((*step)++, debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1598 if ((*step)++, debugBitboards)
1600 // The intersection of the white and black pieces must be empty
1601 if (pieces(WHITE) & pieces(BLACK))
1604 // The union of the white and black pieces must be equal to all
1606 if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1609 // Separate piece type bitboards must have empty intersections
1610 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1611 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1612 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1616 if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)
1619 if ((*step)++, debugKey && st->key != compute_key())
1622 if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key())
1625 if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())
1628 if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score())
1631 if ((*step)++, debugNonPawnMaterial)
1633 if ( st->npMaterial[WHITE] != compute_non_pawn_material(WHITE)
1634 || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1638 if ((*step)++, debugPieceCounts)
1639 for (Color c = WHITE; c <= BLACK; c++)
1640 for (PieceType pt = PAWN; pt <= KING; pt++)
1641 if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
1644 if ((*step)++, debugPieceList)
1645 for (Color c = WHITE; c <= BLACK; c++)
1646 for (PieceType pt = PAWN; pt <= KING; pt++)
1647 for (int i = 0; i < pieceCount[c][pt]; i++)
1649 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1652 if (index[piece_list(c, pt)[i]] != i)
1656 if ((*step)++, debugCastleSquares)
1657 for (Color c = WHITE; c <= BLACK; c++)
1658 for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
1660 CastleRight cr = make_castle_right(c, s);
1662 if (!can_castle(cr))
1665 if ((castleRightsMask[king_square(c)] & cr) != cr)
1668 if ( piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
1669 || castleRightsMask[castleRookSquare[c][s]] != cr)