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
68 // Bonus for having the side to move (modified by Joona Kiiski)
69 const Score Tempo = make_score(48, 22);
71 // To convert a Piece to and from a FEN char
72 const string PieceToChar(" PNBRQK pnbrqk .");
78 CheckInfo::CheckInfo(const Position& pos) {
80 Color them = ~pos.side_to_move();
81 ksq = pos.king_square(them);
83 pinned = pos.pinned_pieces();
84 dcCandidates = pos.discovered_check_candidates();
86 checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
87 checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
88 checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
89 checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
90 checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
95 /// Position::operator=() creates a copy of 'pos'. We want the new born Position
96 /// object do not depend on any external data so we detach state pointer from
99 Position& Position::operator=(const Position& pos) {
101 memcpy(this, &pos, sizeof(Position));
109 /// Position::from_fen() initializes the position object with the given FEN
110 /// string. This function is not very robust - make sure that input FENs are
111 /// correct (this is assumed to be the responsibility of the GUI).
113 void Position::from_fen(const string& fenStr, bool isChess960) {
115 A FEN string defines a particular position using only the ASCII character set.
117 A FEN string contains six fields separated by a space. The fields are:
119 1) Piece placement (from white's perspective). Each rank is described, starting
120 with rank 8 and ending with rank 1; within each rank, the contents of each
121 square are described from file A through file H. Following the Standard
122 Algebraic Notation (SAN), each piece is identified by a single letter taken
123 from the standard English names. White pieces are designated using upper-case
124 letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
125 noted using digits 1 through 8 (the number of blank squares), and "/"
128 2) Active color. "w" means white moves next, "b" means black.
130 3) Castling availability. If neither side can castle, this is "-". Otherwise,
131 this has one or more letters: "K" (White can castle kingside), "Q" (White
132 can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
133 can castle queenside).
135 4) En passant target square (in algebraic notation). If there's no en passant
136 target square, this is "-". If a pawn has just made a 2-square move, this
137 is the position "behind" the pawn. This is recorded regardless of whether
138 there is a pawn in position to make an en passant capture.
140 5) Halfmove clock. This is the number of halfmoves since the last pawn advance
141 or capture. This is used to determine if a draw can be claimed under the
144 6) Fullmove number. The number of the full move. It starts at 1, and is
145 incremented after Black's move.
148 char col, row, token;
151 std::istringstream fen(fenStr);
154 fen >> std::noskipws;
156 // 1. Piece placement
157 while ((fen >> token) && !isspace(token))
160 sq += Square(token - '0'); // Advance the given number of files
162 else if (token == '/')
163 sq = make_square(FILE_A, rank_of(sq) - Rank(2));
165 else if ((p = PieceToChar.find(token)) != string::npos)
167 put_piece(Piece(p), sq);
174 sideToMove = (token == 'w' ? WHITE : BLACK);
177 // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
178 // Shredder-FEN that uses the letters of the columns on which the rooks began
179 // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
180 // if an inner rook is associated with the castling right, the castling tag is
181 // replaced by the file letter of the involved rook, as for the Shredder-FEN.
182 while ((fen >> token) && !isspace(token))
185 Color c = islower(token) ? BLACK : WHITE;
187 token = char(toupper(token));
190 for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
192 else if (token == 'Q')
193 for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
195 else if (token >= 'A' && token <= 'H')
196 rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1));
201 set_castle_right(c, rsq);
204 // 4. En passant square. Ignore if no pawn capture is possible
205 if ( ((fen >> col) && (col >= 'a' && col <= 'h'))
206 && ((fen >> row) && (row == '3' || row == '6')))
208 st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
210 if (!(attackers_to(st->epSquare) & pieces(PAWN, sideToMove)))
211 st->epSquare = SQ_NONE;
214 // 5-6. Halfmove clock and fullmove number
215 fen >> std::skipws >> st->rule50 >> startPosPly;
217 // Convert from fullmove starting from 1 to ply starting from 0,
218 // handle also common incorrect FEN with fullmove = 0.
219 startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
221 st->key = compute_key();
222 st->pawnKey = compute_pawn_key();
223 st->materialKey = compute_material_key();
224 st->psqScore = compute_psq_score();
225 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
226 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
227 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
228 chess960 = isChess960;
234 /// Position::set_castle_right() is an helper function used to set castling
235 /// rights given the corresponding color and the rook starting square.
237 void Position::set_castle_right(Color c, Square rfrom) {
239 Square kfrom = king_square(c);
240 bool kingSide = kfrom < rfrom;
241 int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c;
243 st->castleRights |= cr;
244 castleRightsMask[kfrom] |= cr;
245 castleRightsMask[rfrom] |= cr;
246 castleRookSquare[cr] = rfrom;
248 Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1);
249 Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1);
251 for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
252 if (s != kfrom && s != rfrom)
255 for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
256 if (s != kfrom && s != rfrom)
261 /// Position::to_fen() returns a FEN representation of the position. In case
262 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
264 const string Position::to_fen() const {
266 std::ostringstream fen;
270 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
274 for (File file = FILE_A; file <= FILE_H; file++)
276 sq = make_square(file, rank);
278 if (square_empty(sq))
287 fen << PieceToChar[piece_on(sq)];
298 fen << (sideToMove == WHITE ? " w " : " b ");
300 if (can_castle(WHITE_OO))
301 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K');
303 if (can_castle(WHITE_OOO))
304 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q');
306 if (can_castle(BLACK_OO))
307 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k');
309 if (can_castle(BLACK_OOO))
310 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q');
312 if (st->castleRights == CASTLES_NONE)
315 fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
316 << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2;
322 /// Position::print() prints an ASCII representation of the position to
323 /// the standard output. If a move is given then also the san is printed.
325 void Position::print(Move move) const {
327 const char* dottedLine = "\n+---+---+---+---+---+---+---+---+\n";
332 cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
335 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
337 cout << dottedLine << '|';
338 for (File file = FILE_A; file <= FILE_H; file++)
340 Square sq = make_square(file, rank);
341 Piece piece = piece_on(sq);
342 char c = (color_of(piece) == BLACK ? '=' : ' ');
344 if (piece == NO_PIECE && !opposite_colors(sq, SQ_A1))
345 piece++; // Index the dot
347 cout << c << PieceToChar[piece] << c << '|';
350 cout << dottedLine << "Fen is: " << to_fen() << "\nKey is: " << st->key << endl;
354 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
355 /// king) pieces for the given color. Or, when template parameter FindPinned is
356 /// false, the function return the pieces of the given color candidate for a
357 /// discovery check against the enemy king.
358 template<bool FindPinned>
359 Bitboard Position::hidden_checkers() const {
361 // Pinned pieces protect our king, dicovery checks attack the enemy king
362 Bitboard b, result = 0;
363 Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
364 Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
366 // Pinners are sliders, that give check when candidate pinned is removed
367 pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
368 | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
372 b = squares_between(ksq, pop_1st_bit(&pinners)) & pieces();
374 if (b && single_bit(b) && (b & pieces(sideToMove)))
380 // Explicit template instantiations
381 template Bitboard Position::hidden_checkers<true>() const;
382 template Bitboard Position::hidden_checkers<false>() const;
385 /// Position::attackers_to() computes a bitboard of all pieces which attack a
386 /// given square. Slider attacks use occ bitboard as occupancy.
388 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
390 return (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
391 | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
392 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
393 | (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN))
394 | (attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN))
395 | (attacks_from<KING>(s) & pieces(KING));
399 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
400 /// put in a given square. Slider attacks use occ bitboard as occupancy.
402 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
408 case BISHOP: return attacks_bb<BISHOP>(s, occ);
409 case ROOK : return attacks_bb<ROOK>(s, occ);
410 case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
411 default : return StepAttacksBB[p][s];
416 /// Position::move_attacks_square() tests whether a move from the current
417 /// position attacks a given square.
419 bool Position::move_attacks_square(Move m, Square s) const {
425 Square from = from_sq(m);
426 Square to = to_sq(m);
427 Piece piece = piece_moved(m);
429 assert(!square_empty(from));
431 // Update occupancy as if the piece is moving
432 occ = pieces() ^ from ^ to;
434 // The piece moved in 'to' attacks the square 's' ?
435 if (attacks_from(piece, to, occ) & s)
438 // Scan for possible X-ray attackers behind the moved piece
439 xray = (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN, color_of(piece)))
440 |(attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
442 // Verify attackers are triggered by our move and not already existing
443 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
447 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
449 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
452 assert(pinned == pinned_pieces());
454 Color us = sideToMove;
455 Square from = from_sq(m);
457 assert(color_of(piece_moved(m)) == us);
458 assert(piece_on(king_square(us)) == make_piece(us, KING));
460 // En passant captures are a tricky special case. Because they are rather
461 // uncommon, we do it simply by testing whether the king is attacked after
466 Square to = to_sq(m);
467 Square capsq = to + pawn_push(them);
468 Square ksq = king_square(us);
469 Bitboard b = (pieces() ^ from ^ capsq) | to;
471 assert(to == ep_square());
472 assert(piece_moved(m) == make_piece(us, PAWN));
473 assert(piece_on(capsq) == make_piece(them, PAWN));
474 assert(piece_on(to) == NO_PIECE);
476 return !(attacks_bb<ROOK>(ksq, b) & pieces(ROOK, QUEEN, them))
477 && !(attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, them));
480 // If the moving piece is a king, check whether the destination
481 // square is attacked by the opponent. Castling moves are checked
482 // for legality during move generation.
483 if (type_of(piece_on(from)) == KING)
484 return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
486 // A non-king move is legal if and only if it is not pinned or it
487 // is moving along the ray towards or away from the king.
490 || squares_aligned(from, to_sq(m), king_square(us));
494 /// Position::move_is_legal() takes a random move and tests whether the move
495 /// is legal. This version is not very fast and should be used only in non
496 /// time-critical paths.
498 bool Position::move_is_legal(const Move m) const {
500 for (MoveList<MV_LEGAL> ml(*this); !ml.end(); ++ml)
508 /// Position::is_pseudo_legal() takes a random move and tests whether the move
509 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
510 /// due to SMP concurrent access or hash position key aliasing.
512 bool Position::is_pseudo_legal(const Move m) const {
514 Color us = sideToMove;
515 Color them = ~sideToMove;
516 Square from = from_sq(m);
517 Square to = to_sq(m);
518 Piece pc = piece_moved(m);
520 // Use a slower but simpler function for uncommon cases
522 return move_is_legal(m);
524 // Is not a promotion, so promotion piece must be empty
525 if (promotion_type(m) - 2 != NO_PIECE_TYPE)
528 // If the from square is not occupied by a piece belonging to the side to
529 // move, the move is obviously not legal.
530 if (pc == NO_PIECE || color_of(pc) != us)
533 // The destination square cannot be occupied by a friendly piece
534 if (color_of(piece_on(to)) == us)
537 // Handle the special case of a pawn move
538 if (type_of(pc) == PAWN)
540 // Move direction must be compatible with pawn color
541 int direction = to - from;
542 if ((us == WHITE) != (direction > 0))
545 // We have already handled promotion moves, so destination
546 // cannot be on the 8/1th rank.
547 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
550 // Proceed according to the square delta between the origin and
551 // destination squares.
558 // Capture. The destination square must be occupied by an enemy
559 // piece (en passant captures was handled earlier).
560 if (color_of(piece_on(to)) != them)
563 // From and to files must be one file apart, avoids a7h5
564 if (abs(file_of(from) - file_of(to)) != 1)
570 // Pawn push. The destination square must be empty.
571 if (!square_empty(to))
576 // Double white pawn push. The destination square must be on the fourth
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_4
581 || !square_empty(from + DELTA_N))
586 // Double black pawn push. The destination square must be on the fifth
587 // rank, and both the destination square and the square between the
588 // source and destination squares must be empty.
589 if ( rank_of(to) != RANK_5
591 || !square_empty(from + DELTA_S))
599 else if (!(attacks_from(pc, from) & to))
602 // Evasions generator already takes care to avoid some kind of illegal moves
603 // and pl_move_is_legal() relies on this. So we have to take care that the
604 // same kind of moves are filtered out here.
607 if (type_of(pc) != KING)
609 Bitboard b = checkers();
610 Square checksq = pop_1st_bit(&b);
612 if (b) // double check ? In this case a king move is required
615 // Our move must be a blocking evasion or a capture of the checking piece
616 if (!((squares_between(checksq, king_square(us)) | checkers()) & to))
619 // In case of king moves under check we have to remove king so to catch
620 // as invalid moves like b1a1 when opposite queen is on c1.
621 else if (attackers_to(to, pieces() ^ from) & pieces(~us))
629 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
631 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
634 assert(ci.dcCandidates == discovered_check_candidates());
635 assert(color_of(piece_moved(m)) == sideToMove);
637 Square from = from_sq(m);
638 Square to = to_sq(m);
639 PieceType pt = type_of(piece_on(from));
642 if (ci.checkSq[pt] & to)
646 if (ci.dcCandidates && (ci.dcCandidates & from))
648 // For pawn and king moves we need to verify also direction
649 if ( (pt != PAWN && pt != KING)
650 || !squares_aligned(from, to, king_square(~sideToMove)))
654 // Can we skip the ugly special cases ?
658 Color us = sideToMove;
659 Square ksq = king_square(~us);
661 // Promotion with check ?
663 return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
665 // En passant capture with check ? We have already handled the case
666 // of direct checks and ordinary discovered check, the only case we
667 // need to handle is the unusual case of a discovered check through
668 // the captured pawn.
671 Square capsq = make_square(file_of(to), rank_of(from));
672 Bitboard b = (pieces() ^ from ^ capsq) | to;
674 return (attacks_bb< ROOK>(ksq, b) & pieces( ROOK, QUEEN, us))
675 | (attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, us));
678 // Castling with check ?
682 Square rfrom = to; // 'King captures the rook' notation
683 Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
684 Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
685 Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
687 return attacks_bb<ROOK>(rto, b) & ksq;
694 /// Position::do_move() makes a move, and saves all information necessary
695 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
696 /// moves should be filtered out before this function is called.
698 void Position::do_move(Move m, StateInfo& newSt) {
701 do_move(m, newSt, ci, move_gives_check(m, ci));
704 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
707 assert(&newSt != st);
712 // Copy some fields of old state to our new StateInfo object except the ones
713 // which are recalculated from scratch anyway, then switch our state pointer
714 // to point to the new, ready to be updated, state.
715 struct ReducedStateInfo {
716 Key pawnKey, materialKey;
718 int castleRights, rule50, pliesFromNull;
723 memcpy(&newSt, st, sizeof(ReducedStateInfo));
728 // Update side to move
731 // Increment the 50 moves rule draw counter. Resetting it to zero in the
732 // case of a capture or a pawn move is taken care of later.
739 do_castle_move<true>(m);
743 Color us = sideToMove;
745 Square from = from_sq(m);
746 Square to = to_sq(m);
747 Piece piece = piece_on(from);
748 PieceType pt = type_of(piece);
749 PieceType capture = is_enpassant(m) ? PAWN : type_of(piece_on(to));
751 assert(color_of(piece) == us);
752 assert(color_of(piece_on(to)) != us);
753 assert(capture != KING);
759 // If the captured piece is a pawn, update pawn hash key, otherwise
760 // update non-pawn material.
765 capsq += pawn_push(them);
768 assert(to == st->epSquare);
769 assert(relative_rank(us, to) == RANK_6);
770 assert(piece_on(to) == NO_PIECE);
771 assert(piece_on(capsq) == make_piece(them, PAWN));
773 board[capsq] = NO_PIECE;
776 st->pawnKey ^= zobrist[them][PAWN][capsq];
779 st->npMaterial[them] -= PieceValueMidgame[capture];
781 // Remove the captured piece
782 byTypeBB[ALL_PIECES] ^= capsq;
783 byTypeBB[capture] ^= capsq;
784 byColorBB[them] ^= capsq;
786 // Update piece list, move the last piece at index[capsq] position and
789 // WARNING: This is a not revresible operation. When we will reinsert the
790 // captured piece in undo_move() we will put it at the end of the list and
791 // not in its original place, it means index[] and pieceList[] are not
792 // guaranteed to be invariant to a do_move() + undo_move() sequence.
793 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
794 index[lastSquare] = index[capsq];
795 pieceList[them][capture][index[lastSquare]] = lastSquare;
796 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
799 k ^= zobrist[them][capture][capsq];
800 st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
802 // Update incremental scores
803 st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq];
805 // Reset rule 50 counter
810 k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
812 // Reset en passant square
813 if (st->epSquare != SQ_NONE)
815 k ^= zobEp[file_of(st->epSquare)];
816 st->epSquare = SQ_NONE;
819 // Update castle rights if needed
820 if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
822 int cr = castleRightsMask[from] | castleRightsMask[to];
823 k ^= zobCastle[st->castleRights & cr];
824 st->castleRights &= ~cr;
827 // Prefetch TT access as soon as we know key is updated
828 prefetch((char*)TT.first_entry(k));
831 Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
832 byTypeBB[ALL_PIECES] ^= from_to_bb;
833 byTypeBB[pt] ^= from_to_bb;
834 byColorBB[us] ^= from_to_bb;
836 board[to] = board[from];
837 board[from] = NO_PIECE;
839 // Update piece lists, index[from] is not updated and becomes stale. This
840 // works as long as index[] is accessed just by known occupied squares.
841 index[to] = index[from];
842 pieceList[us][pt][index[to]] = to;
844 // If the moving piece is a pawn do some special extra work
847 // Set en-passant square, only if moved pawn can be captured
848 if ( (int(to) ^ int(from)) == 16
849 && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(PAWN, them)))
851 st->epSquare = Square((from + to) / 2);
852 k ^= zobEp[file_of(st->epSquare)];
857 PieceType promotion = promotion_type(m);
859 assert(relative_rank(us, to) == RANK_8);
860 assert(promotion >= KNIGHT && promotion <= QUEEN);
862 // Replace the pawn with the promoted piece
863 byTypeBB[PAWN] ^= to;
864 byTypeBB[promotion] |= to;
865 board[to] = make_piece(us, promotion);
867 // Update piece lists, move the last pawn at index[to] position
868 // and shrink the list. Add a new promotion piece to the list.
869 Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
870 index[lastSquare] = index[to];
871 pieceList[us][PAWN][index[lastSquare]] = lastSquare;
872 pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
873 index[to] = pieceCount[us][promotion];
874 pieceList[us][promotion][index[to]] = to;
877 k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
878 st->pawnKey ^= zobrist[us][PAWN][to];
879 st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]++]
880 ^ zobrist[us][PAWN][pieceCount[us][PAWN]];
882 // Update incremental score
883 st->psqScore += pieceSquareTable[make_piece(us, promotion)][to]
884 - pieceSquareTable[make_piece(us, PAWN)][to];
887 st->npMaterial[us] += PieceValueMidgame[promotion];
890 // Update pawn hash key
891 st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
893 // Reset rule 50 draw counter
897 // Prefetch pawn and material hash tables
898 prefetch((char*)this_thread->pawnTable.entries[st->pawnKey]);
899 prefetch((char*)this_thread->materialTable.entries[st->materialKey]);
901 // Update incremental scores
902 st->psqScore += psq_delta(piece, from, to);
905 st->capturedType = capture;
907 // Update the key with the final value
910 // Update checkers bitboard, piece must be already moved
916 st->checkersBB = attackers_to(king_square(them)) & pieces(us);
920 if (ci.checkSq[pt] & to)
921 st->checkersBB |= to;
924 if (ci.dcCandidates && (ci.dcCandidates & from))
927 st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(ROOK, QUEEN, us);
930 st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(BISHOP, QUEEN, us);
936 sideToMove = ~sideToMove;
937 st->psqScore += (sideToMove == WHITE ? Tempo : -Tempo);
943 /// Position::undo_move() unmakes a move. When it returns, the position should
944 /// be restored to exactly the same state as before the move was made.
946 void Position::undo_move(Move m) {
950 sideToMove = ~sideToMove;
954 do_castle_move<false>(m);
958 Color us = sideToMove;
960 Square from = from_sq(m);
961 Square to = to_sq(m);
962 Piece piece = piece_on(to);
963 PieceType pt = type_of(piece);
964 PieceType capture = st->capturedType;
966 assert(square_empty(from));
967 assert(color_of(piece) == us);
968 assert(capture != KING);
972 PieceType promotion = promotion_type(m);
974 assert(promotion == pt);
975 assert(relative_rank(us, to) == RANK_8);
976 assert(promotion >= KNIGHT && promotion <= QUEEN);
978 // Replace the promoted piece with the pawn
979 byTypeBB[promotion] ^= to;
980 byTypeBB[PAWN] |= to;
981 board[to] = make_piece(us, PAWN);
983 // Update piece lists, move the last promoted piece at index[to] position
984 // and shrink the list. Add a new pawn to the list.
985 Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
986 index[lastSquare] = index[to];
987 pieceList[us][promotion][index[lastSquare]] = lastSquare;
988 pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
989 index[to] = pieceCount[us][PAWN]++;
990 pieceList[us][PAWN][index[to]] = to;
995 // Put the piece back at the source square
996 Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
997 byTypeBB[ALL_PIECES] ^= from_to_bb;
998 byTypeBB[pt] ^= from_to_bb;
999 byColorBB[us] ^= from_to_bb;
1001 board[from] = board[to];
1002 board[to] = NO_PIECE;
1004 // Update piece lists, index[to] is not updated and becomes stale. This
1005 // works as long as index[] is accessed just by known occupied squares.
1006 index[from] = index[to];
1007 pieceList[us][pt][index[from]] = from;
1013 if (is_enpassant(m))
1015 capsq -= pawn_push(us);
1018 assert(to == st->previous->epSquare);
1019 assert(relative_rank(us, to) == RANK_6);
1020 assert(piece_on(capsq) == NO_PIECE);
1023 // Restore the captured piece
1024 byTypeBB[ALL_PIECES] |= capsq;
1025 byTypeBB[capture] |= capsq;
1026 byColorBB[them] |= capsq;
1028 board[capsq] = make_piece(them, capture);
1030 // Update piece list, add a new captured piece in capsq square
1031 index[capsq] = pieceCount[them][capture]++;
1032 pieceList[them][capture][index[capsq]] = capsq;
1035 // Finally point our state pointer back to the previous state
1038 assert(pos_is_ok());
1042 /// Position::do_castle_move() is a private method used to do/undo a castling
1043 /// move. Note that castling moves are encoded as "king captures friendly rook"
1044 /// moves, for instance white short castling in a non-Chess960 game is encoded
1047 void Position::do_castle_move(Move m) {
1050 assert(is_castle(m));
1052 Square kto, kfrom, rfrom, rto, kAfter, rAfter;
1054 Color us = sideToMove;
1055 Square kBefore = from_sq(m);
1056 Square rBefore = to_sq(m);
1058 // Find after-castle squares for king and rook
1059 if (rBefore > kBefore) // O-O
1061 kAfter = relative_square(us, SQ_G1);
1062 rAfter = relative_square(us, SQ_F1);
1066 kAfter = relative_square(us, SQ_C1);
1067 rAfter = relative_square(us, SQ_D1);
1070 kfrom = Do ? kBefore : kAfter;
1071 rfrom = Do ? rBefore : rAfter;
1073 kto = Do ? kAfter : kBefore;
1074 rto = Do ? rAfter : rBefore;
1076 assert(piece_on(kfrom) == make_piece(us, KING));
1077 assert(piece_on(rfrom) == make_piece(us, ROOK));
1079 // Remove pieces from source squares
1080 byTypeBB[ALL_PIECES] ^= kfrom;
1081 byTypeBB[KING] ^= kfrom;
1082 byColorBB[us] ^= kfrom;
1083 byTypeBB[ALL_PIECES] ^= rfrom;
1084 byTypeBB[ROOK] ^= rfrom;
1085 byColorBB[us] ^= rfrom;
1087 // Put pieces on destination squares
1088 byTypeBB[ALL_PIECES] |= kto;
1089 byTypeBB[KING] |= kto;
1090 byColorBB[us] |= kto;
1091 byTypeBB[ALL_PIECES] |= rto;
1092 byTypeBB[ROOK] |= rto;
1093 byColorBB[us] |= rto;
1096 Piece king = make_piece(us, KING);
1097 Piece rook = make_piece(us, ROOK);
1098 board[kfrom] = board[rfrom] = NO_PIECE;
1102 // Update piece lists
1103 pieceList[us][KING][index[kfrom]] = kto;
1104 pieceList[us][ROOK][index[rfrom]] = rto;
1105 int tmp = index[rfrom]; // In Chess960 could be kto == rfrom
1106 index[kto] = index[kfrom];
1111 // Reset capture field
1112 st->capturedType = NO_PIECE_TYPE;
1114 // Update incremental scores
1115 st->psqScore += psq_delta(king, kfrom, kto);
1116 st->psqScore += psq_delta(rook, rfrom, rto);
1119 st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
1120 st->key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto];
1122 // Clear en passant square
1123 if (st->epSquare != SQ_NONE)
1125 st->key ^= zobEp[file_of(st->epSquare)];
1126 st->epSquare = SQ_NONE;
1129 // Update castling rights
1130 st->key ^= zobCastle[st->castleRights & castleRightsMask[kfrom]];
1131 st->castleRights &= ~castleRightsMask[kfrom];
1133 // Update checkers BB
1134 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1137 sideToMove = ~sideToMove;
1138 st->psqScore += (sideToMove == WHITE ? Tempo : -Tempo);
1141 // Undo: point our state pointer back to the previous state
1144 assert(pos_is_ok());
1148 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1149 /// to move and updates the hash key without executing any move on the board.
1151 void Position::do_null_move(StateInfo& backupSt) {
1153 assert(!in_check());
1155 // Back up the information necessary to undo the null move to the supplied
1156 // StateInfo object. Note that differently from normal case here backupSt
1157 // is actually used as a backup storage not as the new state. This reduces
1158 // the number of fields to be copied.
1159 StateInfo* src = Do ? st : &backupSt;
1160 StateInfo* dst = Do ? &backupSt : st;
1162 dst->key = src->key;
1163 dst->epSquare = src->epSquare;
1164 dst->psqScore = src->psqScore;
1165 dst->rule50 = src->rule50;
1166 dst->pliesFromNull = src->pliesFromNull;
1168 sideToMove = ~sideToMove;
1172 if (st->epSquare != SQ_NONE)
1173 st->key ^= zobEp[file_of(st->epSquare)];
1175 st->key ^= zobSideToMove;
1176 prefetch((char*)TT.first_entry(st->key));
1178 st->epSquare = SQ_NONE;
1180 st->pliesFromNull = 0;
1181 st->psqScore += (sideToMove == WHITE ? Tempo : -Tempo);
1184 assert(pos_is_ok());
1187 // Explicit template instantiations
1188 template void Position::do_null_move<false>(StateInfo& backupSt);
1189 template void Position::do_null_move<true>(StateInfo& backupSt);
1192 /// Position::see() is a static exchange evaluator: It tries to estimate the
1193 /// material gain or loss resulting from a move. There are three versions of
1194 /// this function: One which takes a destination square as input, one takes a
1195 /// move, and one which takes a 'from' and a 'to' square. The function does
1196 /// not yet understand promotions captures.
1198 int Position::see_sign(Move m) const {
1202 // Early return if SEE cannot be negative because captured piece value
1203 // is not less then capturing one. Note that king moves always return
1204 // here because king midgame value is set to 0.
1205 if (PieceValueMidgame[piece_on(to_sq(m))] >= PieceValueMidgame[piece_moved(m)])
1211 int Position::see(Move m) const {
1214 Bitboard occ, attackers, stmAttackers, b;
1215 int swapList[32], slIndex = 1;
1216 PieceType capturedType, pt;
1221 // As castle moves are implemented as capturing the rook, they have
1222 // SEE == RookValueMidgame most of the times (unless the rook is under
1229 capturedType = type_of(piece_on(to));
1232 // Handle en passant moves
1233 if (is_enpassant(m))
1235 Square capQq = to - pawn_push(sideToMove);
1237 assert(!capturedType);
1238 assert(type_of(piece_on(capQq)) == PAWN);
1240 // Remove the captured pawn
1242 capturedType = PAWN;
1245 // Find all attackers to the destination square, with the moving piece
1246 // removed, but possibly an X-ray attacker added behind it.
1248 attackers = attackers_to(to, occ);
1250 // If the opponent has no attackers we are finished
1251 stm = ~color_of(piece_on(from));
1252 stmAttackers = attackers & pieces(stm);
1254 return PieceValueMidgame[capturedType];
1256 // The destination square is defended, which makes things rather more
1257 // difficult to compute. We proceed by building up a "swap list" containing
1258 // the material gain or loss at each stop in a sequence of captures to the
1259 // destination square, where the sides alternately capture, and always
1260 // capture with the least valuable piece. After each capture, we look for
1261 // new X-ray attacks from behind the capturing piece.
1262 swapList[0] = PieceValueMidgame[capturedType];
1263 capturedType = type_of(piece_on(from));
1266 // Locate the least valuable attacker for the side to move. The loop
1267 // below looks like it is potentially infinite, but it isn't. We know
1268 // that the side to move still has at least one attacker left.
1269 for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
1272 // Remove the attacker we just found from the 'occupied' bitboard,
1273 // and scan for new X-ray attacks behind the attacker.
1274 b = stmAttackers & pieces(pt);
1275 occ ^= (b & (~b + 1));
1276 attackers |= (attacks_bb<ROOK>(to, occ) & pieces(ROOK, QUEEN))
1277 | (attacks_bb<BISHOP>(to, occ) & pieces(BISHOP, QUEEN));
1279 attackers &= occ; // Cut out pieces we've already done
1281 // Add the new entry to the swap list
1282 assert(slIndex < 32);
1283 swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
1286 // Remember the value of the capturing piece, and change the side to
1287 // move before beginning the next iteration.
1290 stmAttackers = attackers & pieces(stm);
1292 // Stop before processing a king capture
1293 if (capturedType == KING && stmAttackers)
1295 assert(slIndex < 32);
1296 swapList[slIndex++] = QueenValueMidgame*10;
1299 } while (stmAttackers);
1301 // Having built the swap list, we negamax through it to find the best
1302 // achievable score from the point of view of the side to move.
1304 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1310 /// Position::clear() erases the position object to a pristine state, with an
1311 /// empty board, white to move, and no castling rights.
1313 void Position::clear() {
1315 memset(this, 0, sizeof(Position));
1316 startState.epSquare = SQ_NONE;
1319 for (int i = 0; i < 8; i++)
1320 for (int j = 0; j < 16; j++)
1321 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1323 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1324 board[sq] = NO_PIECE;
1328 /// Position::put_piece() puts a piece on the given square of the board,
1329 /// updating the board array, pieces list, bitboards, and piece counts.
1331 void Position::put_piece(Piece p, Square s) {
1333 Color c = color_of(p);
1334 PieceType pt = type_of(p);
1337 index[s] = pieceCount[c][pt]++;
1338 pieceList[c][pt][index[s]] = s;
1340 byTypeBB[ALL_PIECES] |= s;
1346 /// Position::compute_key() computes the hash key of the position. The hash
1347 /// key is usually updated incrementally as moves are made and unmade, the
1348 /// compute_key() function is only used when a new position is set up, and
1349 /// to verify the correctness of the hash key when running in debug mode.
1351 Key Position::compute_key() const {
1353 Key result = zobCastle[st->castleRights];
1355 for (Square s = SQ_A1; s <= SQ_H8; s++)
1356 if (!square_empty(s))
1357 result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
1359 if (ep_square() != SQ_NONE)
1360 result ^= zobEp[file_of(ep_square())];
1362 if (sideToMove == BLACK)
1363 result ^= zobSideToMove;
1369 /// Position::compute_pawn_key() computes the hash key of the position. The
1370 /// hash key is usually updated incrementally as moves are made and unmade,
1371 /// the compute_pawn_key() function is only used when a new position is set
1372 /// up, and to verify the correctness of the pawn hash key when running in
1375 Key Position::compute_pawn_key() const {
1380 for (Color c = WHITE; c <= BLACK; c++)
1382 b = pieces(PAWN, c);
1384 result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
1390 /// Position::compute_material_key() computes the hash key of the position.
1391 /// The hash key is usually updated incrementally as moves are made and unmade,
1392 /// the compute_material_key() function is only used when a new position is set
1393 /// up, and to verify the correctness of the material hash key when running in
1396 Key Position::compute_material_key() const {
1400 for (Color c = WHITE; c <= BLACK; c++)
1401 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1402 for (int i = 0; i < piece_count(c, pt); i++)
1403 result ^= zobrist[c][pt][i];
1409 /// Position::compute_psq_score() computes the incremental scores for the middle
1410 /// game and the endgame. These functions are used to initialize the incremental
1411 /// scores when a new position is set up, and to verify that the scores are correctly
1412 /// updated by do_move and undo_move when the program is running in debug mode.
1413 Score Position::compute_psq_score() const {
1416 Score result = SCORE_ZERO;
1418 for (Color c = WHITE; c <= BLACK; c++)
1419 for (PieceType pt = PAWN; pt <= KING; pt++)
1423 result += pieceSquareTable[make_piece(c, pt)][pop_1st_bit(&b)];
1426 result += (sideToMove == WHITE ? Tempo / 2 : -Tempo / 2);
1431 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1432 /// game material value for the given side. Material values are updated
1433 /// incrementally during the search, this function is only used while
1434 /// initializing a new Position object.
1436 Value Position::compute_non_pawn_material(Color c) const {
1438 Value result = VALUE_ZERO;
1440 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1441 result += piece_count(c, pt) * PieceValueMidgame[pt];
1447 /// Position::is_draw() tests whether the position is drawn by material,
1448 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1449 /// must be done by the search.
1450 template<bool SkipRepetition>
1451 bool Position::is_draw() const {
1453 // Draw by material?
1455 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMidgame))
1458 // Draw by the 50 moves rule?
1459 if (st->rule50 > 99 && (!in_check() || MoveList<MV_LEGAL>(*this).size()))
1462 // Draw by repetition?
1463 if (!SkipRepetition)
1465 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1469 StateInfo* stp = st->previous->previous;
1472 stp = stp->previous->previous;
1474 if (stp->key == st->key)
1486 // Explicit template instantiations
1487 template bool Position::is_draw<false>() const;
1488 template bool Position::is_draw<true>() const;
1491 /// Position::init() is a static member function which initializes at startup
1492 /// the various arrays used to compute hash keys and the piece square tables.
1493 /// The latter is a two-step operation: First, the white halves of the tables
1494 /// are copied from PSQT[] tables. Second, the black halves of the tables are
1495 /// initialized by flipping and changing the sign of the white scores.
1497 void Position::init() {
1501 for (Color c = WHITE; c <= BLACK; c++)
1502 for (PieceType pt = PAWN; pt <= KING; pt++)
1503 for (Square s = SQ_A1; s <= SQ_H8; s++)
1504 zobrist[c][pt][s] = rk.rand<Key>();
1506 for (File f = FILE_A; f <= FILE_H; f++)
1507 zobEp[f] = rk.rand<Key>();
1509 for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
1514 Key k = zobCastle[1ULL << pop_1st_bit(&b)];
1515 zobCastle[cr] ^= k ? k : rk.rand<Key>();
1519 zobSideToMove = rk.rand<Key>();
1520 zobExclusion = rk.rand<Key>();
1522 for (Piece p = W_PAWN; p <= W_KING; p++)
1524 Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
1526 for (Square s = SQ_A1; s <= SQ_H8; s++)
1528 pieceSquareTable[p][s] = ps + PSQT[p][s];
1529 pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
1535 /// Position::flip() flips position with the white and black sides reversed. This
1536 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1538 void Position::flip() {
1540 // Make a copy of current position before to start changing
1541 const Position pos(*this);
1546 for (Square s = SQ_A1; s <= SQ_H8; s++)
1547 if (!pos.square_empty(s))
1548 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1551 sideToMove = ~pos.side_to_move();
1554 if (pos.can_castle(WHITE_OO))
1555 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
1556 if (pos.can_castle(WHITE_OOO))
1557 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
1558 if (pos.can_castle(BLACK_OO))
1559 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
1560 if (pos.can_castle(BLACK_OOO))
1561 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
1563 // En passant square
1564 if (pos.st->epSquare != SQ_NONE)
1565 st->epSquare = ~pos.st->epSquare;
1568 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1571 st->key = compute_key();
1572 st->pawnKey = compute_pawn_key();
1573 st->materialKey = compute_material_key();
1575 // Incremental scores
1576 st->psqScore = compute_psq_score();
1579 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1580 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1582 assert(pos_is_ok());
1586 /// Position::pos_is_ok() performs some consitency checks for the position object.
1587 /// This is meant to be helpful when debugging.
1589 bool Position::pos_is_ok(int* failedStep) const {
1591 // What features of the position should be verified?
1592 const bool debugAll = false;
1594 const bool debugBitboards = debugAll || false;
1595 const bool debugKingCount = debugAll || false;
1596 const bool debugKingCapture = debugAll || false;
1597 const bool debugCheckerCount = debugAll || false;
1598 const bool debugKey = debugAll || false;
1599 const bool debugMaterialKey = debugAll || false;
1600 const bool debugPawnKey = debugAll || false;
1601 const bool debugIncrementalEval = debugAll || false;
1602 const bool debugNonPawnMaterial = debugAll || false;
1603 const bool debugPieceCounts = debugAll || false;
1604 const bool debugPieceList = debugAll || false;
1605 const bool debugCastleSquares = debugAll || false;
1607 if (failedStep) *failedStep = 1;
1610 if (sideToMove != WHITE && sideToMove != BLACK)
1613 // Are the king squares in the position correct?
1614 if (failedStep) (*failedStep)++;
1615 if (piece_on(king_square(WHITE)) != W_KING)
1618 if (failedStep) (*failedStep)++;
1619 if (piece_on(king_square(BLACK)) != B_KING)
1622 // Do both sides have exactly one king?
1623 if (failedStep) (*failedStep)++;
1626 int kingCount[2] = {0, 0};
1627 for (Square s = SQ_A1; s <= SQ_H8; s++)
1628 if (type_of(piece_on(s)) == KING)
1629 kingCount[color_of(piece_on(s))]++;
1631 if (kingCount[0] != 1 || kingCount[1] != 1)
1635 // Can the side to move capture the opponent's king?
1636 if (failedStep) (*failedStep)++;
1637 if (debugKingCapture)
1639 Color us = sideToMove;
1641 Square ksq = king_square(them);
1642 if (attackers_to(ksq) & pieces(us))
1646 // Is there more than 2 checkers?
1647 if (failedStep) (*failedStep)++;
1648 if (debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1652 if (failedStep) (*failedStep)++;
1655 // The intersection of the white and black pieces must be empty
1656 if (pieces(WHITE) & pieces(BLACK))
1659 // The union of the white and black pieces must be equal to all
1661 if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1664 // Separate piece type bitboards must have empty intersections
1665 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1666 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1667 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1671 // En passant square OK?
1672 if (failedStep) (*failedStep)++;
1673 if (ep_square() != SQ_NONE)
1675 // The en passant square must be on rank 6, from the point of view of the
1677 if (relative_rank(sideToMove, ep_square()) != RANK_6)
1682 if (failedStep) (*failedStep)++;
1683 if (debugKey && st->key != compute_key())
1686 // Pawn hash key OK?
1687 if (failedStep) (*failedStep)++;
1688 if (debugPawnKey && st->pawnKey != compute_pawn_key())
1691 // Material hash key OK?
1692 if (failedStep) (*failedStep)++;
1693 if (debugMaterialKey && st->materialKey != compute_material_key())
1696 // Incremental eval OK?
1697 if (failedStep) (*failedStep)++;
1698 if (debugIncrementalEval && st->psqScore != compute_psq_score())
1701 // Non-pawn material OK?
1702 if (failedStep) (*failedStep)++;
1703 if (debugNonPawnMaterial)
1705 if (st->npMaterial[WHITE] != compute_non_pawn_material(WHITE))
1708 if (st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1713 if (failedStep) (*failedStep)++;
1714 if (debugPieceCounts)
1715 for (Color c = WHITE; c <= BLACK; c++)
1716 for (PieceType pt = PAWN; pt <= KING; pt++)
1717 if (pieceCount[c][pt] != popcount<Full>(pieces(pt, c)))
1720 if (failedStep) (*failedStep)++;
1722 for (Color c = WHITE; c <= BLACK; c++)
1723 for (PieceType pt = PAWN; pt <= KING; pt++)
1724 for (int i = 0; i < pieceCount[c][pt]; i++)
1726 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1729 if (index[piece_list(c, pt)[i]] != i)
1733 if (failedStep) (*failedStep)++;
1734 if (debugCastleSquares)
1735 for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1))
1740 Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
1742 if ( piece_on(castleRookSquare[f]) != rook
1743 || castleRightsMask[castleRookSquare[f]] != f)
1747 if (failedStep) *failedStep = 0;