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[64];
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 rsq) {
247 int f = (rsq < king_square(c) ? WHITE_OOO : WHITE_OO) << c;
249 st->castleRights |= f;
250 castleRightsMask[king_square(c)] ^= f;
251 castleRightsMask[rsq] ^= f;
252 castleRookSquare[f] = rsq;
256 /// Position::to_fen() returns a FEN representation of the position. In case
257 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
259 const string Position::to_fen() const {
261 std::ostringstream fen;
265 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
269 for (File file = FILE_A; file <= FILE_H; file++)
271 sq = make_square(file, rank);
273 if (square_is_empty(sq))
282 fen << PieceToChar[piece_on(sq)];
293 fen << (sideToMove == WHITE ? " w " : " b ");
295 if (can_castle(WHITE_OO))
296 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K');
298 if (can_castle(WHITE_OOO))
299 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q');
301 if (can_castle(BLACK_OO))
302 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k');
304 if (can_castle(BLACK_OOO))
305 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q');
307 if (st->castleRights == CASTLES_NONE)
310 fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
311 << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2;
317 /// Position::print() prints an ASCII representation of the position to
318 /// the standard output. If a move is given then also the san is printed.
320 void Position::print(Move move) const {
322 const char* dottedLine = "\n+---+---+---+---+---+---+---+---+\n";
326 Position p(*this, thread());
327 cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
330 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
332 cout << dottedLine << '|';
333 for (File file = FILE_A; file <= FILE_H; file++)
335 Square sq = make_square(file, rank);
336 Piece piece = piece_on(sq);
337 char c = (color_of(piece) == BLACK ? '=' : ' ');
339 if (piece == NO_PIECE && !opposite_colors(sq, SQ_A1))
340 piece++; // Index the dot
342 cout << c << PieceToChar[piece] << c << '|';
345 cout << dottedLine << "Fen is: " << to_fen() << "\nKey is: " << st->key << endl;
349 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
350 /// king) pieces for the given color. Or, when template parameter FindPinned is
351 /// false, the function return the pieces of the given color candidate for a
352 /// discovery check against the enemy king.
353 template<bool FindPinned>
354 Bitboard Position::hidden_checkers() const {
356 // Pinned pieces protect our king, dicovery checks attack the enemy king
357 Bitboard b, result = 0;
358 Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
359 Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
361 // Pinners are sliders, that give check when candidate pinned is removed
362 pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
363 | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
367 b = squares_between(ksq, pop_1st_bit(&pinners)) & occupied_squares();
369 // Only one bit set and is an our piece?
370 if (b && !(b & (b - 1)) && (b & pieces(sideToMove)))
376 // Explicit template instantiations
377 template Bitboard Position::hidden_checkers<true>() const;
378 template Bitboard Position::hidden_checkers<false>() const;
381 /// Position::attackers_to() computes a bitboard of all pieces which attack a
382 /// given square. Slider attacks use occ bitboard as occupancy.
384 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
386 return (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
387 | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
388 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
389 | (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN))
390 | (bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN))
391 | (attacks_from<KING>(s) & pieces(KING));
395 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
396 /// put in a given square. Slider attacks use occ bitboard as occupancy.
398 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
400 assert(square_is_ok(s));
404 case BISHOP: return bishop_attacks_bb(s, occ);
405 case ROOK : return rook_attacks_bb(s, occ);
406 case QUEEN : return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
407 default : return StepAttacksBB[p][s];
412 /// Position::move_attacks_square() tests whether a move from the current
413 /// position attacks a given square.
415 bool Position::move_attacks_square(Move m, Square s) const {
418 assert(square_is_ok(s));
421 Square from = from_sq(m);
422 Square to = to_sq(m);
423 Piece piece = piece_on(from);
425 assert(!square_is_empty(from));
427 // Update occupancy as if the piece is moving
428 occ = occupied_squares();
429 do_move_bb(&occ, make_move_bb(from, to));
431 // The piece moved in 'to' attacks the square 's' ?
432 if (bit_is_set(attacks_from(piece, to, occ), s))
435 // Scan for possible X-ray attackers behind the moved piece
436 xray = (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN, color_of(piece)))
437 |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
439 // Verify attackers are triggered by our move and not already existing
440 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
444 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
446 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
449 assert(pinned == pinned_pieces());
451 Color us = sideToMove;
452 Square from = from_sq(m);
454 assert(color_of(piece_on(from)) == us);
455 assert(piece_on(king_square(us)) == make_piece(us, KING));
457 // En passant captures are a tricky special case. Because they are rather
458 // uncommon, we do it simply by testing whether the king is attacked after
463 Square to = to_sq(m);
464 Square capsq = to + pawn_push(them);
465 Square ksq = king_square(us);
466 Bitboard b = occupied_squares();
468 assert(to == ep_square());
469 assert(piece_on(from) == make_piece(us, PAWN));
470 assert(piece_on(capsq) == make_piece(them, PAWN));
471 assert(piece_on(to) == NO_PIECE);
474 clear_bit(&b, capsq);
477 return !(rook_attacks_bb(ksq, b) & pieces(ROOK, QUEEN, them))
478 && !(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, them));
481 // If the moving piece is a king, check whether the destination
482 // square is attacked by the opponent. Castling moves are checked
483 // for legality during move generation.
484 if (type_of(piece_on(from)) == KING)
485 return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
487 // A non-king move is legal if and only if it is not pinned or it
488 // is moving along the ray towards or away from the king.
490 || !bit_is_set(pinned, from)
491 || squares_aligned(from, to_sq(m), king_square(us));
495 /// Position::move_is_legal() takes a random move and tests whether the move
496 /// is legal. This version is not very fast and should be used only in non
497 /// time-critical paths.
499 bool Position::move_is_legal(const Move m) const {
501 for (MoveList<MV_LEGAL> ml(*this); !ml.end(); ++ml)
509 /// Position::is_pseudo_legal() takes a random move and tests whether the move
510 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
511 /// due to SMP concurrent access or hash position key aliasing.
513 bool Position::is_pseudo_legal(const Move m) const {
515 Color us = sideToMove;
516 Color them = ~sideToMove;
517 Square from = from_sq(m);
518 Square to = to_sq(m);
519 Piece pc = piece_on(from);
521 // Use a slower but simpler function for uncommon cases
523 return move_is_legal(m);
525 // Is not a promotion, so promotion piece must be empty
526 if (promotion_piece_type(m) - 2 != NO_PIECE_TYPE)
529 // If the from square is not occupied by a piece belonging to the side to
530 // move, the move is obviously not legal.
531 if (pc == NO_PIECE || color_of(pc) != us)
534 // The destination square cannot be occupied by a friendly piece
535 if (color_of(piece_on(to)) == us)
538 // Handle the special case of a pawn move
539 if (type_of(pc) == PAWN)
541 // Move direction must be compatible with pawn color
542 int direction = to - from;
543 if ((us == WHITE) != (direction > 0))
546 // We have already handled promotion moves, so destination
547 // cannot be on the 8/1th rank.
548 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
551 // Proceed according to the square delta between the origin and
552 // destination squares.
559 // Capture. The destination square must be occupied by an enemy
560 // piece (en passant captures was handled earlier).
561 if (color_of(piece_on(to)) != them)
564 // From and to files must be one file apart, avoids a7h5
565 if (abs(file_of(from) - file_of(to)) != 1)
571 // Pawn push. The destination square must be empty.
572 if (!square_is_empty(to))
577 // Double white pawn push. The destination square must be on the fourth
578 // rank, and both the destination square and the square between the
579 // source and destination squares must be empty.
580 if ( rank_of(to) != RANK_4
581 || !square_is_empty(to)
582 || !square_is_empty(from + DELTA_N))
587 // Double black pawn push. The destination square must be on the fifth
588 // rank, and both the destination square and the square between the
589 // source and destination squares must be empty.
590 if ( rank_of(to) != RANK_5
591 || !square_is_empty(to)
592 || !square_is_empty(from + DELTA_S))
600 else if (!bit_is_set(attacks_from(pc, from), to))
603 // Evasions generator already takes care to avoid some kind of illegal moves
604 // and pl_move_is_legal() relies on this. So we have to take care that the
605 // same kind of moves are filtered out here.
608 // In case of king moves under check we have to remove king so to catch
609 // as invalid moves like b1a1 when opposite queen is on c1.
610 if (type_of(piece_on(from)) == KING)
612 Bitboard b = occupied_squares();
614 if (attackers_to(to_sq(m), b) & pieces(~us))
619 Bitboard target = checkers();
620 Square checksq = pop_1st_bit(&target);
622 if (target) // double check ? In this case a king move is required
625 // Our move must be a blocking evasion or a capture of the checking piece
626 target = squares_between(checksq, king_square(us)) | checkers();
627 if (!bit_is_set(target, to_sq(m)))
636 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
638 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
641 assert(ci.dcCandidates == discovered_check_candidates());
642 assert(color_of(piece_moved(m)) == sideToMove);
644 Square from = from_sq(m);
645 Square to = to_sq(m);
646 PieceType pt = type_of(piece_on(from));
649 if (bit_is_set(ci.checkSq[pt], to))
653 if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
655 // For pawn and king moves we need to verify also direction
656 if ( (pt != PAWN && pt != KING)
657 || !squares_aligned(from, to, king_square(~sideToMove)))
661 // Can we skip the ugly special cases ?
665 Color us = sideToMove;
666 Bitboard b = occupied_squares();
667 Square ksq = king_square(~us);
669 // Promotion with check ?
673 return bit_is_set(attacks_from(Piece(promotion_piece_type(m)), to, b), ksq);
676 // En passant capture with check ? We have already handled the case
677 // of direct checks and ordinary discovered check, the only case we
678 // need to handle is the unusual case of a discovered check through
679 // the captured pawn.
682 Square capsq = make_square(file_of(to), rank_of(from));
684 clear_bit(&b, capsq);
686 return (rook_attacks_bb(ksq, b) & pieces(ROOK, QUEEN, us))
687 ||(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, us));
690 // Castling with check ?
693 Square kfrom, kto, rfrom, rto;
699 kto = relative_square(us, SQ_G1);
700 rto = relative_square(us, SQ_F1);
702 kto = relative_square(us, SQ_C1);
703 rto = relative_square(us, SQ_D1);
705 clear_bit(&b, kfrom);
706 clear_bit(&b, rfrom);
709 return bit_is_set(rook_attacks_bb(rto, b), ksq);
716 /// Position::do_move() makes a move, and saves all information necessary
717 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
718 /// moves should be filtered out before this function is called.
720 void Position::do_move(Move m, StateInfo& newSt) {
723 do_move(m, newSt, ci, move_gives_check(m, ci));
726 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
729 assert(&newSt != st);
734 // Copy some fields of old state to our new StateInfo object except the ones
735 // which are recalculated from scratch anyway, then switch our state pointer
736 // to point to the new, ready to be updated, state.
737 struct ReducedStateInfo {
738 Key pawnKey, materialKey;
740 int castleRights, rule50, pliesFromNull;
745 memcpy(&newSt, st, sizeof(ReducedStateInfo));
750 // Update side to move
753 // Increment the 50 moves rule draw counter. Resetting it to zero in the
754 // case of non-reversible moves is taken care of later.
761 do_castle_move<true>(m);
765 Color us = sideToMove;
767 Square from = from_sq(m);
768 Square to = to_sq(m);
769 Piece piece = piece_on(from);
770 PieceType pt = type_of(piece);
771 PieceType capture = is_enpassant(m) ? PAWN : type_of(piece_on(to));
773 assert(color_of(piece) == us);
774 assert(color_of(piece_on(to)) != us);
775 assert(capture != KING);
781 // If the captured piece is a pawn, update pawn hash key, otherwise
782 // update non-pawn material.
787 capsq += pawn_push(them);
790 assert(to == st->epSquare);
791 assert(relative_rank(us, to) == RANK_6);
792 assert(piece_on(to) == NO_PIECE);
793 assert(piece_on(capsq) == make_piece(them, PAWN));
795 board[capsq] = NO_PIECE;
798 st->pawnKey ^= zobrist[them][PAWN][capsq];
801 st->npMaterial[them] -= PieceValueMidgame[capture];
803 // Remove the captured piece
804 clear_bit(&byColorBB[them], capsq);
805 clear_bit(&byTypeBB[capture], capsq);
806 clear_bit(&occupied, capsq);
808 // Update piece list, move the last piece at index[capsq] position and
811 // WARNING: This is a not revresible operation. When we will reinsert the
812 // captured piece in undo_move() we will put it at the end of the list and
813 // not in its original place, it means index[] and pieceList[] are not
814 // guaranteed to be invariant to a do_move() + undo_move() sequence.
815 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
816 index[lastSquare] = index[capsq];
817 pieceList[them][capture][index[lastSquare]] = lastSquare;
818 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
821 k ^= zobrist[them][capture][capsq];
822 st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
824 // Update incremental scores
825 st->value -= pst(make_piece(them, capture), capsq);
827 // Reset rule 50 counter
832 k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
834 // Reset en passant square
835 if (st->epSquare != SQ_NONE)
837 k ^= zobEp[st->epSquare];
838 st->epSquare = SQ_NONE;
841 // Update castle rights if needed
842 if ( st->castleRights != CASTLES_NONE
843 && (castleRightsMask[from] & castleRightsMask[to]) != ALL_CASTLES)
845 k ^= zobCastle[st->castleRights];
846 st->castleRights &= castleRightsMask[from] & castleRightsMask[to];
847 k ^= zobCastle[st->castleRights];
850 // Prefetch TT access as soon as we know key is updated
851 prefetch((char*)TT.first_entry(k));
854 Bitboard move_bb = make_move_bb(from, to);
855 do_move_bb(&byColorBB[us], move_bb);
856 do_move_bb(&byTypeBB[pt], move_bb);
857 do_move_bb(&occupied, move_bb);
859 board[to] = board[from];
860 board[from] = NO_PIECE;
862 // Update piece lists, index[from] is not updated and becomes stale. This
863 // works as long as index[] is accessed just by known occupied squares.
864 index[to] = index[from];
865 pieceList[us][pt][index[to]] = to;
867 // If the moving piece is a pawn do some special extra work
870 // Set en-passant square, only if moved pawn can be captured
871 if ( (to ^ from) == 16
872 && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(PAWN, them)))
874 st->epSquare = Square((from + to) / 2);
875 k ^= zobEp[st->epSquare];
880 PieceType promotion = promotion_piece_type(m);
882 assert(relative_rank(us, to) == RANK_8);
883 assert(promotion >= KNIGHT && promotion <= QUEEN);
885 // Replace the pawn with the promoted piece
886 clear_bit(&byTypeBB[PAWN], to);
887 set_bit(&byTypeBB[promotion], to);
888 board[to] = make_piece(us, promotion);
890 // Update piece lists, move the last pawn at index[to] position
891 // and shrink the list. Add a new promotion piece to the list.
892 Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
893 index[lastSquare] = index[to];
894 pieceList[us][PAWN][index[lastSquare]] = lastSquare;
895 pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
896 index[to] = pieceCount[us][promotion];
897 pieceList[us][promotion][index[to]] = to;
900 k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
901 st->pawnKey ^= zobrist[us][PAWN][to];
902 st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]++]
903 ^ zobrist[us][PAWN][pieceCount[us][PAWN]];
905 // Update incremental score
906 st->value += pst(make_piece(us, promotion), to)
907 - pst(make_piece(us, PAWN), to);
910 st->npMaterial[us] += PieceValueMidgame[promotion];
913 // Update pawn hash key
914 st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
916 // Reset rule 50 draw counter
920 // Prefetch pawn and material hash tables
921 Threads[threadID].pawnTable.prefetch(st->pawnKey);
922 Threads[threadID].materialTable.prefetch(st->materialKey);
924 // Update incremental scores
925 st->value += pst_delta(piece, from, to);
928 st->capturedType = capture;
930 // Update the key with the final value
933 // Update checkers bitboard, piece must be already moved
939 st->checkersBB = attackers_to(king_square(them)) & pieces(us);
943 if (bit_is_set(ci.checkSq[pt], to))
944 st->checkersBB = SetMaskBB[to];
947 if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
950 st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(ROOK, QUEEN, us);
953 st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(BISHOP, QUEEN, us);
959 sideToMove = ~sideToMove;
960 st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
966 /// Position::undo_move() unmakes a move. When it returns, the position should
967 /// be restored to exactly the same state as before the move was made.
969 void Position::undo_move(Move m) {
973 sideToMove = ~sideToMove;
977 do_castle_move<false>(m);
981 Color us = sideToMove;
983 Square from = from_sq(m);
984 Square to = to_sq(m);
985 Piece piece = piece_on(to);
986 PieceType pt = type_of(piece);
987 PieceType capture = st->capturedType;
989 assert(square_is_empty(from));
990 assert(color_of(piece) == us);
991 assert(capture != KING);
995 PieceType promotion = promotion_piece_type(m);
997 assert(promotion == pt);
998 assert(relative_rank(us, to) == RANK_8);
999 assert(promotion >= KNIGHT && promotion <= QUEEN);
1001 // Replace the promoted piece with the pawn
1002 clear_bit(&byTypeBB[promotion], to);
1003 set_bit(&byTypeBB[PAWN], to);
1004 board[to] = make_piece(us, PAWN);
1006 // Update piece lists, move the last promoted piece at index[to] position
1007 // and shrink the list. Add a new pawn to the list.
1008 Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
1009 index[lastSquare] = index[to];
1010 pieceList[us][promotion][index[lastSquare]] = lastSquare;
1011 pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
1012 index[to] = pieceCount[us][PAWN]++;
1013 pieceList[us][PAWN][index[to]] = to;
1018 // Put the piece back at the source square
1019 Bitboard move_bb = make_move_bb(to, from);
1020 do_move_bb(&byColorBB[us], move_bb);
1021 do_move_bb(&byTypeBB[pt], move_bb);
1022 do_move_bb(&occupied, move_bb);
1024 board[from] = board[to];
1025 board[to] = NO_PIECE;
1027 // Update piece lists, index[to] is not updated and becomes stale. This
1028 // works as long as index[] is accessed just by known occupied squares.
1029 index[from] = index[to];
1030 pieceList[us][pt][index[from]] = from;
1036 if (is_enpassant(m))
1038 capsq -= pawn_push(us);
1041 assert(to == st->previous->epSquare);
1042 assert(relative_rank(us, to) == RANK_6);
1043 assert(piece_on(capsq) == NO_PIECE);
1046 // Restore the captured piece
1047 set_bit(&byColorBB[them], capsq);
1048 set_bit(&byTypeBB[capture], capsq);
1049 set_bit(&occupied, capsq);
1051 board[capsq] = make_piece(them, capture);
1053 // Update piece list, add a new captured piece in capsq square
1054 index[capsq] = pieceCount[them][capture]++;
1055 pieceList[them][capture][index[capsq]] = capsq;
1058 // Finally point our state pointer back to the previous state
1061 assert(pos_is_ok());
1065 /// Position::do_castle_move() is a private method used to do/undo a castling
1066 /// move. Note that castling moves are encoded as "king captures friendly rook"
1067 /// moves, for instance white short castling in a non-Chess960 game is encoded
1070 void Position::do_castle_move(Move m) {
1073 assert(is_castle(m));
1075 Square kto, kfrom, rfrom, rto, kAfter, rAfter;
1077 Color us = sideToMove;
1078 Square kBefore = from_sq(m);
1079 Square rBefore = to_sq(m);
1081 // Find after-castle squares for king and rook
1082 if (rBefore > kBefore) // O-O
1084 kAfter = relative_square(us, SQ_G1);
1085 rAfter = relative_square(us, SQ_F1);
1089 kAfter = relative_square(us, SQ_C1);
1090 rAfter = relative_square(us, SQ_D1);
1093 kfrom = Do ? kBefore : kAfter;
1094 rfrom = Do ? rBefore : rAfter;
1096 kto = Do ? kAfter : kBefore;
1097 rto = Do ? rAfter : rBefore;
1099 assert(piece_on(kfrom) == make_piece(us, KING));
1100 assert(piece_on(rfrom) == make_piece(us, ROOK));
1102 // Remove pieces from source squares
1103 clear_bit(&byColorBB[us], kfrom);
1104 clear_bit(&byTypeBB[KING], kfrom);
1105 clear_bit(&occupied, kfrom);
1106 clear_bit(&byColorBB[us], rfrom);
1107 clear_bit(&byTypeBB[ROOK], rfrom);
1108 clear_bit(&occupied, rfrom);
1110 // Put pieces on destination squares
1111 set_bit(&byColorBB[us], kto);
1112 set_bit(&byTypeBB[KING], kto);
1113 set_bit(&occupied, kto);
1114 set_bit(&byColorBB[us], rto);
1115 set_bit(&byTypeBB[ROOK], rto);
1116 set_bit(&occupied, rto);
1119 Piece king = make_piece(us, KING);
1120 Piece rook = make_piece(us, ROOK);
1121 board[kfrom] = board[rfrom] = NO_PIECE;
1125 // Update piece lists
1126 pieceList[us][KING][index[kfrom]] = kto;
1127 pieceList[us][ROOK][index[rfrom]] = rto;
1128 int tmp = index[rfrom]; // In Chess960 could be kto == rfrom
1129 index[kto] = index[kfrom];
1134 // Reset capture field
1135 st->capturedType = NO_PIECE_TYPE;
1137 // Update incremental scores
1138 st->value += pst_delta(king, kfrom, kto);
1139 st->value += pst_delta(rook, rfrom, rto);
1142 st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
1143 st->key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto];
1145 // Clear en passant square
1146 if (st->epSquare != SQ_NONE)
1148 st->key ^= zobEp[st->epSquare];
1149 st->epSquare = SQ_NONE;
1152 // Update castling rights
1153 st->key ^= zobCastle[st->castleRights];
1154 st->castleRights &= castleRightsMask[kfrom];
1155 st->key ^= zobCastle[st->castleRights];
1157 // Reset rule 50 counter
1160 // Update checkers BB
1161 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1164 sideToMove = ~sideToMove;
1165 st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
1168 // Undo: point our state pointer back to the previous state
1171 assert(pos_is_ok());
1175 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1176 /// to move and updates the hash key without executing any move on the board.
1178 void Position::do_null_move(StateInfo& backupSt) {
1180 assert(!in_check());
1182 // Back up the information necessary to undo the null move to the supplied
1183 // StateInfo object. Note that differently from normal case here backupSt
1184 // is actually used as a backup storage not as the new state. This reduces
1185 // the number of fields to be copied.
1186 StateInfo* src = Do ? st : &backupSt;
1187 StateInfo* dst = Do ? &backupSt : st;
1189 dst->key = src->key;
1190 dst->epSquare = src->epSquare;
1191 dst->value = src->value;
1192 dst->rule50 = src->rule50;
1193 dst->pliesFromNull = src->pliesFromNull;
1195 sideToMove = ~sideToMove;
1199 if (st->epSquare != SQ_NONE)
1200 st->key ^= zobEp[st->epSquare];
1202 st->key ^= zobSideToMove;
1203 prefetch((char*)TT.first_entry(st->key));
1205 st->epSquare = SQ_NONE;
1207 st->pliesFromNull = 0;
1208 st->value += (sideToMove == WHITE) ? TempoValue : -TempoValue;
1211 assert(pos_is_ok());
1214 // Explicit template instantiations
1215 template void Position::do_null_move<false>(StateInfo& backupSt);
1216 template void Position::do_null_move<true>(StateInfo& backupSt);
1219 /// Position::see() is a static exchange evaluator: It tries to estimate the
1220 /// material gain or loss resulting from a move. There are three versions of
1221 /// this function: One which takes a destination square as input, one takes a
1222 /// move, and one which takes a 'from' and a 'to' square. The function does
1223 /// not yet understand promotions captures.
1225 int Position::see_sign(Move m) const {
1229 Square from = from_sq(m);
1230 Square to = to_sq(m);
1232 // Early return if SEE cannot be negative because captured piece value
1233 // is not less then capturing one. Note that king moves always return
1234 // here because king midgame value is set to 0.
1235 if (PieceValueMidgame[piece_on(to)] >= PieceValueMidgame[piece_on(from)])
1241 int Position::see(Move m) const {
1244 Bitboard occ, attackers, stmAttackers, b;
1245 int swapList[32], slIndex = 1;
1246 PieceType capturedType, pt;
1251 // As castle moves are implemented as capturing the rook, they have
1252 // SEE == RookValueMidgame most of the times (unless the rook is under
1259 capturedType = type_of(piece_on(to));
1260 occ = occupied_squares();
1262 // Handle en passant moves
1263 if (is_enpassant(m))
1265 Square capQq = to - pawn_push(sideToMove);
1267 assert(!capturedType);
1268 assert(type_of(piece_on(capQq)) == PAWN);
1270 // Remove the captured pawn
1271 clear_bit(&occ, capQq);
1272 capturedType = PAWN;
1275 // Find all attackers to the destination square, with the moving piece
1276 // removed, but possibly an X-ray attacker added behind it.
1277 clear_bit(&occ, from);
1278 attackers = attackers_to(to, occ);
1280 // If the opponent has no attackers we are finished
1281 stm = ~color_of(piece_on(from));
1282 stmAttackers = attackers & pieces(stm);
1284 return PieceValueMidgame[capturedType];
1286 // The destination square is defended, which makes things rather more
1287 // difficult to compute. We proceed by building up a "swap list" containing
1288 // the material gain or loss at each stop in a sequence of captures to the
1289 // destination square, where the sides alternately capture, and always
1290 // capture with the least valuable piece. After each capture, we look for
1291 // new X-ray attacks from behind the capturing piece.
1292 swapList[0] = PieceValueMidgame[capturedType];
1293 capturedType = type_of(piece_on(from));
1296 // Locate the least valuable attacker for the side to move. The loop
1297 // below looks like it is potentially infinite, but it isn't. We know
1298 // that the side to move still has at least one attacker left.
1299 for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
1302 // Remove the attacker we just found from the 'occupied' bitboard,
1303 // and scan for new X-ray attacks behind the attacker.
1304 b = stmAttackers & pieces(pt);
1305 occ ^= (b & (~b + 1));
1306 attackers |= (rook_attacks_bb(to, occ) & pieces(ROOK, QUEEN))
1307 | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN));
1309 attackers &= occ; // Cut out pieces we've already done
1311 // Add the new entry to the swap list
1312 assert(slIndex < 32);
1313 swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
1316 // Remember the value of the capturing piece, and change the side to
1317 // move before beginning the next iteration.
1320 stmAttackers = attackers & pieces(stm);
1322 // Stop before processing a king capture
1323 if (capturedType == KING && stmAttackers)
1325 assert(slIndex < 32);
1326 swapList[slIndex++] = QueenValueMidgame*10;
1329 } while (stmAttackers);
1331 // Having built the swap list, we negamax through it to find the best
1332 // achievable score from the point of view of the side to move.
1334 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1340 /// Position::clear() erases the position object to a pristine state, with an
1341 /// empty board, white to move, and no castling rights.
1343 void Position::clear() {
1346 memset(st, 0, sizeof(StateInfo));
1347 st->epSquare = SQ_NONE;
1349 memset(byColorBB, 0, sizeof(Bitboard) * 2);
1350 memset(byTypeBB, 0, sizeof(Bitboard) * 8);
1351 memset(pieceCount, 0, sizeof(int) * 2 * 8);
1352 memset(index, 0, sizeof(int) * 64);
1354 for (int i = 0; i < 8; i++)
1355 for (int j = 0; j < 16; j++)
1356 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1358 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1360 board[sq] = NO_PIECE;
1361 castleRightsMask[sq] = ALL_CASTLES;
1369 /// Position::put_piece() puts a piece on the given square of the board,
1370 /// updating the board array, pieces list, bitboards, and piece counts.
1372 void Position::put_piece(Piece p, Square s) {
1374 Color c = color_of(p);
1375 PieceType pt = type_of(p);
1378 index[s] = pieceCount[c][pt]++;
1379 pieceList[c][pt][index[s]] = s;
1381 set_bit(&byTypeBB[pt], s);
1382 set_bit(&byColorBB[c], s);
1383 set_bit(&occupied, s);
1387 /// Position::compute_key() computes the hash key of the position. The hash
1388 /// key is usually updated incrementally as moves are made and unmade, the
1389 /// compute_key() function is only used when a new position is set up, and
1390 /// to verify the correctness of the hash key when running in debug mode.
1392 Key Position::compute_key() const {
1394 Key result = zobCastle[st->castleRights];
1396 for (Square s = SQ_A1; s <= SQ_H8; s++)
1397 if (!square_is_empty(s))
1398 result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
1400 if (ep_square() != SQ_NONE)
1401 result ^= zobEp[ep_square()];
1403 if (sideToMove == BLACK)
1404 result ^= zobSideToMove;
1410 /// Position::compute_pawn_key() computes the hash key of the position. The
1411 /// hash key is usually updated incrementally as moves are made and unmade,
1412 /// the compute_pawn_key() function is only used when a new position is set
1413 /// up, and to verify the correctness of the pawn hash key when running in
1416 Key Position::compute_pawn_key() const {
1421 for (Color c = WHITE; c <= BLACK; c++)
1423 b = pieces(PAWN, c);
1425 result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
1431 /// Position::compute_material_key() computes the hash key of the position.
1432 /// The hash key is usually updated incrementally as moves are made and unmade,
1433 /// the compute_material_key() function is only used when a new position is set
1434 /// up, and to verify the correctness of the material hash key when running in
1437 Key Position::compute_material_key() const {
1441 for (Color c = WHITE; c <= BLACK; c++)
1442 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1443 for (int i = 0; i < piece_count(c, pt); i++)
1444 result ^= zobrist[c][pt][i];
1450 /// Position::compute_value() compute the incremental scores for the middle
1451 /// game and the endgame. These functions are used to initialize the incremental
1452 /// scores when a new position is set up, and to verify that the scores are correctly
1453 /// updated by do_move and undo_move when the program is running in debug mode.
1454 Score Position::compute_value() const {
1457 Score result = SCORE_ZERO;
1459 for (Color c = WHITE; c <= BLACK; c++)
1460 for (PieceType pt = PAWN; pt <= KING; pt++)
1464 result += pst(make_piece(c, pt), pop_1st_bit(&b));
1467 result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2);
1472 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1473 /// game material value for the given side. Material values are updated
1474 /// incrementally during the search, this function is only used while
1475 /// initializing a new Position object.
1477 Value Position::compute_non_pawn_material(Color c) const {
1479 Value result = VALUE_ZERO;
1481 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1482 result += piece_count(c, pt) * PieceValueMidgame[pt];
1488 /// Position::is_draw() tests whether the position is drawn by material,
1489 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1490 /// must be done by the search.
1491 template<bool SkipRepetition>
1492 bool Position::is_draw() const {
1494 // Draw by material?
1496 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMidgame))
1499 // Draw by the 50 moves rule?
1500 if (st->rule50 > 99 && (!in_check() || MoveList<MV_LEGAL>(*this).size()))
1503 // Draw by repetition?
1504 if (!SkipRepetition)
1506 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1510 StateInfo* stp = st->previous->previous;
1513 stp = stp->previous->previous;
1515 if (stp->key == st->key)
1527 // Explicit template instantiations
1528 template bool Position::is_draw<false>() const;
1529 template bool Position::is_draw<true>() const;
1532 /// Position::init() is a static member function which initializes at startup
1533 /// the various arrays used to compute hash keys and the piece square tables.
1534 /// The latter is a two-step operation: First, the white halves of the tables
1535 /// are copied from PSQT[] tables. Second, the black halves of the tables are
1536 /// initialized by flipping and changing the sign of the white scores.
1538 void Position::init() {
1542 for (Color c = WHITE; c <= BLACK; c++)
1543 for (PieceType pt = PAWN; pt <= KING; pt++)
1544 for (Square s = SQ_A1; s <= SQ_H8; s++)
1545 zobrist[c][pt][s] = rk.rand<Key>();
1547 for (Square s = SQ_A1; s <= SQ_H8; s++)
1548 zobEp[s] = rk.rand<Key>();
1550 for (int i = 0; i < 16; i++)
1551 zobCastle[i] = rk.rand<Key>();
1553 zobSideToMove = rk.rand<Key>();
1554 zobExclusion = rk.rand<Key>();
1556 for (Piece p = W_PAWN; p <= W_KING; p++)
1558 Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
1560 for (Square s = SQ_A1; s <= SQ_H8; s++)
1562 pieceSquareTable[p][s] = ps + PSQT[p][s];
1563 pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
1569 /// Position::flip_me() flips position with the white and black sides reversed. This
1570 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1572 void Position::flip_me() {
1574 // Make a copy of current position before to start changing
1575 const Position pos(*this, threadID);
1578 threadID = pos.thread();
1581 for (Square s = SQ_A1; s <= SQ_H8; s++)
1582 if (!pos.square_is_empty(s))
1583 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1586 sideToMove = ~pos.side_to_move();
1589 if (pos.can_castle(WHITE_OO))
1590 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
1591 if (pos.can_castle(WHITE_OOO))
1592 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
1593 if (pos.can_castle(BLACK_OO))
1594 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
1595 if (pos.can_castle(BLACK_OOO))
1596 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
1598 // En passant square
1599 if (pos.st->epSquare != SQ_NONE)
1600 st->epSquare = ~pos.st->epSquare;
1603 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1606 st->key = compute_key();
1607 st->pawnKey = compute_pawn_key();
1608 st->materialKey = compute_material_key();
1610 // Incremental scores
1611 st->value = compute_value();
1614 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1615 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1617 assert(pos_is_ok());
1621 /// Position::pos_is_ok() performs some consitency checks for the position object.
1622 /// This is meant to be helpful when debugging.
1624 bool Position::pos_is_ok(int* failedStep) const {
1626 // What features of the position should be verified?
1627 const bool debugAll = false;
1629 const bool debugBitboards = debugAll || false;
1630 const bool debugKingCount = debugAll || false;
1631 const bool debugKingCapture = debugAll || false;
1632 const bool debugCheckerCount = debugAll || false;
1633 const bool debugKey = debugAll || false;
1634 const bool debugMaterialKey = debugAll || false;
1635 const bool debugPawnKey = debugAll || false;
1636 const bool debugIncrementalEval = debugAll || false;
1637 const bool debugNonPawnMaterial = debugAll || false;
1638 const bool debugPieceCounts = debugAll || false;
1639 const bool debugPieceList = debugAll || false;
1640 const bool debugCastleSquares = debugAll || false;
1642 if (failedStep) *failedStep = 1;
1645 if (sideToMove != WHITE && sideToMove != BLACK)
1648 // Are the king squares in the position correct?
1649 if (failedStep) (*failedStep)++;
1650 if (piece_on(king_square(WHITE)) != W_KING)
1653 if (failedStep) (*failedStep)++;
1654 if (piece_on(king_square(BLACK)) != B_KING)
1657 // Do both sides have exactly one king?
1658 if (failedStep) (*failedStep)++;
1661 int kingCount[2] = {0, 0};
1662 for (Square s = SQ_A1; s <= SQ_H8; s++)
1663 if (type_of(piece_on(s)) == KING)
1664 kingCount[color_of(piece_on(s))]++;
1666 if (kingCount[0] != 1 || kingCount[1] != 1)
1670 // Can the side to move capture the opponent's king?
1671 if (failedStep) (*failedStep)++;
1672 if (debugKingCapture)
1674 Color us = sideToMove;
1676 Square ksq = king_square(them);
1677 if (attackers_to(ksq) & pieces(us))
1681 // Is there more than 2 checkers?
1682 if (failedStep) (*failedStep)++;
1683 if (debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1687 if (failedStep) (*failedStep)++;
1690 // The intersection of the white and black pieces must be empty
1691 if (!(pieces(WHITE) & pieces(BLACK)))
1694 // The union of the white and black pieces must be equal to all
1696 if ((pieces(WHITE) | pieces(BLACK)) != occupied_squares())
1699 // Separate piece type bitboards must have empty intersections
1700 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1701 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1702 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1706 // En passant square OK?
1707 if (failedStep) (*failedStep)++;
1708 if (ep_square() != SQ_NONE)
1710 // The en passant square must be on rank 6, from the point of view of the
1712 if (relative_rank(sideToMove, ep_square()) != RANK_6)
1717 if (failedStep) (*failedStep)++;
1718 if (debugKey && st->key != compute_key())
1721 // Pawn hash key OK?
1722 if (failedStep) (*failedStep)++;
1723 if (debugPawnKey && st->pawnKey != compute_pawn_key())
1726 // Material hash key OK?
1727 if (failedStep) (*failedStep)++;
1728 if (debugMaterialKey && st->materialKey != compute_material_key())
1731 // Incremental eval OK?
1732 if (failedStep) (*failedStep)++;
1733 if (debugIncrementalEval && st->value != compute_value())
1736 // Non-pawn material OK?
1737 if (failedStep) (*failedStep)++;
1738 if (debugNonPawnMaterial)
1740 if (st->npMaterial[WHITE] != compute_non_pawn_material(WHITE))
1743 if (st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1748 if (failedStep) (*failedStep)++;
1749 if (debugPieceCounts)
1750 for (Color c = WHITE; c <= BLACK; c++)
1751 for (PieceType pt = PAWN; pt <= KING; pt++)
1752 if (pieceCount[c][pt] != popcount<Full>(pieces(pt, c)))
1755 if (failedStep) (*failedStep)++;
1757 for (Color c = WHITE; c <= BLACK; c++)
1758 for (PieceType pt = PAWN; pt <= KING; pt++)
1759 for (int i = 0; i < pieceCount[c][pt]; i++)
1761 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1764 if (index[piece_list(c, pt)[i]] != i)
1768 if (failedStep) (*failedStep)++;
1769 if (debugCastleSquares)
1770 for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1))
1775 Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
1777 if ( castleRightsMask[castleRookSquare[f]] != (ALL_CASTLES ^ f)
1778 || piece_on(castleRookSquare[f]) != rook)
1782 if (failedStep) *failedStep = 0;