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 TempoValue = 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 c'tors. Here we always create a copy of the original position
96 /// or the FEN string, we want the new born Position object do not depend
97 /// on any external data so we detach state pointer from the source one.
99 void Position::copy(const Position& pos, int th) {
101 memcpy(this, &pos, sizeof(Position));
110 Position::Position(const string& fen, bool isChess960, int th) {
112 from_fen(fen, isChess960);
117 /// Position::from_fen() initializes the position object with the given FEN
118 /// string. This function is not very robust - make sure that input FENs are
119 /// correct (this is assumed to be the responsibility of the GUI).
121 void Position::from_fen(const string& fenStr, bool isChess960) {
123 A FEN string defines a particular position using only the ASCII character set.
125 A FEN string contains six fields separated by a space. The fields are:
127 1) Piece placement (from white's perspective). Each rank is described, starting
128 with rank 8 and ending with rank 1; within each rank, the contents of each
129 square are described from file A through file H. Following the Standard
130 Algebraic Notation (SAN), each piece is identified by a single letter taken
131 from the standard English names. White pieces are designated using upper-case
132 letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
133 noted using digits 1 through 8 (the number of blank squares), and "/"
136 2) Active color. "w" means white moves next, "b" means black.
138 3) Castling availability. If neither side can castle, this is "-". Otherwise,
139 this has one or more letters: "K" (White can castle kingside), "Q" (White
140 can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
141 can castle queenside).
143 4) En passant target square (in algebraic notation). If there's no en passant
144 target square, this is "-". If a pawn has just made a 2-square move, this
145 is the position "behind" the pawn. This is recorded regardless of whether
146 there is a pawn in position to make an en passant capture.
148 5) Halfmove clock. This is the number of halfmoves since the last pawn advance
149 or capture. This is used to determine if a draw can be claimed under the
152 6) Fullmove number. The number of the full move. It starts at 1, and is
153 incremented after Black's move.
156 char col, row, token;
159 std::istringstream fen(fenStr);
162 fen >> std::noskipws;
164 // 1. Piece placement
165 while ((fen >> token) && !isspace(token))
168 sq += Square(token - '0'); // Advance the given number of files
170 else if (token == '/')
171 sq = make_square(FILE_A, rank_of(sq) - Rank(2));
173 else if ((p = PieceToChar.find(token)) != string::npos)
175 put_piece(Piece(p), sq);
182 sideToMove = (token == 'w' ? WHITE : BLACK);
185 // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
186 // Shredder-FEN that uses the letters of the columns on which the rooks began
187 // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
188 // if an inner rook is associated with the castling right, the castling tag is
189 // replaced by the file letter of the involved rook, as for the Shredder-FEN.
190 while ((fen >> token) && !isspace(token))
193 Color c = islower(token) ? BLACK : WHITE;
195 token = char(toupper(token));
198 for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
200 else if (token == 'Q')
201 for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
203 else if (token >= 'A' && token <= 'H')
204 rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1));
209 set_castle_right(c, rsq);
212 // 4. En passant square. Ignore if no pawn capture is possible
213 if ( ((fen >> col) && (col >= 'a' && col <= 'h'))
214 && ((fen >> row) && (row == '3' || row == '6')))
216 st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
218 if (!(attackers_to(st->epSquare) & pieces(PAWN, sideToMove)))
219 st->epSquare = SQ_NONE;
222 // 5-6. Halfmove clock and fullmove number
223 fen >> std::skipws >> st->rule50 >> startPosPly;
225 // Convert from fullmove starting from 1 to ply starting from 0,
226 // handle also common incorrect FEN with fullmove = 0.
227 startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
229 st->key = compute_key();
230 st->pawnKey = compute_pawn_key();
231 st->materialKey = compute_material_key();
232 st->value = compute_value();
233 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
234 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
235 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
236 chess960 = isChess960;
242 /// Position::set_castle_right() is an helper function used to set castling
243 /// rights given the corresponding color and the rook starting square.
245 void Position::set_castle_right(Color c, Square rfrom) {
247 Square kfrom = king_square(c);
248 bool kingSide = kfrom < rfrom;
249 int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c;
251 st->castleRights |= cr;
252 castleRightsMask[kfrom] |= cr;
253 castleRightsMask[rfrom] |= cr;
254 castleRookSquare[cr] = rfrom;
256 Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1);
257 Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1);
259 for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
260 if (s != kfrom && s != rfrom)
263 for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
264 if (s != kfrom && s != rfrom)
269 /// Position::to_fen() returns a FEN representation of the position. In case
270 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
272 const string Position::to_fen() const {
274 std::ostringstream fen;
278 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
282 for (File file = FILE_A; file <= FILE_H; file++)
284 sq = make_square(file, rank);
286 if (square_is_empty(sq))
295 fen << PieceToChar[piece_on(sq)];
306 fen << (sideToMove == WHITE ? " w " : " b ");
308 if (can_castle(WHITE_OO))
309 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K');
311 if (can_castle(WHITE_OOO))
312 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q');
314 if (can_castle(BLACK_OO))
315 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k');
317 if (can_castle(BLACK_OOO))
318 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q');
320 if (st->castleRights == CASTLES_NONE)
323 fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
324 << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2;
330 /// Position::print() prints an ASCII representation of the position to
331 /// the standard output. If a move is given then also the san is printed.
333 void Position::print(Move move) const {
335 const char* dottedLine = "\n+---+---+---+---+---+---+---+---+\n";
339 Position p(*this, thread());
340 cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
343 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
345 cout << dottedLine << '|';
346 for (File file = FILE_A; file <= FILE_H; file++)
348 Square sq = make_square(file, rank);
349 Piece piece = piece_on(sq);
350 char c = (color_of(piece) == BLACK ? '=' : ' ');
352 if (piece == NO_PIECE && !opposite_colors(sq, SQ_A1))
353 piece++; // Index the dot
355 cout << c << PieceToChar[piece] << c << '|';
358 cout << dottedLine << "Fen is: " << to_fen() << "\nKey is: " << st->key << endl;
362 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
363 /// king) pieces for the given color. Or, when template parameter FindPinned is
364 /// false, the function return the pieces of the given color candidate for a
365 /// discovery check against the enemy king.
366 template<bool FindPinned>
367 Bitboard Position::hidden_checkers() const {
369 // Pinned pieces protect our king, dicovery checks attack the enemy king
370 Bitboard b, result = 0;
371 Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
372 Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
374 // Pinners are sliders, that give check when candidate pinned is removed
375 pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
376 | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
380 b = squares_between(ksq, pop_1st_bit(&pinners)) & pieces();
382 if (b && single_bit(b) && (b & pieces(sideToMove)))
388 // Explicit template instantiations
389 template Bitboard Position::hidden_checkers<true>() const;
390 template Bitboard Position::hidden_checkers<false>() const;
393 /// Position::attackers_to() computes a bitboard of all pieces which attack a
394 /// given square. Slider attacks use occ bitboard as occupancy.
396 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
398 return (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
399 | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
400 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
401 | (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN))
402 | (attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN))
403 | (attacks_from<KING>(s) & pieces(KING));
407 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
408 /// put in a given square. Slider attacks use occ bitboard as occupancy.
410 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
412 assert(square_is_ok(s));
416 case BISHOP: return attacks_bb<BISHOP>(s, occ);
417 case ROOK : return attacks_bb<ROOK>(s, occ);
418 case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
419 default : return StepAttacksBB[p][s];
424 /// Position::move_attacks_square() tests whether a move from the current
425 /// position attacks a given square.
427 bool Position::move_attacks_square(Move m, Square s) const {
430 assert(square_is_ok(s));
433 Square from = from_sq(m);
434 Square to = to_sq(m);
435 Piece piece = piece_moved(m);
437 assert(!square_is_empty(from));
439 // Update occupancy as if the piece is moving
440 occ = pieces() ^ from ^ to;
442 // The piece moved in 'to' attacks the square 's' ?
443 if (attacks_from(piece, to, occ) & s)
446 // Scan for possible X-ray attackers behind the moved piece
447 xray = (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN, color_of(piece)))
448 |(attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
450 // Verify attackers are triggered by our move and not already existing
451 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
455 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
457 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
460 assert(pinned == pinned_pieces());
462 Color us = sideToMove;
463 Square from = from_sq(m);
465 assert(color_of(piece_moved(m)) == us);
466 assert(piece_on(king_square(us)) == make_piece(us, KING));
468 // En passant captures are a tricky special case. Because they are rather
469 // uncommon, we do it simply by testing whether the king is attacked after
474 Square to = to_sq(m);
475 Square capsq = to + pawn_push(them);
476 Square ksq = king_square(us);
477 Bitboard b = (pieces() ^ from ^ capsq) | to;
479 assert(to == ep_square());
480 assert(piece_moved(m) == make_piece(us, PAWN));
481 assert(piece_on(capsq) == make_piece(them, PAWN));
482 assert(piece_on(to) == NO_PIECE);
484 return !(attacks_bb<ROOK>(ksq, b) & pieces(ROOK, QUEEN, them))
485 && !(attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, them));
488 // If the moving piece is a king, check whether the destination
489 // square is attacked by the opponent. Castling moves are checked
490 // for legality during move generation.
491 if (type_of(piece_on(from)) == KING)
492 return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
494 // A non-king move is legal if and only if it is not pinned or it
495 // is moving along the ray towards or away from the king.
498 || squares_aligned(from, to_sq(m), king_square(us));
502 /// Position::move_is_legal() takes a random move and tests whether the move
503 /// is legal. This version is not very fast and should be used only in non
504 /// time-critical paths.
506 bool Position::move_is_legal(const Move m) const {
508 for (MoveList<MV_LEGAL> ml(*this); !ml.end(); ++ml)
516 /// Position::is_pseudo_legal() takes a random move and tests whether the move
517 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
518 /// due to SMP concurrent access or hash position key aliasing.
520 bool Position::is_pseudo_legal(const Move m) const {
522 Color us = sideToMove;
523 Color them = ~sideToMove;
524 Square from = from_sq(m);
525 Square to = to_sq(m);
526 Piece pc = piece_moved(m);
528 // Use a slower but simpler function for uncommon cases
530 return move_is_legal(m);
532 // Is not a promotion, so promotion piece must be empty
533 if (promotion_type(m) - 2 != NO_PIECE_TYPE)
536 // If the from square is not occupied by a piece belonging to the side to
537 // move, the move is obviously not legal.
538 if (pc == NO_PIECE || color_of(pc) != us)
541 // The destination square cannot be occupied by a friendly piece
542 if (color_of(piece_on(to)) == us)
545 // Handle the special case of a pawn move
546 if (type_of(pc) == PAWN)
548 // Move direction must be compatible with pawn color
549 int direction = to - from;
550 if ((us == WHITE) != (direction > 0))
553 // We have already handled promotion moves, so destination
554 // cannot be on the 8/1th rank.
555 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
558 // Proceed according to the square delta between the origin and
559 // destination squares.
566 // Capture. The destination square must be occupied by an enemy
567 // piece (en passant captures was handled earlier).
568 if (color_of(piece_on(to)) != them)
571 // From and to files must be one file apart, avoids a7h5
572 if (abs(file_of(from) - file_of(to)) != 1)
578 // Pawn push. The destination square must be empty.
579 if (!square_is_empty(to))
584 // Double white pawn push. The destination square must be on the fourth
585 // rank, and both the destination square and the square between the
586 // source and destination squares must be empty.
587 if ( rank_of(to) != RANK_4
588 || !square_is_empty(to)
589 || !square_is_empty(from + DELTA_N))
594 // Double black pawn push. The destination square must be on the fifth
595 // rank, and both the destination square and the square between the
596 // source and destination squares must be empty.
597 if ( rank_of(to) != RANK_5
598 || !square_is_empty(to)
599 || !square_is_empty(from + DELTA_S))
607 else if (!(attacks_from(pc, from) & to))
610 // Evasions generator already takes care to avoid some kind of illegal moves
611 // and pl_move_is_legal() relies on this. So we have to take care that the
612 // same kind of moves are filtered out here.
615 if (type_of(pc) != KING)
617 Bitboard b = checkers();
618 Square checksq = pop_1st_bit(&b);
620 if (b) // double check ? In this case a king move is required
623 // Our move must be a blocking evasion or a capture of the checking piece
624 if (!((squares_between(checksq, king_square(us)) | checkers()) & to))
627 // In case of king moves under check we have to remove king so to catch
628 // as invalid moves like b1a1 when opposite queen is on c1.
629 else if (attackers_to(to, pieces() ^ from) & pieces(~us))
637 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
639 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
642 assert(ci.dcCandidates == discovered_check_candidates());
643 assert(color_of(piece_moved(m)) == sideToMove);
645 Square from = from_sq(m);
646 Square to = to_sq(m);
647 PieceType pt = type_of(piece_on(from));
650 if (ci.checkSq[pt] & to)
654 if (ci.dcCandidates && (ci.dcCandidates & from))
656 // For pawn and king moves we need to verify also direction
657 if ( (pt != PAWN && pt != KING)
658 || !squares_aligned(from, to, king_square(~sideToMove)))
662 // Can we skip the ugly special cases ?
666 Color us = sideToMove;
667 Square ksq = king_square(~us);
669 // Promotion with check ?
671 return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
673 // En passant capture with check ? We have already handled the case
674 // of direct checks and ordinary discovered check, the only case we
675 // need to handle is the unusual case of a discovered check through
676 // the captured pawn.
679 Square capsq = make_square(file_of(to), rank_of(from));
680 Bitboard b = (pieces() ^ from ^ capsq) | to;
682 return (attacks_bb< ROOK>(ksq, b) & pieces( ROOK, QUEEN, us))
683 | (attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, us));
686 // Castling with check ?
690 Square rfrom = to; // 'King captures the rook' notation
691 Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
692 Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
693 Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
695 return attacks_bb<ROOK>(rto, b) & ksq;
702 /// Position::do_move() makes a move, and saves all information necessary
703 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
704 /// moves should be filtered out before this function is called.
706 void Position::do_move(Move m, StateInfo& newSt) {
709 do_move(m, newSt, ci, move_gives_check(m, ci));
712 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
715 assert(&newSt != st);
720 // Copy some fields of old state to our new StateInfo object except the ones
721 // which are recalculated from scratch anyway, then switch our state pointer
722 // to point to the new, ready to be updated, state.
723 struct ReducedStateInfo {
724 Key pawnKey, materialKey;
726 int castleRights, rule50, pliesFromNull;
731 memcpy(&newSt, st, sizeof(ReducedStateInfo));
736 // Update side to move
739 // Increment the 50 moves rule draw counter. Resetting it to zero in the
740 // case of a capture or a pawn move is taken care of later.
747 do_castle_move<true>(m);
751 Color us = sideToMove;
753 Square from = from_sq(m);
754 Square to = to_sq(m);
755 Piece piece = piece_on(from);
756 PieceType pt = type_of(piece);
757 PieceType capture = is_enpassant(m) ? PAWN : type_of(piece_on(to));
759 assert(color_of(piece) == us);
760 assert(color_of(piece_on(to)) != us);
761 assert(capture != KING);
767 // If the captured piece is a pawn, update pawn hash key, otherwise
768 // update non-pawn material.
773 capsq += pawn_push(them);
776 assert(to == st->epSquare);
777 assert(relative_rank(us, to) == RANK_6);
778 assert(piece_on(to) == NO_PIECE);
779 assert(piece_on(capsq) == make_piece(them, PAWN));
781 board[capsq] = NO_PIECE;
784 st->pawnKey ^= zobrist[them][PAWN][capsq];
787 st->npMaterial[them] -= PieceValueMidgame[capture];
789 // Remove the captured piece
790 byTypeBB[ALL_PIECES] ^= capsq;
791 byTypeBB[capture] ^= capsq;
792 byColorBB[them] ^= capsq;
794 // Update piece list, move the last piece at index[capsq] position and
797 // WARNING: This is a not revresible operation. When we will reinsert the
798 // captured piece in undo_move() we will put it at the end of the list and
799 // not in its original place, it means index[] and pieceList[] are not
800 // guaranteed to be invariant to a do_move() + undo_move() sequence.
801 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
802 index[lastSquare] = index[capsq];
803 pieceList[them][capture][index[lastSquare]] = lastSquare;
804 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
807 k ^= zobrist[them][capture][capsq];
808 st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
810 // Update incremental scores
811 st->value -= pst(make_piece(them, capture), capsq);
813 // Reset rule 50 counter
818 k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
820 // Reset en passant square
821 if (st->epSquare != SQ_NONE)
823 k ^= zobEp[file_of(st->epSquare)];
824 st->epSquare = SQ_NONE;
827 // Update castle rights if needed
828 if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
830 int cr = castleRightsMask[from] | castleRightsMask[to];
831 k ^= zobCastle[st->castleRights & cr];
832 st->castleRights &= ~cr;
835 // Prefetch TT access as soon as we know key is updated
836 prefetch((char*)TT.first_entry(k));
839 Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
840 byTypeBB[ALL_PIECES] ^= from_to_bb;
841 byTypeBB[pt] ^= from_to_bb;
842 byColorBB[us] ^= from_to_bb;
844 board[to] = board[from];
845 board[from] = NO_PIECE;
847 // Update piece lists, index[from] is not updated and becomes stale. This
848 // works as long as index[] is accessed just by known occupied squares.
849 index[to] = index[from];
850 pieceList[us][pt][index[to]] = to;
852 // If the moving piece is a pawn do some special extra work
855 // Set en-passant square, only if moved pawn can be captured
856 if ( (int(to) ^ int(from)) == 16
857 && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(PAWN, them)))
859 st->epSquare = Square((from + to) / 2);
860 k ^= zobEp[file_of(st->epSquare)];
865 PieceType promotion = promotion_type(m);
867 assert(relative_rank(us, to) == RANK_8);
868 assert(promotion >= KNIGHT && promotion <= QUEEN);
870 // Replace the pawn with the promoted piece
871 byTypeBB[PAWN] ^= to;
872 byTypeBB[promotion] |= to;
873 board[to] = make_piece(us, promotion);
875 // Update piece lists, move the last pawn at index[to] position
876 // and shrink the list. Add a new promotion piece to the list.
877 Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
878 index[lastSquare] = index[to];
879 pieceList[us][PAWN][index[lastSquare]] = lastSquare;
880 pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
881 index[to] = pieceCount[us][promotion];
882 pieceList[us][promotion][index[to]] = to;
885 k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
886 st->pawnKey ^= zobrist[us][PAWN][to];
887 st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]++]
888 ^ zobrist[us][PAWN][pieceCount[us][PAWN]];
890 // Update incremental score
891 st->value += pst(make_piece(us, promotion), to)
892 - pst(make_piece(us, PAWN), to);
895 st->npMaterial[us] += PieceValueMidgame[promotion];
898 // Update pawn hash key
899 st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
901 // Reset rule 50 draw counter
905 // Prefetch pawn and material hash tables
906 Threads[threadID].pawnTable.prefetch(st->pawnKey);
907 Threads[threadID].materialTable.prefetch(st->materialKey);
909 // Update incremental scores
910 st->value += pst_delta(piece, from, to);
913 st->capturedType = capture;
915 // Update the key with the final value
918 // Update checkers bitboard, piece must be already moved
924 st->checkersBB = attackers_to(king_square(them)) & pieces(us);
928 if (ci.checkSq[pt] & to)
929 st->checkersBB |= to;
932 if (ci.dcCandidates && (ci.dcCandidates & from))
935 st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(ROOK, QUEEN, us);
938 st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(BISHOP, QUEEN, us);
944 sideToMove = ~sideToMove;
945 st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
951 /// Position::undo_move() unmakes a move. When it returns, the position should
952 /// be restored to exactly the same state as before the move was made.
954 void Position::undo_move(Move m) {
958 sideToMove = ~sideToMove;
962 do_castle_move<false>(m);
966 Color us = sideToMove;
968 Square from = from_sq(m);
969 Square to = to_sq(m);
970 Piece piece = piece_on(to);
971 PieceType pt = type_of(piece);
972 PieceType capture = st->capturedType;
974 assert(square_is_empty(from));
975 assert(color_of(piece) == us);
976 assert(capture != KING);
980 PieceType promotion = promotion_type(m);
982 assert(promotion == pt);
983 assert(relative_rank(us, to) == RANK_8);
984 assert(promotion >= KNIGHT && promotion <= QUEEN);
986 // Replace the promoted piece with the pawn
987 byTypeBB[promotion] ^= to;
988 byTypeBB[PAWN] |= to;
989 board[to] = make_piece(us, PAWN);
991 // Update piece lists, move the last promoted piece at index[to] position
992 // and shrink the list. Add a new pawn to the list.
993 Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
994 index[lastSquare] = index[to];
995 pieceList[us][promotion][index[lastSquare]] = lastSquare;
996 pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
997 index[to] = pieceCount[us][PAWN]++;
998 pieceList[us][PAWN][index[to]] = to;
1003 // Put the piece back at the source square
1004 Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
1005 byTypeBB[ALL_PIECES] ^= from_to_bb;
1006 byTypeBB[pt] ^= from_to_bb;
1007 byColorBB[us] ^= from_to_bb;
1009 board[from] = board[to];
1010 board[to] = NO_PIECE;
1012 // Update piece lists, index[to] is not updated and becomes stale. This
1013 // works as long as index[] is accessed just by known occupied squares.
1014 index[from] = index[to];
1015 pieceList[us][pt][index[from]] = from;
1021 if (is_enpassant(m))
1023 capsq -= pawn_push(us);
1026 assert(to == st->previous->epSquare);
1027 assert(relative_rank(us, to) == RANK_6);
1028 assert(piece_on(capsq) == NO_PIECE);
1031 // Restore the captured piece
1032 byTypeBB[ALL_PIECES] |= capsq;
1033 byTypeBB[capture] |= capsq;
1034 byColorBB[them] |= capsq;
1036 board[capsq] = make_piece(them, capture);
1038 // Update piece list, add a new captured piece in capsq square
1039 index[capsq] = pieceCount[them][capture]++;
1040 pieceList[them][capture][index[capsq]] = capsq;
1043 // Finally point our state pointer back to the previous state
1046 assert(pos_is_ok());
1050 /// Position::do_castle_move() is a private method used to do/undo a castling
1051 /// move. Note that castling moves are encoded as "king captures friendly rook"
1052 /// moves, for instance white short castling in a non-Chess960 game is encoded
1055 void Position::do_castle_move(Move m) {
1058 assert(is_castle(m));
1060 Square kto, kfrom, rfrom, rto, kAfter, rAfter;
1062 Color us = sideToMove;
1063 Square kBefore = from_sq(m);
1064 Square rBefore = to_sq(m);
1066 // Find after-castle squares for king and rook
1067 if (rBefore > kBefore) // O-O
1069 kAfter = relative_square(us, SQ_G1);
1070 rAfter = relative_square(us, SQ_F1);
1074 kAfter = relative_square(us, SQ_C1);
1075 rAfter = relative_square(us, SQ_D1);
1078 kfrom = Do ? kBefore : kAfter;
1079 rfrom = Do ? rBefore : rAfter;
1081 kto = Do ? kAfter : kBefore;
1082 rto = Do ? rAfter : rBefore;
1084 assert(piece_on(kfrom) == make_piece(us, KING));
1085 assert(piece_on(rfrom) == make_piece(us, ROOK));
1087 // Remove pieces from source squares
1088 byTypeBB[ALL_PIECES] ^= kfrom;
1089 byTypeBB[KING] ^= kfrom;
1090 byColorBB[us] ^= kfrom;
1091 byTypeBB[ALL_PIECES] ^= rfrom;
1092 byTypeBB[ROOK] ^= rfrom;
1093 byColorBB[us] ^= rfrom;
1095 // Put pieces on destination squares
1096 byTypeBB[ALL_PIECES] |= kto;
1097 byTypeBB[KING] |= kto;
1098 byColorBB[us] |= kto;
1099 byTypeBB[ALL_PIECES] |= rto;
1100 byTypeBB[ROOK] |= rto;
1101 byColorBB[us] |= rto;
1104 Piece king = make_piece(us, KING);
1105 Piece rook = make_piece(us, ROOK);
1106 board[kfrom] = board[rfrom] = NO_PIECE;
1110 // Update piece lists
1111 pieceList[us][KING][index[kfrom]] = kto;
1112 pieceList[us][ROOK][index[rfrom]] = rto;
1113 int tmp = index[rfrom]; // In Chess960 could be kto == rfrom
1114 index[kto] = index[kfrom];
1119 // Reset capture field
1120 st->capturedType = NO_PIECE_TYPE;
1122 // Update incremental scores
1123 st->value += pst_delta(king, kfrom, kto);
1124 st->value += pst_delta(rook, rfrom, rto);
1127 st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
1128 st->key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto];
1130 // Clear en passant square
1131 if (st->epSquare != SQ_NONE)
1133 st->key ^= zobEp[file_of(st->epSquare)];
1134 st->epSquare = SQ_NONE;
1137 // Update castling rights
1138 st->key ^= zobCastle[st->castleRights & castleRightsMask[kfrom]];
1139 st->castleRights &= ~castleRightsMask[kfrom];
1141 // Update checkers BB
1142 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1145 sideToMove = ~sideToMove;
1146 st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
1149 // Undo: point our state pointer back to the previous state
1152 assert(pos_is_ok());
1156 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1157 /// to move and updates the hash key without executing any move on the board.
1159 void Position::do_null_move(StateInfo& backupSt) {
1161 assert(!in_check());
1163 // Back up the information necessary to undo the null move to the supplied
1164 // StateInfo object. Note that differently from normal case here backupSt
1165 // is actually used as a backup storage not as the new state. This reduces
1166 // the number of fields to be copied.
1167 StateInfo* src = Do ? st : &backupSt;
1168 StateInfo* dst = Do ? &backupSt : st;
1170 dst->key = src->key;
1171 dst->epSquare = src->epSquare;
1172 dst->value = src->value;
1173 dst->rule50 = src->rule50;
1174 dst->pliesFromNull = src->pliesFromNull;
1176 sideToMove = ~sideToMove;
1180 if (st->epSquare != SQ_NONE)
1181 st->key ^= zobEp[file_of(st->epSquare)];
1183 st->key ^= zobSideToMove;
1184 prefetch((char*)TT.first_entry(st->key));
1186 st->epSquare = SQ_NONE;
1188 st->pliesFromNull = 0;
1189 st->value += (sideToMove == WHITE) ? TempoValue : -TempoValue;
1192 assert(pos_is_ok());
1195 // Explicit template instantiations
1196 template void Position::do_null_move<false>(StateInfo& backupSt);
1197 template void Position::do_null_move<true>(StateInfo& backupSt);
1200 /// Position::see() is a static exchange evaluator: It tries to estimate the
1201 /// material gain or loss resulting from a move. There are three versions of
1202 /// this function: One which takes a destination square as input, one takes a
1203 /// move, and one which takes a 'from' and a 'to' square. The function does
1204 /// not yet understand promotions captures.
1206 int Position::see_sign(Move m) const {
1210 // Early return if SEE cannot be negative because captured piece value
1211 // is not less then capturing one. Note that king moves always return
1212 // here because king midgame value is set to 0.
1213 if (PieceValueMidgame[piece_on(to_sq(m))] >= PieceValueMidgame[piece_moved(m)])
1219 int Position::see(Move m) const {
1222 Bitboard occ, attackers, stmAttackers, b;
1223 int swapList[32], slIndex = 1;
1224 PieceType capturedType, pt;
1229 // As castle moves are implemented as capturing the rook, they have
1230 // SEE == RookValueMidgame most of the times (unless the rook is under
1237 capturedType = type_of(piece_on(to));
1240 // Handle en passant moves
1241 if (is_enpassant(m))
1243 Square capQq = to - pawn_push(sideToMove);
1245 assert(!capturedType);
1246 assert(type_of(piece_on(capQq)) == PAWN);
1248 // Remove the captured pawn
1250 capturedType = PAWN;
1253 // Find all attackers to the destination square, with the moving piece
1254 // removed, but possibly an X-ray attacker added behind it.
1256 attackers = attackers_to(to, occ);
1258 // If the opponent has no attackers we are finished
1259 stm = ~color_of(piece_on(from));
1260 stmAttackers = attackers & pieces(stm);
1262 return PieceValueMidgame[capturedType];
1264 // The destination square is defended, which makes things rather more
1265 // difficult to compute. We proceed by building up a "swap list" containing
1266 // the material gain or loss at each stop in a sequence of captures to the
1267 // destination square, where the sides alternately capture, and always
1268 // capture with the least valuable piece. After each capture, we look for
1269 // new X-ray attacks from behind the capturing piece.
1270 swapList[0] = PieceValueMidgame[capturedType];
1271 capturedType = type_of(piece_on(from));
1274 // Locate the least valuable attacker for the side to move. The loop
1275 // below looks like it is potentially infinite, but it isn't. We know
1276 // that the side to move still has at least one attacker left.
1277 for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
1280 // Remove the attacker we just found from the 'occupied' bitboard,
1281 // and scan for new X-ray attacks behind the attacker.
1282 b = stmAttackers & pieces(pt);
1283 occ ^= (b & (~b + 1));
1284 attackers |= (attacks_bb<ROOK>(to, occ) & pieces(ROOK, QUEEN))
1285 | (attacks_bb<BISHOP>(to, occ) & pieces(BISHOP, QUEEN));
1287 attackers &= occ; // Cut out pieces we've already done
1289 // Add the new entry to the swap list
1290 assert(slIndex < 32);
1291 swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
1294 // Remember the value of the capturing piece, and change the side to
1295 // move before beginning the next iteration.
1298 stmAttackers = attackers & pieces(stm);
1300 // Stop before processing a king capture
1301 if (capturedType == KING && stmAttackers)
1303 assert(slIndex < 32);
1304 swapList[slIndex++] = QueenValueMidgame*10;
1307 } while (stmAttackers);
1309 // Having built the swap list, we negamax through it to find the best
1310 // achievable score from the point of view of the side to move.
1312 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1318 /// Position::clear() erases the position object to a pristine state, with an
1319 /// empty board, white to move, and no castling rights.
1321 void Position::clear() {
1323 memset(this, 0, sizeof(Position));
1324 startState.epSquare = SQ_NONE;
1327 for (int i = 0; i < 8; i++)
1328 for (int j = 0; j < 16; j++)
1329 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1331 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1332 board[sq] = NO_PIECE;
1336 /// Position::put_piece() puts a piece on the given square of the board,
1337 /// updating the board array, pieces list, bitboards, and piece counts.
1339 void Position::put_piece(Piece p, Square s) {
1341 Color c = color_of(p);
1342 PieceType pt = type_of(p);
1345 index[s] = pieceCount[c][pt]++;
1346 pieceList[c][pt][index[s]] = s;
1348 byTypeBB[ALL_PIECES] |= s;
1354 /// Position::compute_key() computes the hash key of the position. The hash
1355 /// key is usually updated incrementally as moves are made and unmade, the
1356 /// compute_key() function is only used when a new position is set up, and
1357 /// to verify the correctness of the hash key when running in debug mode.
1359 Key Position::compute_key() const {
1361 Key result = zobCastle[st->castleRights];
1363 for (Square s = SQ_A1; s <= SQ_H8; s++)
1364 if (!square_is_empty(s))
1365 result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
1367 if (ep_square() != SQ_NONE)
1368 result ^= zobEp[file_of(ep_square())];
1370 if (sideToMove == BLACK)
1371 result ^= zobSideToMove;
1377 /// Position::compute_pawn_key() computes the hash key of the position. The
1378 /// hash key is usually updated incrementally as moves are made and unmade,
1379 /// the compute_pawn_key() function is only used when a new position is set
1380 /// up, and to verify the correctness of the pawn hash key when running in
1383 Key Position::compute_pawn_key() const {
1388 for (Color c = WHITE; c <= BLACK; c++)
1390 b = pieces(PAWN, c);
1392 result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
1398 /// Position::compute_material_key() computes the hash key of the position.
1399 /// The hash key is usually updated incrementally as moves are made and unmade,
1400 /// the compute_material_key() function is only used when a new position is set
1401 /// up, and to verify the correctness of the material hash key when running in
1404 Key Position::compute_material_key() const {
1408 for (Color c = WHITE; c <= BLACK; c++)
1409 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1410 for (int i = 0; i < piece_count(c, pt); i++)
1411 result ^= zobrist[c][pt][i];
1417 /// Position::compute_value() compute the incremental scores for the middle
1418 /// game and the endgame. These functions are used to initialize the incremental
1419 /// scores when a new position is set up, and to verify that the scores are correctly
1420 /// updated by do_move and undo_move when the program is running in debug mode.
1421 Score Position::compute_value() const {
1424 Score result = SCORE_ZERO;
1426 for (Color c = WHITE; c <= BLACK; c++)
1427 for (PieceType pt = PAWN; pt <= KING; pt++)
1431 result += pst(make_piece(c, pt), pop_1st_bit(&b));
1434 result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2);
1439 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1440 /// game material value for the given side. Material values are updated
1441 /// incrementally during the search, this function is only used while
1442 /// initializing a new Position object.
1444 Value Position::compute_non_pawn_material(Color c) const {
1446 Value result = VALUE_ZERO;
1448 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1449 result += piece_count(c, pt) * PieceValueMidgame[pt];
1455 /// Position::is_draw() tests whether the position is drawn by material,
1456 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1457 /// must be done by the search.
1458 template<bool SkipRepetition>
1459 bool Position::is_draw() const {
1461 // Draw by material?
1463 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMidgame))
1466 // Draw by the 50 moves rule?
1467 if (st->rule50 > 99 && (!in_check() || MoveList<MV_LEGAL>(*this).size()))
1470 // Draw by repetition?
1471 if (!SkipRepetition)
1473 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1477 StateInfo* stp = st->previous->previous;
1480 stp = stp->previous->previous;
1482 if (stp->key == st->key)
1494 // Explicit template instantiations
1495 template bool Position::is_draw<false>() const;
1496 template bool Position::is_draw<true>() const;
1499 /// Position::init() is a static member function which initializes at startup
1500 /// the various arrays used to compute hash keys and the piece square tables.
1501 /// The latter is a two-step operation: First, the white halves of the tables
1502 /// are copied from PSQT[] tables. Second, the black halves of the tables are
1503 /// initialized by flipping and changing the sign of the white scores.
1505 void Position::init() {
1509 for (Color c = WHITE; c <= BLACK; c++)
1510 for (PieceType pt = PAWN; pt <= KING; pt++)
1511 for (Square s = SQ_A1; s <= SQ_H8; s++)
1512 zobrist[c][pt][s] = rk.rand<Key>();
1514 for (File f = FILE_A; f <= FILE_H; f++)
1515 zobEp[f] = rk.rand<Key>();
1517 for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
1522 Key k = zobCastle[1ULL << pop_1st_bit(&b)];
1523 zobCastle[cr] ^= k ? k : rk.rand<Key>();
1527 zobSideToMove = rk.rand<Key>();
1528 zobExclusion = rk.rand<Key>();
1530 for (Piece p = W_PAWN; p <= W_KING; p++)
1532 Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
1534 for (Square s = SQ_A1; s <= SQ_H8; s++)
1536 pieceSquareTable[p][s] = ps + PSQT[p][s];
1537 pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
1543 /// Position::flip_me() flips position with the white and black sides reversed. This
1544 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1546 void Position::flip_me() {
1548 // Make a copy of current position before to start changing
1549 const Position pos(*this, threadID);
1552 threadID = pos.thread();
1555 for (Square s = SQ_A1; s <= SQ_H8; s++)
1556 if (!pos.square_is_empty(s))
1557 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1560 sideToMove = ~pos.side_to_move();
1563 if (pos.can_castle(WHITE_OO))
1564 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
1565 if (pos.can_castle(WHITE_OOO))
1566 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
1567 if (pos.can_castle(BLACK_OO))
1568 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
1569 if (pos.can_castle(BLACK_OOO))
1570 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
1572 // En passant square
1573 if (pos.st->epSquare != SQ_NONE)
1574 st->epSquare = ~pos.st->epSquare;
1577 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1580 st->key = compute_key();
1581 st->pawnKey = compute_pawn_key();
1582 st->materialKey = compute_material_key();
1584 // Incremental scores
1585 st->value = compute_value();
1588 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1589 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1591 assert(pos_is_ok());
1595 /// Position::pos_is_ok() performs some consitency checks for the position object.
1596 /// This is meant to be helpful when debugging.
1598 bool Position::pos_is_ok(int* failedStep) const {
1600 // What features of the position should be verified?
1601 const bool debugAll = false;
1603 const bool debugBitboards = debugAll || false;
1604 const bool debugKingCount = debugAll || false;
1605 const bool debugKingCapture = debugAll || false;
1606 const bool debugCheckerCount = debugAll || false;
1607 const bool debugKey = debugAll || false;
1608 const bool debugMaterialKey = debugAll || false;
1609 const bool debugPawnKey = debugAll || false;
1610 const bool debugIncrementalEval = debugAll || false;
1611 const bool debugNonPawnMaterial = debugAll || false;
1612 const bool debugPieceCounts = debugAll || false;
1613 const bool debugPieceList = debugAll || false;
1614 const bool debugCastleSquares = debugAll || false;
1616 if (failedStep) *failedStep = 1;
1619 if (sideToMove != WHITE && sideToMove != BLACK)
1622 // Are the king squares in the position correct?
1623 if (failedStep) (*failedStep)++;
1624 if (piece_on(king_square(WHITE)) != W_KING)
1627 if (failedStep) (*failedStep)++;
1628 if (piece_on(king_square(BLACK)) != B_KING)
1631 // Do both sides have exactly one king?
1632 if (failedStep) (*failedStep)++;
1635 int kingCount[2] = {0, 0};
1636 for (Square s = SQ_A1; s <= SQ_H8; s++)
1637 if (type_of(piece_on(s)) == KING)
1638 kingCount[color_of(piece_on(s))]++;
1640 if (kingCount[0] != 1 || kingCount[1] != 1)
1644 // Can the side to move capture the opponent's king?
1645 if (failedStep) (*failedStep)++;
1646 if (debugKingCapture)
1648 Color us = sideToMove;
1650 Square ksq = king_square(them);
1651 if (attackers_to(ksq) & pieces(us))
1655 // Is there more than 2 checkers?
1656 if (failedStep) (*failedStep)++;
1657 if (debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1661 if (failedStep) (*failedStep)++;
1664 // The intersection of the white and black pieces must be empty
1665 if (pieces(WHITE) & pieces(BLACK))
1668 // The union of the white and black pieces must be equal to all
1670 if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1673 // Separate piece type bitboards must have empty intersections
1674 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1675 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1676 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1680 // En passant square OK?
1681 if (failedStep) (*failedStep)++;
1682 if (ep_square() != SQ_NONE)
1684 // The en passant square must be on rank 6, from the point of view of the
1686 if (relative_rank(sideToMove, ep_square()) != RANK_6)
1691 if (failedStep) (*failedStep)++;
1692 if (debugKey && st->key != compute_key())
1695 // Pawn hash key OK?
1696 if (failedStep) (*failedStep)++;
1697 if (debugPawnKey && st->pawnKey != compute_pawn_key())
1700 // Material hash key OK?
1701 if (failedStep) (*failedStep)++;
1702 if (debugMaterialKey && st->materialKey != compute_material_key())
1705 // Incremental eval OK?
1706 if (failedStep) (*failedStep)++;
1707 if (debugIncrementalEval && st->value != compute_value())
1710 // Non-pawn material OK?
1711 if (failedStep) (*failedStep)++;
1712 if (debugNonPawnMaterial)
1714 if (st->npMaterial[WHITE] != compute_non_pawn_material(WHITE))
1717 if (st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1722 if (failedStep) (*failedStep)++;
1723 if (debugPieceCounts)
1724 for (Color c = WHITE; c <= BLACK; c++)
1725 for (PieceType pt = PAWN; pt <= KING; pt++)
1726 if (pieceCount[c][pt] != popcount<Full>(pieces(pt, c)))
1729 if (failedStep) (*failedStep)++;
1731 for (Color c = WHITE; c <= BLACK; c++)
1732 for (PieceType pt = PAWN; pt <= KING; pt++)
1733 for (int i = 0; i < pieceCount[c][pt]; i++)
1735 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1738 if (index[piece_list(c, pt)[i]] != i)
1742 if (failedStep) (*failedStep)++;
1743 if (debugCastleSquares)
1744 for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1))
1749 Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
1751 if ( piece_on(castleRookSquare[f]) != rook
1752 || castleRightsMask[castleRookSquare[f]] != f)
1756 if (failedStep) *failedStep = 0;