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/>.
39 static const string PieceToChar(" PNBRQK pnbrqk");
43 Score pieceSquareTable[16][64]; // [piece][square]
44 Value PieceValue[2][18] = { // [Mg / Eg][piece / pieceType]
45 { VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
46 { VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } };
50 Key psq[2][8][64]; // [color][pieceType][square / piece count]
51 Key enpassant[8]; // [file]
52 Key castle[16]; // [castleRight]
56 /// init() initializes at startup the various arrays used to compute hash keys
57 /// and the piece square tables. The latter is a two-step operation: First, the
58 /// white halves of the tables are copied from PSQT[] tables. Second, the black
59 /// halves of the tables are initialized by flipping and changing the sign of
66 for (Color c = WHITE; c <= BLACK; c++)
67 for (PieceType pt = PAWN; pt <= KING; pt++)
68 for (Square s = SQ_A1; s <= SQ_H8; s++)
69 psq[c][pt][s] = rk.rand<Key>();
71 for (File f = FILE_A; f <= FILE_H; f++)
72 enpassant[f] = rk.rand<Key>();
74 for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
79 Key k = castle[1ULL << pop_lsb(&b)];
80 castle[cr] ^= k ? k : rk.rand<Key>();
84 side = rk.rand<Key>();
85 exclusion = rk.rand<Key>();
87 for (PieceType pt = PAWN; pt <= KING; pt++)
89 PieceValue[Mg][make_piece(BLACK, pt)] = PieceValue[Mg][pt];
90 PieceValue[Eg][make_piece(BLACK, pt)] = PieceValue[Eg][pt];
92 Score v = make_score(PieceValue[Mg][pt], PieceValue[Eg][pt]);
94 for (Square s = SQ_A1; s <= SQ_H8; s++)
96 pieceSquareTable[make_piece(WHITE, pt)][ s] = (v + PSQT[pt][s]);
97 pieceSquareTable[make_piece(BLACK, pt)][~s] = -(v + PSQT[pt][s]);
102 } // namespace Zobrist
105 /// next_attacker() is an helper function used by see() to locate the least
106 /// valuable attacker for the side to move, remove the attacker we just found
107 /// from the 'occupied' bitboard and scan for new X-ray attacks behind it.
109 template<int Pt> static FORCE_INLINE
110 PieceType next_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers,
111 Bitboard& occupied, Bitboard& attackers) {
113 if (stmAttackers & bb[Pt])
115 Bitboard b = stmAttackers & bb[Pt];
116 occupied ^= b & ~(b - 1);
118 if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
119 attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
121 if (Pt == ROOK || Pt == QUEEN)
122 attackers |= attacks_bb<ROOK>(to, occupied) & (bb[ROOK] | bb[QUEEN]);
124 return (PieceType)Pt;
126 return next_attacker<Pt+1>(bb, to, stmAttackers, occupied, attackers);
129 template<> FORCE_INLINE
130 PieceType next_attacker<KING>(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) {
131 return KING; // No need to update bitboards, it is the last cycle
137 CheckInfo::CheckInfo(const Position& pos) {
139 Color them = ~pos.side_to_move();
140 ksq = pos.king_square(them);
142 pinned = pos.pinned_pieces();
143 dcCandidates = pos.discovered_check_candidates();
145 checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
146 checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
147 checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
148 checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
149 checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
154 /// Position::operator=() creates a copy of 'pos'. We want the new born Position
155 /// object do not depend on any external data so we detach state pointer from
158 Position& Position::operator=(const Position& pos) {
160 memcpy(this, &pos, sizeof(Position));
171 /// Position::from_fen() initializes the position object with the given FEN
172 /// string. This function is not very robust - make sure that input FENs are
173 /// correct (this is assumed to be the responsibility of the GUI).
175 void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) {
177 A FEN string defines a particular position using only the ASCII character set.
179 A FEN string contains six fields separated by a space. The fields are:
181 1) Piece placement (from white's perspective). Each rank is described, starting
182 with rank 8 and ending with rank 1; within each rank, the contents of each
183 square are described from file A through file H. Following the Standard
184 Algebraic Notation (SAN), each piece is identified by a single letter taken
185 from the standard English names. White pieces are designated using upper-case
186 letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
187 noted using digits 1 through 8 (the number of blank squares), and "/"
190 2) Active color. "w" means white moves next, "b" means black.
192 3) Castling availability. If neither side can castle, this is "-". Otherwise,
193 this has one or more letters: "K" (White can castle kingside), "Q" (White
194 can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
195 can castle queenside).
197 4) En passant target square (in algebraic notation). If there's no en passant
198 target square, this is "-". If a pawn has just made a 2-square move, this
199 is the position "behind" the pawn. This is recorded regardless of whether
200 there is a pawn in position to make an en passant capture.
202 5) Halfmove clock. This is the number of halfmoves since the last pawn advance
203 or capture. This is used to determine if a draw can be claimed under the
206 6) Fullmove number. The number of the full move. It starts at 1, and is
207 incremented after Black's move.
210 char col, row, token;
213 std::istringstream fen(fenStr);
216 fen >> std::noskipws;
218 // 1. Piece placement
219 while ((fen >> token) && !isspace(token))
222 sq += Square(token - '0'); // Advance the given number of files
224 else if (token == '/')
227 else if ((p = PieceToChar.find(token)) != string::npos)
229 put_piece(Piece(p), sq);
236 sideToMove = (token == 'w' ? WHITE : BLACK);
239 // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
240 // Shredder-FEN that uses the letters of the columns on which the rooks began
241 // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
242 // if an inner rook is associated with the castling right, the castling tag is
243 // replaced by the file letter of the involved rook, as for the Shredder-FEN.
244 while ((fen >> token) && !isspace(token))
247 Color c = islower(token) ? BLACK : WHITE;
249 token = char(toupper(token));
252 for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
254 else if (token == 'Q')
255 for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
257 else if (token >= 'A' && token <= 'H')
258 rsq = File(token - 'A') | relative_rank(c, RANK_1);
263 set_castle_right(c, rsq);
266 // 4. En passant square. Ignore if no pawn capture is possible
267 if ( ((fen >> col) && (col >= 'a' && col <= 'h'))
268 && ((fen >> row) && (row == '3' || row == '6')))
270 st->epSquare = File(col - 'a') | Rank(row - '1');
272 if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
273 st->epSquare = SQ_NONE;
276 // 5-6. Halfmove clock and fullmove number
277 fen >> std::skipws >> st->rule50 >> startPosPly;
279 // Convert from fullmove starting from 1 to ply starting from 0,
280 // handle also common incorrect FEN with fullmove = 0.
281 startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
283 st->key = compute_key();
284 st->pawnKey = compute_pawn_key();
285 st->materialKey = compute_material_key();
286 st->psqScore = compute_psq_score();
287 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
288 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
289 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
290 chess960 = isChess960;
297 /// Position::set_castle_right() is an helper function used to set castling
298 /// rights given the corresponding color and the rook starting square.
300 void Position::set_castle_right(Color c, Square rfrom) {
302 Square kfrom = king_square(c);
303 CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
304 CastleRight cr = make_castle_right(c, cs);
306 st->castleRights |= cr;
307 castleRightsMask[kfrom] |= cr;
308 castleRightsMask[rfrom] |= cr;
309 castleRookSquare[c][cs] = rfrom;
311 Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
312 Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
314 for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
315 if (s != kfrom && s != rfrom)
316 castlePath[c][cs] |= s;
318 for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
319 if (s != kfrom && s != rfrom)
320 castlePath[c][cs] |= s;
324 /// Position::to_fen() returns a FEN representation of the position. In case
325 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
327 const string Position::to_fen() const {
329 std::ostringstream fen;
333 for (Rank rank = RANK_8; rank >= RANK_1; rank--)
337 for (File file = FILE_A; file <= FILE_H; file++)
350 fen << PieceToChar[piece_on(sq)];
361 fen << (sideToMove == WHITE ? " w " : " b ");
363 if (can_castle(WHITE_OO))
364 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K');
366 if (can_castle(WHITE_OOO))
367 fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q');
369 if (can_castle(BLACK_OO))
370 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k');
372 if (can_castle(BLACK_OOO))
373 fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q');
375 if (st->castleRights == CASTLES_NONE)
378 fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
379 << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2;
385 /// Position::print() prints an ASCII representation of the position to
386 /// the standard output. If a move is given then also the san is printed.
388 void Position::print(Move move) const {
390 const string dottedLine = "\n+---+---+---+---+---+---+---+---+";
391 const string twoRows = dottedLine + "\n| | . | | . | | . | | . |"
392 + dottedLine + "\n| . | | . | | . | | . | |";
394 string brd = twoRows + twoRows + twoRows + twoRows + dottedLine;
401 cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
404 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
405 if (piece_on(sq) != NO_PIECE)
406 brd[513 - 68*rank_of(sq) + 4*file_of(sq)] = PieceToChar[piece_on(sq)];
408 cout << brd << "\nFen is: " << to_fen() << "\nKey is: " << st->key << sync_endl;
412 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
413 /// king) pieces for the given color. Or, when template parameter FindPinned is
414 /// false, the function return the pieces of the given color candidate for a
415 /// discovery check against the enemy king.
416 template<bool FindPinned>
417 Bitboard Position::hidden_checkers() const {
419 // Pinned pieces protect our king, dicovery checks attack the enemy king
420 Bitboard b, result = 0;
421 Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
422 Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
424 // Pinners are sliders, that give check when candidate pinned is removed
425 pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
426 | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
430 b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
432 if (b && !more_than_one(b) && (b & pieces(sideToMove)))
438 // Explicit template instantiations
439 template Bitboard Position::hidden_checkers<true>() const;
440 template Bitboard Position::hidden_checkers<false>() const;
443 /// Position::attackers_to() computes a bitboard of all pieces which attack a
444 /// given square. Slider attacks use occ bitboard as occupancy.
446 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
448 return (attacks_from<PAWN>(s, BLACK) & pieces(WHITE, PAWN))
449 | (attacks_from<PAWN>(s, WHITE) & pieces(BLACK, PAWN))
450 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
451 | (attacks_bb<ROOK>(s, occ) & pieces(ROOK, QUEEN))
452 | (attacks_bb<BISHOP>(s, occ) & pieces(BISHOP, QUEEN))
453 | (attacks_from<KING>(s) & pieces(KING));
457 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
458 /// put in a given square. Slider attacks use occ bitboard as occupancy.
460 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
466 case BISHOP: return attacks_bb<BISHOP>(s, occ);
467 case ROOK : return attacks_bb<ROOK>(s, occ);
468 case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
469 default : return StepAttacksBB[p][s];
474 /// Position::move_attacks_square() tests whether a move from the current
475 /// position attacks a given square.
477 bool Position::move_attacks_square(Move m, Square s) const {
483 Square from = from_sq(m);
484 Square to = to_sq(m);
485 Piece piece = piece_moved(m);
487 assert(!is_empty(from));
489 // Update occupancy as if the piece is moving
490 occ = pieces() ^ from ^ to;
492 // The piece moved in 'to' attacks the square 's' ?
493 if (attacks_from(piece, to, occ) & s)
496 // Scan for possible X-ray attackers behind the moved piece
497 xray = (attacks_bb< ROOK>(s, occ) & pieces(color_of(piece), QUEEN, ROOK))
498 | (attacks_bb<BISHOP>(s, occ) & pieces(color_of(piece), QUEEN, BISHOP));
500 // Verify attackers are triggered by our move and not already existing
501 return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
505 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
507 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
510 assert(pinned == pinned_pieces());
512 Color us = sideToMove;
513 Square from = from_sq(m);
515 assert(color_of(piece_moved(m)) == us);
516 assert(piece_on(king_square(us)) == make_piece(us, KING));
518 // En passant captures are a tricky special case. Because they are rather
519 // uncommon, we do it simply by testing whether the king is attacked after
521 if (type_of(m) == ENPASSANT)
524 Square to = to_sq(m);
525 Square capsq = to + pawn_push(them);
526 Square ksq = king_square(us);
527 Bitboard b = (pieces() ^ from ^ capsq) | to;
529 assert(to == ep_square());
530 assert(piece_moved(m) == make_piece(us, PAWN));
531 assert(piece_on(capsq) == make_piece(them, PAWN));
532 assert(piece_on(to) == NO_PIECE);
534 return !(attacks_bb< ROOK>(ksq, b) & pieces(them, QUEEN, ROOK))
535 && !(attacks_bb<BISHOP>(ksq, b) & pieces(them, QUEEN, BISHOP));
538 // If the moving piece is a king, check whether the destination
539 // square is attacked by the opponent. Castling moves are checked
540 // for legality during move generation.
541 if (type_of(piece_on(from)) == KING)
542 return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us));
544 // A non-king move is legal if and only if it is not pinned or it
545 // is moving along the ray towards or away from the king.
548 || squares_aligned(from, to_sq(m), king_square(us));
552 /// Position::move_is_legal() takes a random move and tests whether the move
553 /// is legal. This version is not very fast and should be used only in non
554 /// time-critical paths.
556 bool Position::move_is_legal(const Move m) const {
558 for (MoveList<LEGAL> ml(*this); !ml.end(); ++ml)
566 /// Position::is_pseudo_legal() takes a random move and tests whether the move
567 /// is pseudo legal. It is used to validate moves from TT that can be corrupted
568 /// due to SMP concurrent access or hash position key aliasing.
570 bool Position::is_pseudo_legal(const Move m) const {
572 Color us = sideToMove;
573 Color them = ~sideToMove;
574 Square from = from_sq(m);
575 Square to = to_sq(m);
576 Piece pc = piece_moved(m);
578 // Use a slower but simpler function for uncommon cases
579 if (type_of(m) != NORMAL)
580 return move_is_legal(m);
582 // Is not a promotion, so promotion piece must be empty
583 if (promotion_type(m) - 2 != NO_PIECE_TYPE)
586 // If the from square is not occupied by a piece belonging to the side to
587 // move, the move is obviously not legal.
588 if (pc == NO_PIECE || color_of(pc) != us)
591 // The destination square cannot be occupied by a friendly piece
592 if (color_of(piece_on(to)) == us)
595 // Handle the special case of a pawn move
596 if (type_of(pc) == PAWN)
598 // Move direction must be compatible with pawn color
599 int direction = to - from;
600 if ((us == WHITE) != (direction > 0))
603 // We have already handled promotion moves, so destination
604 // cannot be on the 8/1th rank.
605 if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
608 // Proceed according to the square delta between the origin and
609 // destination squares.
616 // Capture. The destination square must be occupied by an enemy
617 // piece (en passant captures was handled earlier).
618 if (color_of(piece_on(to)) != them)
621 // From and to files must be one file apart, avoids a7h5
622 if (abs(file_of(from) - file_of(to)) != 1)
628 // Pawn push. The destination square must be empty.
634 // Double white pawn push. The destination square must be on the fourth
635 // rank, and both the destination square and the square between the
636 // source and destination squares must be empty.
637 if ( rank_of(to) != RANK_4
639 || !is_empty(from + DELTA_N))
644 // Double black pawn push. The destination square must be on the fifth
645 // rank, and both the destination square and the square between the
646 // source and destination squares must be empty.
647 if ( rank_of(to) != RANK_5
649 || !is_empty(from + DELTA_S))
657 else if (!(attacks_from(pc, from) & to))
660 // Evasions generator already takes care to avoid some kind of illegal moves
661 // and pl_move_is_legal() relies on this. So we have to take care that the
662 // same kind of moves are filtered out here.
665 if (type_of(pc) != KING)
667 Bitboard b = checkers();
668 Square checksq = pop_lsb(&b);
670 if (b) // double check ? In this case a king move is required
673 // Our move must be a blocking evasion or a capture of the checking piece
674 if (!((between_bb(checksq, king_square(us)) | checkers()) & to))
677 // In case of king moves under check we have to remove king so to catch
678 // as invalid moves like b1a1 when opposite queen is on c1.
679 else if (attackers_to(to, pieces() ^ from) & pieces(~us))
687 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
689 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
692 assert(ci.dcCandidates == discovered_check_candidates());
693 assert(color_of(piece_moved(m)) == sideToMove);
695 Square from = from_sq(m);
696 Square to = to_sq(m);
697 PieceType pt = type_of(piece_on(from));
700 if (ci.checkSq[pt] & to)
704 if (ci.dcCandidates && (ci.dcCandidates & from))
706 // For pawn and king moves we need to verify also direction
707 if ( (pt != PAWN && pt != KING)
708 || !squares_aligned(from, to, king_square(~sideToMove)))
712 // Can we skip the ugly special cases ?
713 if (type_of(m) == NORMAL)
716 Color us = sideToMove;
717 Square ksq = king_square(~us);
719 // Promotion with check ?
720 if (type_of(m) == PROMOTION)
721 return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
723 // En passant capture with check ? We have already handled the case
724 // of direct checks and ordinary discovered check, the only case we
725 // need to handle is the unusual case of a discovered check through
726 // the captured pawn.
727 if (type_of(m) == ENPASSANT)
729 Square capsq = file_of(to) | rank_of(from);
730 Bitboard b = (pieces() ^ from ^ capsq) | to;
732 return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
733 | (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
736 // Castling with check ?
737 if (type_of(m) == CASTLE)
740 Square rfrom = to; // 'King captures the rook' notation
741 Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
742 Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
743 Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
745 return attacks_bb<ROOK>(rto, b) & ksq;
752 /// Position::do_move() makes a move, and saves all information necessary
753 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
754 /// moves should be filtered out before this function is called.
756 void Position::do_move(Move m, StateInfo& newSt) {
759 do_move(m, newSt, ci, move_gives_check(m, ci));
762 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
765 assert(&newSt != st);
770 // Copy some fields of old state to our new StateInfo object except the ones
771 // which are recalculated from scratch anyway, then switch our state pointer
772 // to point to the new, ready to be updated, state.
773 memcpy(&newSt, st, sizeof(ReducedStateInfo));
778 // Update side to move
781 // Increment the 50 moves rule draw counter. Resetting it to zero in the
782 // case of a capture or a pawn move is taken care of later.
786 if (type_of(m) == CASTLE)
789 do_castle_move<true>(m);
793 Color us = sideToMove;
795 Square from = from_sq(m);
796 Square to = to_sq(m);
797 Piece piece = piece_on(from);
798 PieceType pt = type_of(piece);
799 PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
801 assert(color_of(piece) == us);
802 assert(color_of(piece_on(to)) != us);
803 assert(capture != KING);
809 // If the captured piece is a pawn, update pawn hash key, otherwise
810 // update non-pawn material.
813 if (type_of(m) == ENPASSANT)
815 capsq += pawn_push(them);
818 assert(to == st->epSquare);
819 assert(relative_rank(us, to) == RANK_6);
820 assert(piece_on(to) == NO_PIECE);
821 assert(piece_on(capsq) == make_piece(them, PAWN));
823 board[capsq] = NO_PIECE;
826 st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
829 st->npMaterial[them] -= PieceValue[Mg][capture];
831 // Remove the captured piece
832 byTypeBB[ALL_PIECES] ^= capsq;
833 byTypeBB[capture] ^= capsq;
834 byColorBB[them] ^= capsq;
836 // Update piece list, move the last piece at index[capsq] position and
839 // WARNING: This is a not revresible operation. When we will reinsert the
840 // captured piece in undo_move() we will put it at the end of the list and
841 // not in its original place, it means index[] and pieceList[] are not
842 // guaranteed to be invariant to a do_move() + undo_move() sequence.
843 Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
844 index[lastSquare] = index[capsq];
845 pieceList[them][capture][index[lastSquare]] = lastSquare;
846 pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
849 k ^= Zobrist::psq[them][capture][capsq];
850 st->materialKey ^= Zobrist::psq[them][capture][pieceCount[them][capture]];
852 // Update incremental scores
853 st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq];
855 // Reset rule 50 counter
860 k ^= Zobrist::psq[us][pt][from] ^ Zobrist::psq[us][pt][to];
862 // Reset en passant square
863 if (st->epSquare != SQ_NONE)
865 k ^= Zobrist::enpassant[file_of(st->epSquare)];
866 st->epSquare = SQ_NONE;
869 // Update castle rights if needed
870 if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
872 int cr = castleRightsMask[from] | castleRightsMask[to];
873 k ^= Zobrist::castle[st->castleRights & cr];
874 st->castleRights &= ~cr;
877 // Prefetch TT access as soon as we know key is updated
878 prefetch((char*)TT.first_entry(k));
881 Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
882 byTypeBB[ALL_PIECES] ^= from_to_bb;
883 byTypeBB[pt] ^= from_to_bb;
884 byColorBB[us] ^= from_to_bb;
886 board[to] = board[from];
887 board[from] = NO_PIECE;
889 // Update piece lists, index[from] is not updated and becomes stale. This
890 // works as long as index[] is accessed just by known occupied squares.
891 index[to] = index[from];
892 pieceList[us][pt][index[to]] = to;
894 // If the moving piece is a pawn do some special extra work
897 // Set en-passant square, only if moved pawn can be captured
898 if ( (int(to) ^ int(from)) == 16
899 && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
901 st->epSquare = Square((from + to) / 2);
902 k ^= Zobrist::enpassant[file_of(st->epSquare)];
905 if (type_of(m) == PROMOTION)
907 PieceType promotion = promotion_type(m);
909 assert(relative_rank(us, to) == RANK_8);
910 assert(promotion >= KNIGHT && promotion <= QUEEN);
912 // Replace the pawn with the promoted piece
913 byTypeBB[PAWN] ^= to;
914 byTypeBB[promotion] |= to;
915 board[to] = make_piece(us, promotion);
917 // Update piece lists, move the last pawn at index[to] position
918 // and shrink the list. Add a new promotion piece to the list.
919 Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
920 index[lastSquare] = index[to];
921 pieceList[us][PAWN][index[lastSquare]] = lastSquare;
922 pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
923 index[to] = pieceCount[us][promotion];
924 pieceList[us][promotion][index[to]] = to;
927 k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to];
928 st->pawnKey ^= Zobrist::psq[us][PAWN][to];
929 st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]++]
930 ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
932 // Update incremental score
933 st->psqScore += pieceSquareTable[make_piece(us, promotion)][to]
934 - pieceSquareTable[make_piece(us, PAWN)][to];
937 st->npMaterial[us] += PieceValue[Mg][promotion];
940 // Update pawn hash key
941 st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to];
943 // Reset rule 50 draw counter
947 // Prefetch pawn and material hash tables
948 prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]);
949 prefetch((char*)thisThread->materialTable.entries[st->materialKey]);
951 // Update incremental scores
952 st->psqScore += psq_delta(piece, from, to);
955 st->capturedType = capture;
957 // Update the key with the final value
960 // Update checkers bitboard, piece must be already moved
965 if (type_of(m) != NORMAL)
966 st->checkersBB = attackers_to(king_square(them)) & pieces(us);
970 if (ci.checkSq[pt] & to)
971 st->checkersBB |= to;
974 if (ci.dcCandidates && (ci.dcCandidates & from))
977 st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(us, QUEEN, ROOK);
980 st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(us, QUEEN, BISHOP);
985 sideToMove = ~sideToMove;
991 /// Position::undo_move() unmakes a move. When it returns, the position should
992 /// be restored to exactly the same state as before the move was made.
994 void Position::undo_move(Move m) {
998 sideToMove = ~sideToMove;
1000 if (type_of(m) == CASTLE)
1002 do_castle_move<false>(m);
1006 Color us = sideToMove;
1008 Square from = from_sq(m);
1009 Square to = to_sq(m);
1010 Piece piece = piece_on(to);
1011 PieceType pt = type_of(piece);
1012 PieceType capture = st->capturedType;
1014 assert(is_empty(from));
1015 assert(color_of(piece) == us);
1016 assert(capture != KING);
1018 if (type_of(m) == PROMOTION)
1020 PieceType promotion = promotion_type(m);
1022 assert(promotion == pt);
1023 assert(relative_rank(us, to) == RANK_8);
1024 assert(promotion >= KNIGHT && promotion <= QUEEN);
1026 // Replace the promoted piece with the pawn
1027 byTypeBB[promotion] ^= to;
1028 byTypeBB[PAWN] |= to;
1029 board[to] = make_piece(us, PAWN);
1031 // Update piece lists, move the last promoted piece at index[to] position
1032 // and shrink the list. Add a new pawn to the list.
1033 Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
1034 index[lastSquare] = index[to];
1035 pieceList[us][promotion][index[lastSquare]] = lastSquare;
1036 pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
1037 index[to] = pieceCount[us][PAWN]++;
1038 pieceList[us][PAWN][index[to]] = to;
1043 // Put the piece back at the source square
1044 Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
1045 byTypeBB[ALL_PIECES] ^= from_to_bb;
1046 byTypeBB[pt] ^= from_to_bb;
1047 byColorBB[us] ^= from_to_bb;
1049 board[from] = board[to];
1050 board[to] = NO_PIECE;
1052 // Update piece lists, index[to] is not updated and becomes stale. This
1053 // works as long as index[] is accessed just by known occupied squares.
1054 index[from] = index[to];
1055 pieceList[us][pt][index[from]] = from;
1061 if (type_of(m) == ENPASSANT)
1063 capsq -= pawn_push(us);
1066 assert(to == st->previous->epSquare);
1067 assert(relative_rank(us, to) == RANK_6);
1068 assert(piece_on(capsq) == NO_PIECE);
1071 // Restore the captured piece
1072 byTypeBB[ALL_PIECES] |= capsq;
1073 byTypeBB[capture] |= capsq;
1074 byColorBB[them] |= capsq;
1076 board[capsq] = make_piece(them, capture);
1078 // Update piece list, add a new captured piece in capsq square
1079 index[capsq] = pieceCount[them][capture]++;
1080 pieceList[them][capture][index[capsq]] = capsq;
1083 // Finally point our state pointer back to the previous state
1086 assert(pos_is_ok());
1090 /// Position::do_castle_move() is a private method used to do/undo a castling
1091 /// move. Note that castling moves are encoded as "king captures friendly rook"
1092 /// moves, for instance white short castling in a non-Chess960 game is encoded
1095 void Position::do_castle_move(Move m) {
1098 assert(type_of(m) == CASTLE);
1100 Square kto, kfrom, rfrom, rto, kAfter, rAfter;
1102 Color us = sideToMove;
1103 Square kBefore = from_sq(m);
1104 Square rBefore = to_sq(m);
1106 // Find after-castle squares for king and rook
1107 if (rBefore > kBefore) // O-O
1109 kAfter = relative_square(us, SQ_G1);
1110 rAfter = relative_square(us, SQ_F1);
1114 kAfter = relative_square(us, SQ_C1);
1115 rAfter = relative_square(us, SQ_D1);
1118 kfrom = Do ? kBefore : kAfter;
1119 rfrom = Do ? rBefore : rAfter;
1121 kto = Do ? kAfter : kBefore;
1122 rto = Do ? rAfter : rBefore;
1124 assert(piece_on(kfrom) == make_piece(us, KING));
1125 assert(piece_on(rfrom) == make_piece(us, ROOK));
1127 // Move the pieces, with some care; in chess960 could be kto == rfrom
1128 Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto];
1129 Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto];
1130 byTypeBB[KING] ^= k_from_to_bb;
1131 byTypeBB[ROOK] ^= r_from_to_bb;
1132 byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb;
1133 byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb;
1136 Piece king = make_piece(us, KING);
1137 Piece rook = make_piece(us, ROOK);
1138 board[kfrom] = board[rfrom] = NO_PIECE;
1142 // Update piece lists
1143 pieceList[us][KING][index[kfrom]] = kto;
1144 pieceList[us][ROOK][index[rfrom]] = rto;
1145 int tmp = index[rfrom]; // In Chess960 could be kto == rfrom
1146 index[kto] = index[kfrom];
1151 // Reset capture field
1152 st->capturedType = NO_PIECE_TYPE;
1154 // Update incremental scores
1155 st->psqScore += psq_delta(king, kfrom, kto);
1156 st->psqScore += psq_delta(rook, rfrom, rto);
1159 st->key ^= Zobrist::psq[us][KING][kfrom] ^ Zobrist::psq[us][KING][kto];
1160 st->key ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
1162 // Clear en passant square
1163 if (st->epSquare != SQ_NONE)
1165 st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
1166 st->epSquare = SQ_NONE;
1169 // Update castling rights
1170 st->key ^= Zobrist::castle[st->castleRights & castleRightsMask[kfrom]];
1171 st->castleRights &= ~castleRightsMask[kfrom];
1173 // Update checkers BB
1174 st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
1176 sideToMove = ~sideToMove;
1179 // Undo: point our state pointer back to the previous state
1182 assert(pos_is_ok());
1186 /// Position::do_null_move() is used to do/undo a "null move": It flips the side
1187 /// to move and updates the hash key without executing any move on the board.
1189 void Position::do_null_move(StateInfo& backupSt) {
1191 assert(!in_check());
1193 // Back up the information necessary to undo the null move to the supplied
1194 // StateInfo object. Note that differently from normal case here backupSt
1195 // is actually used as a backup storage not as the new state. This reduces
1196 // the number of fields to be copied.
1197 StateInfo* src = Do ? st : &backupSt;
1198 StateInfo* dst = Do ? &backupSt : st;
1200 dst->key = src->key;
1201 dst->epSquare = src->epSquare;
1202 dst->psqScore = src->psqScore;
1203 dst->rule50 = src->rule50;
1204 dst->pliesFromNull = src->pliesFromNull;
1206 sideToMove = ~sideToMove;
1210 if (st->epSquare != SQ_NONE)
1211 st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
1213 st->key ^= Zobrist::side;
1214 prefetch((char*)TT.first_entry(st->key));
1216 st->epSquare = SQ_NONE;
1218 st->pliesFromNull = 0;
1221 assert(pos_is_ok());
1224 // Explicit template instantiations
1225 template void Position::do_null_move<false>(StateInfo& backupSt);
1226 template void Position::do_null_move<true>(StateInfo& backupSt);
1229 /// Position::see() is a static exchange evaluator: It tries to estimate the
1230 /// material gain or loss resulting from a move. There are three versions of
1231 /// this function: One which takes a destination square as input, one takes a
1232 /// move, and one which takes a 'from' and a 'to' square. The function does
1233 /// not yet understand promotions captures.
1235 int Position::see_sign(Move m) const {
1239 // Early return if SEE cannot be negative because captured piece value
1240 // is not less then capturing one. Note that king moves always return
1241 // here because king midgame value is set to 0.
1242 if (PieceValue[Mg][piece_on(to_sq(m))] >= PieceValue[Mg][piece_moved(m)])
1248 int Position::see(Move m) const {
1251 Bitboard occupied, attackers, stmAttackers;
1252 int swapList[32], slIndex = 1;
1260 captured = type_of(piece_on(to));
1261 occupied = pieces() ^ from;
1263 // Handle en passant moves
1264 if (type_of(m) == ENPASSANT)
1266 Square capQq = to - pawn_push(sideToMove);
1269 assert(type_of(piece_on(capQq)) == PAWN);
1271 // Remove the captured pawn
1275 else if (type_of(m) == CASTLE)
1276 // Castle moves are implemented as king capturing the rook so cannot be
1277 // handled correctly. Simply return 0 that is always the correct value
1278 // unless the rook is ends up under attack.
1281 // Find all attackers to the destination square, with the moving piece
1282 // removed, but possibly an X-ray attacker added behind it.
1283 attackers = attackers_to(to, occupied);
1285 // If the opponent has no attackers we are finished
1286 stm = ~color_of(piece_on(from));
1287 stmAttackers = attackers & pieces(stm);
1289 return PieceValue[Mg][captured];
1291 // The destination square is defended, which makes things rather more
1292 // difficult to compute. We proceed by building up a "swap list" containing
1293 // the material gain or loss at each stop in a sequence of captures to the
1294 // destination square, where the sides alternately capture, and always
1295 // capture with the least valuable piece. After each capture, we look for
1296 // new X-ray attacks from behind the capturing piece.
1297 swapList[0] = PieceValue[Mg][captured];
1298 captured = type_of(piece_on(from));
1301 assert(slIndex < 32);
1303 // Add the new entry to the swap list
1304 swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[Mg][captured];
1307 // Locate and remove from 'occupied' the next least valuable attacker
1308 captured = next_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
1310 attackers &= occupied; // Remove the just found attacker
1312 stmAttackers = attackers & pieces(stm);
1314 if (captured == KING)
1316 // Stop before processing a king capture
1318 swapList[slIndex++] = QueenValueMg * 16;
1323 } while (stmAttackers);
1325 // Having built the swap list, we negamax through it to find the best
1326 // achievable score from the point of view of the side to move.
1328 swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
1334 /// Position::clear() erases the position object to a pristine state, with an
1335 /// empty board, white to move, and no castling rights.
1337 void Position::clear() {
1339 memset(this, 0, sizeof(Position));
1340 startState.epSquare = SQ_NONE;
1343 for (int i = 0; i < 8; i++)
1344 for (int j = 0; j < 16; j++)
1345 pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
1347 for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
1348 board[sq] = NO_PIECE;
1352 /// Position::put_piece() puts a piece on the given square of the board,
1353 /// updating the board array, pieces list, bitboards, and piece counts.
1355 void Position::put_piece(Piece p, Square s) {
1357 Color c = color_of(p);
1358 PieceType pt = type_of(p);
1361 index[s] = pieceCount[c][pt]++;
1362 pieceList[c][pt][index[s]] = s;
1364 byTypeBB[ALL_PIECES] |= s;
1370 /// Position::compute_key() computes the hash key of the position. The hash
1371 /// key is usually updated incrementally as moves are made and unmade, the
1372 /// compute_key() function is only used when a new position is set up, and
1373 /// to verify the correctness of the hash key when running in debug mode.
1375 Key Position::compute_key() const {
1377 Key k = Zobrist::castle[st->castleRights];
1379 for (Bitboard b = pieces(); b; )
1381 Square s = pop_lsb(&b);
1382 k ^= Zobrist::psq[color_of(piece_on(s))][type_of(piece_on(s))][s];
1385 if (ep_square() != SQ_NONE)
1386 k ^= Zobrist::enpassant[file_of(ep_square())];
1388 if (sideToMove == BLACK)
1395 /// Position::compute_pawn_key() computes the hash key of the position. The
1396 /// hash key is usually updated incrementally as moves are made and unmade,
1397 /// the compute_pawn_key() function is only used when a new position is set
1398 /// up, and to verify the correctness of the pawn hash key when running in
1401 Key Position::compute_pawn_key() const {
1405 for (Bitboard b = pieces(PAWN); b; )
1407 Square s = pop_lsb(&b);
1408 k ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s];
1415 /// Position::compute_material_key() computes the hash key of the position.
1416 /// The hash key is usually updated incrementally as moves are made and unmade,
1417 /// the compute_material_key() function is only used when a new position is set
1418 /// up, and to verify the correctness of the material hash key when running in
1421 Key Position::compute_material_key() const {
1425 for (Color c = WHITE; c <= BLACK; c++)
1426 for (PieceType pt = PAWN; pt <= QUEEN; pt++)
1427 for (int cnt = 0; cnt < piece_count(c, pt); cnt++)
1428 k ^= Zobrist::psq[c][pt][cnt];
1434 /// Position::compute_psq_score() computes the incremental scores for the middle
1435 /// game and the endgame. These functions are used to initialize the incremental
1436 /// scores when a new position is set up, and to verify that the scores are correctly
1437 /// updated by do_move and undo_move when the program is running in debug mode.
1438 Score Position::compute_psq_score() const {
1440 Score score = SCORE_ZERO;
1442 for (Bitboard b = pieces(); b; )
1444 Square s = pop_lsb(&b);
1445 score += pieceSquareTable[piece_on(s)][s];
1452 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1453 /// game material value for the given side. Material values are updated
1454 /// incrementally during the search, this function is only used while
1455 /// initializing a new Position object.
1457 Value Position::compute_non_pawn_material(Color c) const {
1459 Value value = VALUE_ZERO;
1461 for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
1462 value += piece_count(c, pt) * PieceValue[Mg][pt];
1468 /// Position::is_draw() tests whether the position is drawn by material,
1469 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1470 /// must be done by the search.
1471 template<bool SkipRepetition>
1472 bool Position::is_draw() const {
1474 // Draw by material?
1476 && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg))
1479 // Draw by the 50 moves rule?
1480 if (st->rule50 > 99 && (!in_check() || MoveList<LEGAL>(*this).size()))
1483 // Draw by repetition?
1484 if (!SkipRepetition)
1486 int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1490 StateInfo* stp = st->previous->previous;
1493 stp = stp->previous->previous;
1495 if (stp->key == st->key)
1507 // Explicit template instantiations
1508 template bool Position::is_draw<false>() const;
1509 template bool Position::is_draw<true>() const;
1512 /// Position::flip() flips position with the white and black sides reversed. This
1513 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1515 void Position::flip() {
1517 const Position pos(*this);
1521 sideToMove = ~pos.side_to_move();
1522 thisThread = pos.this_thread();
1523 nodes = pos.nodes_searched();
1524 chess960 = pos.is_chess960();
1525 startPosPly = pos.startpos_ply_counter();
1527 for (Square s = SQ_A1; s <= SQ_H8; s++)
1528 if (!pos.is_empty(s))
1529 put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
1531 if (pos.can_castle(WHITE_OO))
1532 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
1533 if (pos.can_castle(WHITE_OOO))
1534 set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
1535 if (pos.can_castle(BLACK_OO))
1536 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
1537 if (pos.can_castle(BLACK_OOO))
1538 set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
1540 if (pos.st->epSquare != SQ_NONE)
1541 st->epSquare = ~pos.st->epSquare;
1543 st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
1545 st->key = compute_key();
1546 st->pawnKey = compute_pawn_key();
1547 st->materialKey = compute_material_key();
1548 st->psqScore = compute_psq_score();
1549 st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
1550 st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
1552 assert(pos_is_ok());
1556 /// Position::pos_is_ok() performs some consitency checks for the position object.
1557 /// This is meant to be helpful when debugging.
1559 bool Position::pos_is_ok(int* failedStep) const {
1561 int dummy, *step = failedStep ? failedStep : &dummy;
1563 // What features of the position should be verified?
1564 const bool all = false;
1566 const bool debugBitboards = all || false;
1567 const bool debugKingCount = all || false;
1568 const bool debugKingCapture = all || false;
1569 const bool debugCheckerCount = all || false;
1570 const bool debugKey = all || false;
1571 const bool debugMaterialKey = all || false;
1572 const bool debugPawnKey = all || false;
1573 const bool debugIncrementalEval = all || false;
1574 const bool debugNonPawnMaterial = all || false;
1575 const bool debugPieceCounts = all || false;
1576 const bool debugPieceList = all || false;
1577 const bool debugCastleSquares = all || false;
1581 if (sideToMove != WHITE && sideToMove != BLACK)
1584 if ((*step)++, piece_on(king_square(WHITE)) != W_KING)
1587 if ((*step)++, piece_on(king_square(BLACK)) != B_KING)
1590 if ((*step)++, debugKingCount)
1592 int kingCount[2] = {};
1594 for (Square s = SQ_A1; s <= SQ_H8; s++)
1595 if (type_of(piece_on(s)) == KING)
1596 kingCount[color_of(piece_on(s))]++;
1598 if (kingCount[0] != 1 || kingCount[1] != 1)
1602 if ((*step)++, debugKingCapture)
1603 if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove))
1606 if ((*step)++, debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1609 if ((*step)++, debugBitboards)
1611 // The intersection of the white and black pieces must be empty
1612 if (pieces(WHITE) & pieces(BLACK))
1615 // The union of the white and black pieces must be equal to all
1617 if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1620 // Separate piece type bitboards must have empty intersections
1621 for (PieceType p1 = PAWN; p1 <= KING; p1++)
1622 for (PieceType p2 = PAWN; p2 <= KING; p2++)
1623 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1627 if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)
1630 if ((*step)++, debugKey && st->key != compute_key())
1633 if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key())
1636 if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())
1639 if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score())
1642 if ((*step)++, debugNonPawnMaterial)
1644 if ( st->npMaterial[WHITE] != compute_non_pawn_material(WHITE)
1645 || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1649 if ((*step)++, debugPieceCounts)
1650 for (Color c = WHITE; c <= BLACK; c++)
1651 for (PieceType pt = PAWN; pt <= KING; pt++)
1652 if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
1655 if ((*step)++, debugPieceList)
1656 for (Color c = WHITE; c <= BLACK; c++)
1657 for (PieceType pt = PAWN; pt <= KING; pt++)
1658 for (int i = 0; i < pieceCount[c][pt]; i++)
1660 if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt))
1663 if (index[piece_list(c, pt)[i]] != i)
1667 if ((*step)++, debugCastleSquares)
1668 for (Color c = WHITE; c <= BLACK; c++)
1669 for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
1671 CastleRight cr = make_castle_right(c, s);
1673 if (!can_castle(cr))
1676 if ((castleRightsMask[king_square(c)] & cr) != cr)
1679 if ( piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
1680 || castleRightsMask[castleRookSquare[c][s]] != cr)