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 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 | (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN))
390 | (attacks_bb<BISHOP>(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 attacks_bb<BISHOP>(s, occ);
405 case ROOK : return attacks_bb<ROOK>(s, occ);
406 case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(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_moved(m);
425 assert(!square_is_empty(from));
427 // Update occupancy as if the piece is moving
428 occ = occupied_squares();
432 // The piece moved in 'to' attacks the square 's' ?
433 if (attacks_from(piece, to, occ) & s)
436 // Scan for possible X-ray attackers behind the moved piece
437 xray = (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN, color_of(piece)))
438 |(attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
440 // Verify attackers are triggered by our move and not already existing
441 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
445 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
447 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
450 assert(pinned == pinned_pieces());
452 Color us = sideToMove;
453 Square from = from_sq(m);
455 assert(color_of(piece_moved(m)) == us);
456 assert(piece_on(king_square(us)) == make_piece(us, KING));
458 // En passant captures are a tricky special case. Because they are rather
459 // uncommon, we do it simply by testing whether the king is attacked after
464 Square to = to_sq(m);
465 Square capsq = to + pawn_push(them);
466 Square ksq = king_square(us);
467 Bitboard b = occupied_squares();
469 assert(to == ep_square());
470 assert(piece_moved(m) == make_piece(us, PAWN));
471 assert(piece_on(capsq) == make_piece(them, PAWN));
472 assert(piece_on(to) == NO_PIECE);
478 return !(attacks_bb<ROOK>(ksq, b) & pieces(ROOK, QUEEN, them))
479 && !(attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, them));
482 // If the moving piece is a king, check whether the destination
483 // square is attacked by the opponent. Castling moves are checked
484 // for legality during move generation.
485 if (type_of(piece_on(from)) == KING)
486 return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
488 // A non-king move is legal if and only if it is not pinned or it
489 // is moving along the ray towards or away from the king.
492 || squares_aligned(from, to_sq(m), king_square(us));
496 /// Position::move_is_legal() takes a random move and tests whether the move
497 /// is legal. This version is not very fast and should be used only in non
498 /// time-critical paths.
500 bool Position::move_is_legal(const Move m) const {
502 for (MoveList<MV_LEGAL> ml(*this); !ml.end(); ++ml)
510 /// Position::is_pseudo_legal() takes a random move and tests whether the move
511 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
512 /// due to SMP concurrent access or hash position key aliasing.
514 bool Position::is_pseudo_legal(const Move m) const {
516 Color us = sideToMove;
517 Color them = ~sideToMove;
518 Square from = from_sq(m);
519 Square to = to_sq(m);
520 Piece pc = piece_moved(m);
522 // Use a slower but simpler function for uncommon cases
524 return move_is_legal(m);
526 // Is not a promotion, so promotion piece must be empty
527 if (promotion_piece_type(m) - 2 != NO_PIECE_TYPE)
530 // If the from square is not occupied by a piece belonging to the side to
531 // move, the move is obviously not legal.
532 if (pc == NO_PIECE || color_of(pc) != us)
535 // The destination square cannot be occupied by a friendly piece
536 if (color_of(piece_on(to)) == us)
539 // Handle the special case of a pawn move
540 if (type_of(pc) == PAWN)
542 // Move direction must be compatible with pawn color
543 int direction = to - from;
544 if ((us == WHITE) != (direction > 0))
547 // We have already handled promotion moves, so destination
548 // cannot be on the 8/1th rank.
549 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
552 // Proceed according to the square delta between the origin and
553 // destination squares.
560 // Capture. The destination square must be occupied by an enemy
561 // piece (en passant captures was handled earlier).
562 if (color_of(piece_on(to)) != them)
565 // From and to files must be one file apart, avoids a7h5
566 if (abs(file_of(from) - file_of(to)) != 1)
572 // Pawn push. The destination square must be empty.
573 if (!square_is_empty(to))
578 // Double white pawn push. The destination square must be on the fourth
579 // rank, and both the destination square and the square between the
580 // source and destination squares must be empty.
581 if ( rank_of(to) != RANK_4
582 || !square_is_empty(to)
583 || !square_is_empty(from + DELTA_N))
588 // Double black pawn push. The destination square must be on the fifth
589 // rank, and both the destination square and the square between the
590 // source and destination squares must be empty.
591 if ( rank_of(to) != RANK_5
592 || !square_is_empty(to)
593 || !square_is_empty(from + DELTA_S))
601 else if (!(attacks_from(pc, from) & to))
604 // Evasions generator already takes care to avoid some kind of illegal moves
605 // and pl_move_is_legal() relies on this. So we have to take care that the
606 // same kind of moves are filtered out here.
609 // In case of king moves under check we have to remove king so to catch
610 // as invalid moves like b1a1 when opposite queen is on c1.
611 if (type_of(pc) == KING)
613 Bitboard b = occupied_squares();
615 if (attackers_to(to, b) & pieces(~us))
620 Bitboard target = checkers();
621 Square checksq = pop_1st_bit(&target);
623 if (target) // double check ? In this case a king move is required
626 // Our move must be a blocking evasion or a capture of the checking piece
627 target = squares_between(checksq, king_square(us)) | checkers();
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 Bitboard b = occupied_squares();
668 Square ksq = king_square(~us);
670 // Promotion with check ?
674 return attacks_from(Piece(promotion_piece_type(m)), to, b) & ksq;
677 // En passant capture with check ? We have already handled the case
678 // of direct checks and ordinary discovered check, the only case we
679 // need to handle is the unusual case of a discovered check through
680 // the captured pawn.
683 Square capsq = make_square(file_of(to), rank_of(from));
687 return (attacks_bb<ROOK>(ksq, b) & pieces(ROOK, QUEEN, us))
688 ||(attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, us));
691 // Castling with check ?
694 Square kfrom, kto, rfrom, rto;
700 kto = relative_square(us, SQ_G1);
701 rto = relative_square(us, SQ_F1);
703 kto = relative_square(us, SQ_C1);
704 rto = relative_square(us, SQ_D1);
710 return attacks_bb<ROOK>(rto, b) & ksq;
717 /// Position::do_move() makes a move, and saves all information necessary
718 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
719 /// moves should be filtered out before this function is called.
721 void Position::do_move(Move m, StateInfo& newSt) {
724 do_move(m, newSt, ci, move_gives_check(m, ci));
727 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
730 assert(&newSt != st);
735 // Copy some fields of old state to our new StateInfo object except the ones
736 // which are recalculated from scratch anyway, then switch our state pointer
737 // to point to the new, ready to be updated, state.
738 struct ReducedStateInfo {
739 Key pawnKey, materialKey;
741 int castleRights, rule50, pliesFromNull;
746 memcpy(&newSt, st, sizeof(ReducedStateInfo));
751 // Update side to move
754 // Increment the 50 moves rule draw counter. Resetting it to zero in the
755 // case of a capture or a pawn move is taken care of later.
762 do_castle_move<true>(m);
766 Color us = sideToMove;
768 Square from = from_sq(m);
769 Square to = to_sq(m);
770 Piece piece = piece_on(from);
771 PieceType pt = type_of(piece);
772 PieceType capture = is_enpassant(m) ? PAWN : type_of(piece_on(to));
774 assert(color_of(piece) == us);
775 assert(color_of(piece_on(to)) != us);
776 assert(capture != KING);
782 // If the captured piece is a pawn, update pawn hash key, otherwise
783 // update non-pawn material.
788 capsq += pawn_push(them);
791 assert(to == st->epSquare);
792 assert(relative_rank(us, to) == RANK_6);
793 assert(piece_on(to) == NO_PIECE);
794 assert(piece_on(capsq) == make_piece(them, PAWN));
796 board[capsq] = NO_PIECE;
799 st->pawnKey ^= zobrist[them][PAWN][capsq];
802 st->npMaterial[them] -= PieceValueMidgame[capture];
804 // Remove the captured piece
805 byColorBB[them] ^= capsq;
806 byTypeBB[capture] ^= capsq;
809 // Update piece list, move the last piece at index[capsq] position and
812 // WARNING: This is a not revresible operation. When we will reinsert the
813 // captured piece in undo_move() we will put it at the end of the list and
814 // not in its original place, it means index[] and pieceList[] are not
815 // guaranteed to be invariant to a do_move() + undo_move() sequence.
816 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
817 index[lastSquare] = index[capsq];
818 pieceList[them][capture][index[lastSquare]] = lastSquare;
819 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
822 k ^= zobrist[them][capture][capsq];
823 st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
825 // Update incremental scores
826 st->value -= pst(make_piece(them, capture), capsq);
828 // Reset rule 50 counter
833 k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
835 // Reset en passant square
836 if (st->epSquare != SQ_NONE)
838 k ^= zobEp[file_of(st->epSquare)];
839 st->epSquare = SQ_NONE;
842 // Update castle rights if needed
843 if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
845 int cr = castleRightsMask[from] | castleRightsMask[to];
846 k ^= zobCastle[st->castleRights & cr];
847 st->castleRights &= ~cr;
850 // Prefetch TT access as soon as we know key is updated
851 prefetch((char*)TT.first_entry(k));
854 Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
855 byColorBB[us] ^= from_to_bb;
856 byTypeBB[pt] ^= from_to_bb;
857 occupied ^= from_to_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[file_of(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 byTypeBB[PAWN] ^= to;
887 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 (ci.checkSq[pt] & to)
944 st->checkersBB |= to;
947 if (ci.dcCandidates && (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 byTypeBB[promotion] ^= to;
1003 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 from_to_bb = SquareBB[from] | SquareBB[to];
1020 byColorBB[us] ^= from_to_bb;
1021 byTypeBB[pt] ^= from_to_bb;
1022 occupied ^= from_to_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 byColorBB[them] |= capsq;
1048 byTypeBB[capture] |= 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 byColorBB[us] ^= kfrom;
1104 byTypeBB[KING] ^= kfrom;
1106 byColorBB[us] ^= rfrom;
1107 byTypeBB[ROOK] ^= rfrom;
1110 // Put pieces on destination squares
1111 byColorBB[us] |= kto;
1112 byTypeBB[KING] |= kto;
1114 byColorBB[us] |= rto;
1115 byTypeBB[ROOK] |= 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[file_of(st->epSquare)];
1149 st->epSquare = SQ_NONE;
1152 // Update castling rights
1153 st->key ^= zobCastle[st->castleRights & castleRightsMask[kfrom]];
1154 st->castleRights &= ~castleRightsMask[kfrom];
1156 // Update checkers BB
1157 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1160 sideToMove = ~sideToMove;
1161 st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
1164 // Undo: point our state pointer back to the previous state
1167 assert(pos_is_ok());
1171 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1172 /// to move and updates the hash key without executing any move on the board.
1174 void Position::do_null_move(StateInfo& backupSt) {
1176 assert(!in_check());
1178 // Back up the information necessary to undo the null move to the supplied
1179 // StateInfo object. Note that differently from normal case here backupSt
1180 // is actually used as a backup storage not as the new state. This reduces
1181 // the number of fields to be copied.
1182 StateInfo* src = Do ? st : &backupSt;
1183 StateInfo* dst = Do ? &backupSt : st;
1185 dst->key = src->key;
1186 dst->epSquare = src->epSquare;
1187 dst->value = src->value;
1188 dst->rule50 = src->rule50;
1189 dst->pliesFromNull = src->pliesFromNull;
1191 sideToMove = ~sideToMove;
1195 if (st->epSquare != SQ_NONE)
1196 st->key ^= zobEp[file_of(st->epSquare)];
1198 st->key ^= zobSideToMove;
1199 prefetch((char*)TT.first_entry(st->key));
1201 st->epSquare = SQ_NONE;
1203 st->pliesFromNull = 0;
1204 st->value += (sideToMove == WHITE) ? TempoValue : -TempoValue;
1207 assert(pos_is_ok());
1210 // Explicit template instantiations
1211 template void Position::do_null_move<false>(StateInfo& backupSt);
1212 template void Position::do_null_move<true>(StateInfo& backupSt);
1215 /// Position::see() is a static exchange evaluator: It tries to estimate the
1216 /// material gain or loss resulting from a move. There are three versions of
1217 /// this function: One which takes a destination square as input, one takes a
1218 /// move, and one which takes a 'from' and a 'to' square. The function does
1219 /// not yet understand promotions captures.
1221 int Position::see_sign(Move m) const {
1225 // Early return if SEE cannot be negative because captured piece value
1226 // is not less then capturing one. Note that king moves always return
1227 // here because king midgame value is set to 0.
1228 if (PieceValueMidgame[piece_on(to_sq(m))] >= PieceValueMidgame[piece_moved(m)])
1234 int Position::see(Move m) const {
1237 Bitboard occ, attackers, stmAttackers, b;
1238 int swapList[32], slIndex = 1;
1239 PieceType capturedType, pt;
1244 // As castle moves are implemented as capturing the rook, they have
1245 // SEE == RookValueMidgame most of the times (unless the rook is under
1252 capturedType = type_of(piece_on(to));
1253 occ = occupied_squares();
1255 // Handle en passant moves
1256 if (is_enpassant(m))
1258 Square capQq = to - pawn_push(sideToMove);
1260 assert(!capturedType);
1261 assert(type_of(piece_on(capQq)) == PAWN);
1263 // Remove the captured pawn
1265 capturedType = PAWN;
1268 // Find all attackers to the destination square, with the moving piece
1269 // removed, but possibly an X-ray attacker added behind it.
1271 attackers = attackers_to(to, occ);
1273 // If the opponent has no attackers we are finished
1274 stm = ~color_of(piece_on(from));
1275 stmAttackers = attackers & pieces(stm);
1277 return PieceValueMidgame[capturedType];
1279 // The destination square is defended, which makes things rather more
1280 // difficult to compute. We proceed by building up a "swap list" containing
1281 // the material gain or loss at each stop in a sequence of captures to the
1282 // destination square, where the sides alternately capture, and always
1283 // capture with the least valuable piece. After each capture, we look for
1284 // new X-ray attacks from behind the capturing piece.
1285 swapList[0] = PieceValueMidgame[capturedType];
1286 capturedType = type_of(piece_on(from));
1289 // Locate the least valuable attacker for the side to move. The loop
1290 // below looks like it is potentially infinite, but it isn't. We know
1291 // that the side to move still has at least one attacker left.
1292 for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
1295 // Remove the attacker we just found from the 'occupied' bitboard,
1296 // and scan for new X-ray attacks behind the attacker.
1297 b = stmAttackers & pieces(pt);
1298 occ ^= (b & (~b + 1));
1299 attackers |= (attacks_bb<ROOK>(to, occ) & pieces(ROOK, QUEEN))
1300 | (attacks_bb<BISHOP>(to, occ) & pieces(BISHOP, QUEEN));
1302 attackers &= occ; // Cut out pieces we've already done
1304 // Add the new entry to the swap list
1305 assert(slIndex < 32);
1306 swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
1309 // Remember the value of the capturing piece, and change the side to
1310 // move before beginning the next iteration.
1313 stmAttackers = attackers & pieces(stm);
1315 // Stop before processing a king capture
1316 if (capturedType == KING && stmAttackers)
1318 assert(slIndex < 32);
1319 swapList[slIndex++] = QueenValueMidgame*10;
1322 } while (stmAttackers);
1324 // Having built the swap list, we negamax through it to find the best
1325 // achievable score from the point of view of the side to move.
1327 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1333 /// Position::clear() erases the position object to a pristine state, with an
1334 /// empty board, white to move, and no castling rights.
1336 void Position::clear() {
1338 memset(this, 0, sizeof(Position));
1339 startState.epSquare = SQ_NONE;
1342 for (int i = 0; i < 8; i++)
1343 for (int j = 0; j < 16; j++)
1344 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1346 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1347 board[sq] = NO_PIECE;
1351 /// Position::put_piece() puts a piece on the given square of the board,
1352 /// updating the board array, pieces list, bitboards, and piece counts.
1354 void Position::put_piece(Piece p, Square s) {
1356 Color c = color_of(p);
1357 PieceType pt = type_of(p);
1360 index[s] = pieceCount[c][pt]++;
1361 pieceList[c][pt][index[s]] = s;
1369 /// Position::compute_key() computes the hash key of the position. The hash
1370 /// key is usually updated incrementally as moves are made and unmade, the
1371 /// compute_key() function is only used when a new position is set up, and
1372 /// to verify the correctness of the hash key when running in debug mode.
1374 Key Position::compute_key() const {
1376 Key result = zobCastle[st->castleRights];
1378 for (Square s = SQ_A1; s <= SQ_H8; s++)
1379 if (!square_is_empty(s))
1380 result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
1382 if (ep_square() != SQ_NONE)
1383 result ^= zobEp[file_of(ep_square())];
1385 if (sideToMove == BLACK)
1386 result ^= zobSideToMove;
1392 /// Position::compute_pawn_key() computes the hash key of the position. The
1393 /// hash key is usually updated incrementally as moves are made and unmade,
1394 /// the compute_pawn_key() function is only used when a new position is set
1395 /// up, and to verify the correctness of the pawn hash key when running in
1398 Key Position::compute_pawn_key() const {
1403 for (Color c = WHITE; c <= BLACK; c++)
1405 b = pieces(PAWN, c);
1407 result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
1413 /// Position::compute_material_key() computes the hash key of the position.
1414 /// The hash key is usually updated incrementally as moves are made and unmade,
1415 /// the compute_material_key() function is only used when a new position is set
1416 /// up, and to verify the correctness of the material hash key when running in
1419 Key Position::compute_material_key() const {
1423 for (Color c = WHITE; c <= BLACK; c++)
1424 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1425 for (int i = 0; i < piece_count(c, pt); i++)
1426 result ^= zobrist[c][pt][i];
1432 /// Position::compute_value() compute the incremental scores for the middle
1433 /// game and the endgame. These functions are used to initialize the incremental
1434 /// scores when a new position is set up, and to verify that the scores are correctly
1435 /// updated by do_move and undo_move when the program is running in debug mode.
1436 Score Position::compute_value() const {
1439 Score result = SCORE_ZERO;
1441 for (Color c = WHITE; c <= BLACK; c++)
1442 for (PieceType pt = PAWN; pt <= KING; pt++)
1446 result += pst(make_piece(c, pt), pop_1st_bit(&b));
1449 result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2);
1454 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1455 /// game material value for the given side. Material values are updated
1456 /// incrementally during the search, this function is only used while
1457 /// initializing a new Position object.
1459 Value Position::compute_non_pawn_material(Color c) const {
1461 Value result = VALUE_ZERO;
1463 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1464 result += piece_count(c, pt) * PieceValueMidgame[pt];
1470 /// Position::is_draw() tests whether the position is drawn by material,
1471 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1472 /// must be done by the search.
1473 template<bool SkipRepetition>
1474 bool Position::is_draw() const {
1476 // Draw by material?
1478 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMidgame))
1481 // Draw by the 50 moves rule?
1482 if (st->rule50 > 99 && (!in_check() || MoveList<MV_LEGAL>(*this).size()))
1485 // Draw by repetition?
1486 if (!SkipRepetition)
1488 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1492 StateInfo* stp = st->previous->previous;
1495 stp = stp->previous->previous;
1497 if (stp->key == st->key)
1509 // Explicit template instantiations
1510 template bool Position::is_draw<false>() const;
1511 template bool Position::is_draw<true>() const;
1514 /// Position::init() is a static member function which initializes at startup
1515 /// the various arrays used to compute hash keys and the piece square tables.
1516 /// The latter is a two-step operation: First, the white halves of the tables
1517 /// are copied from PSQT[] tables. Second, the black halves of the tables are
1518 /// initialized by flipping and changing the sign of the white scores.
1520 void Position::init() {
1524 for (Color c = WHITE; c <= BLACK; c++)
1525 for (PieceType pt = PAWN; pt <= KING; pt++)
1526 for (Square s = SQ_A1; s <= SQ_H8; s++)
1527 zobrist[c][pt][s] = rk.rand<Key>();
1529 for (File f = FILE_A; f <= FILE_H; f++)
1530 zobEp[f] = rk.rand<Key>();
1532 for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
1537 Key k = zobCastle[1 << pop_1st_bit(&b)];
1538 zobCastle[cr] ^= k ? k : rk.rand<Key>();
1542 zobSideToMove = rk.rand<Key>();
1543 zobExclusion = rk.rand<Key>();
1545 for (Piece p = W_PAWN; p <= W_KING; p++)
1547 Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
1549 for (Square s = SQ_A1; s <= SQ_H8; s++)
1551 pieceSquareTable[p][s] = ps + PSQT[p][s];
1552 pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
1558 /// Position::flip_me() flips position with the white and black sides reversed. This
1559 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1561 void Position::flip_me() {
1563 // Make a copy of current position before to start changing
1564 const Position pos(*this, threadID);
1567 threadID = pos.thread();
1570 for (Square s = SQ_A1; s <= SQ_H8; s++)
1571 if (!pos.square_is_empty(s))
1572 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1575 sideToMove = ~pos.side_to_move();
1578 if (pos.can_castle(WHITE_OO))
1579 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
1580 if (pos.can_castle(WHITE_OOO))
1581 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
1582 if (pos.can_castle(BLACK_OO))
1583 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
1584 if (pos.can_castle(BLACK_OOO))
1585 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
1587 // En passant square
1588 if (pos.st->epSquare != SQ_NONE)
1589 st->epSquare = ~pos.st->epSquare;
1592 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1595 st->key = compute_key();
1596 st->pawnKey = compute_pawn_key();
1597 st->materialKey = compute_material_key();
1599 // Incremental scores
1600 st->value = compute_value();
1603 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1604 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1606 assert(pos_is_ok());
1610 /// Position::pos_is_ok() performs some consitency checks for the position object.
1611 /// This is meant to be helpful when debugging.
1613 bool Position::pos_is_ok(int* failedStep) const {
1615 // What features of the position should be verified?
1616 const bool debugAll = false;
1618 const bool debugBitboards = debugAll || false;
1619 const bool debugKingCount = debugAll || false;
1620 const bool debugKingCapture = debugAll || false;
1621 const bool debugCheckerCount = debugAll || false;
1622 const bool debugKey = debugAll || false;
1623 const bool debugMaterialKey = debugAll || false;
1624 const bool debugPawnKey = debugAll || false;
1625 const bool debugIncrementalEval = debugAll || false;
1626 const bool debugNonPawnMaterial = debugAll || false;
1627 const bool debugPieceCounts = debugAll || false;
1628 const bool debugPieceList = debugAll || false;
1629 const bool debugCastleSquares = debugAll || false;
1631 if (failedStep) *failedStep = 1;
1634 if (sideToMove != WHITE && sideToMove != BLACK)
1637 // Are the king squares in the position correct?
1638 if (failedStep) (*failedStep)++;
1639 if (piece_on(king_square(WHITE)) != W_KING)
1642 if (failedStep) (*failedStep)++;
1643 if (piece_on(king_square(BLACK)) != B_KING)
1646 // Do both sides have exactly one king?
1647 if (failedStep) (*failedStep)++;
1650 int kingCount[2] = {0, 0};
1651 for (Square s = SQ_A1; s <= SQ_H8; s++)
1652 if (type_of(piece_on(s)) == KING)
1653 kingCount[color_of(piece_on(s))]++;
1655 if (kingCount[0] != 1 || kingCount[1] != 1)
1659 // Can the side to move capture the opponent's king?
1660 if (failedStep) (*failedStep)++;
1661 if (debugKingCapture)
1663 Color us = sideToMove;
1665 Square ksq = king_square(them);
1666 if (attackers_to(ksq) & pieces(us))
1670 // Is there more than 2 checkers?
1671 if (failedStep) (*failedStep)++;
1672 if (debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1676 if (failedStep) (*failedStep)++;
1679 // The intersection of the white and black pieces must be empty
1680 if (pieces(WHITE) & pieces(BLACK))
1683 // The union of the white and black pieces must be equal to all
1685 if ((pieces(WHITE) | pieces(BLACK)) != occupied_squares())
1688 // Separate piece type bitboards must have empty intersections
1689 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1690 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1691 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1695 // En passant square OK?
1696 if (failedStep) (*failedStep)++;
1697 if (ep_square() != SQ_NONE)
1699 // The en passant square must be on rank 6, from the point of view of the
1701 if (relative_rank(sideToMove, ep_square()) != RANK_6)
1706 if (failedStep) (*failedStep)++;
1707 if (debugKey && st->key != compute_key())
1710 // Pawn hash key OK?
1711 if (failedStep) (*failedStep)++;
1712 if (debugPawnKey && st->pawnKey != compute_pawn_key())
1715 // Material hash key OK?
1716 if (failedStep) (*failedStep)++;
1717 if (debugMaterialKey && st->materialKey != compute_material_key())
1720 // Incremental eval OK?
1721 if (failedStep) (*failedStep)++;
1722 if (debugIncrementalEval && st->value != compute_value())
1725 // Non-pawn material OK?
1726 if (failedStep) (*failedStep)++;
1727 if (debugNonPawnMaterial)
1729 if (st->npMaterial[WHITE] != compute_non_pawn_material(WHITE))
1732 if (st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1737 if (failedStep) (*failedStep)++;
1738 if (debugPieceCounts)
1739 for (Color c = WHITE; c <= BLACK; c++)
1740 for (PieceType pt = PAWN; pt <= KING; pt++)
1741 if (pieceCount[c][pt] != popcount<Full>(pieces(pt, c)))
1744 if (failedStep) (*failedStep)++;
1746 for (Color c = WHITE; c <= BLACK; c++)
1747 for (PieceType pt = PAWN; pt <= KING; pt++)
1748 for (int i = 0; i < pieceCount[c][pt]; i++)
1750 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1753 if (index[piece_list(c, pt)[i]] != i)
1757 if (failedStep) (*failedStep)++;
1758 if (debugCastleSquares)
1759 for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1))
1764 Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
1766 if ( piece_on(castleRookSquare[f]) != rook
1767 || castleRightsMask[castleRookSquare[f]] != f)
1771 if (failedStep) *failedStep = 0;