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-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5 Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
7 Stockfish is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Stockfish is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include <cstddef> // For offsetof()
24 #include <cstring> // For std::memset, std::memcmp
35 #include "syzygy/tbprobe.h"
40 extern Score psq[PIECE_NB][SQUARE_NB];
45 Key psq[PIECE_NB][SQUARE_NB];
46 Key enpassant[FILE_NB];
47 Key castling[CASTLING_RIGHT_NB];
53 const string PieceToChar(" PNBRQK pnbrqk");
55 // min_attacker() is a helper function used by see() to locate the least
56 // valuable attacker for the side to move, remove the attacker we just found
57 // from the bitboards and scan for new X-ray attacks behind it.
60 PieceType min_attacker(const Bitboard* bb, Square to, Bitboard stmAttackers,
61 Bitboard& occupied, Bitboard& attackers) {
63 Bitboard b = stmAttackers & bb[Pt];
65 return min_attacker<Pt+1>(bb, to, stmAttackers, occupied, attackers);
67 occupied ^= b & ~(b - 1);
69 if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
70 attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
72 if (Pt == ROOK || Pt == QUEEN)
73 attackers |= attacks_bb<ROOK>(to, occupied) & (bb[ROOK] | bb[QUEEN]);
75 attackers &= occupied; // After X-ray that may add already processed pieces
80 PieceType min_attacker<KING>(const Bitboard*, Square, Bitboard, Bitboard&, Bitboard&) {
81 return KING; // No need to update bitboards: it is the last cycle
87 /// operator<<(Position) returns an ASCII representation of the position
89 std::ostream& operator<<(std::ostream& os, Position& pos) {
91 os << "\n +---+---+---+---+---+---+---+---+\n";
93 for (Rank r = RANK_8; r >= RANK_1; --r)
95 for (File f = FILE_A; f <= FILE_H; ++f)
96 os << " | " << PieceToChar[pos.piece_on(make_square(f, r))];
98 os << " |\n +---+---+---+---+---+---+---+---+\n";
101 os << "\nFen: " << pos.fen() << "\nKey: " << std::hex << std::uppercase
102 << std::setfill('0') << std::setw(16) << pos.key()
103 << std::setfill(' ') << std::dec << "\nCheckers: ";
105 for (Bitboard b = pos.checkers(); b; )
106 os << UCI::square(pop_lsb(&b)) << " ";
108 if ( int(Tablebases::MaxCardinality) >= popcount(pos.pieces())
109 && !pos.can_castle(ANY_CASTLING))
111 Tablebases::ProbeState s1, s2;
112 Tablebases::WDLScore wdl = Tablebases::probe_wdl(pos, &s1);
113 int dtz = Tablebases::probe_dtz(pos, &s2);
114 os << "\nTablebases WDL: " << std::setw(4) << wdl << " (" << s1 << ")"
115 << "\nTablebases DTZ: " << std::setw(4) << dtz << " (" << s2 << ")";
122 /// Position::init() initializes at startup the various arrays used to compute
125 void Position::init() {
129 for (Piece pc : Pieces)
130 for (Square s = SQ_A1; s <= SQ_H8; ++s)
131 Zobrist::psq[pc][s] = rng.rand<Key>();
133 for (File f = FILE_A; f <= FILE_H; ++f)
134 Zobrist::enpassant[f] = rng.rand<Key>();
136 for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr)
138 Zobrist::castling[cr] = 0;
142 Key k = Zobrist::castling[1ULL << pop_lsb(&b)];
143 Zobrist::castling[cr] ^= k ? k : rng.rand<Key>();
147 Zobrist::side = rng.rand<Key>();
151 /// Position::set() initializes the position object with the given FEN string.
152 /// This function is not very robust - make sure that input FENs are correct,
153 /// this is assumed to be the responsibility of the GUI.
155 Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Thread* th) {
157 A FEN string defines a particular position using only the ASCII character set.
159 A FEN string contains six fields separated by a space. The fields are:
161 1) Piece placement (from white's perspective). Each rank is described, starting
162 with rank 8 and ending with rank 1. Within each rank, the contents of each
163 square are described from file A through file H. Following the Standard
164 Algebraic Notation (SAN), each piece is identified by a single letter taken
165 from the standard English names. White pieces are designated using upper-case
166 letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are
167 noted using digits 1 through 8 (the number of blank squares), and "/"
170 2) Active color. "w" means white moves next, "b" means black.
172 3) Castling availability. If neither side can castle, this is "-". Otherwise,
173 this has one or more letters: "K" (White can castle kingside), "Q" (White
174 can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
175 can castle queenside).
177 4) En passant target square (in algebraic notation). If there's no en passant
178 target square, this is "-". If a pawn has just made a 2-square move, this
179 is the position "behind" the pawn. This is recorded regardless of whether
180 there is a pawn in position to make an en passant capture.
182 5) Halfmove clock. This is the number of halfmoves since the last pawn advance
183 or capture. This is used to determine if a draw can be claimed under the
186 6) Fullmove number. The number of the full move. It starts at 1, and is
187 incremented after Black's move.
190 unsigned char col, row, token;
193 std::istringstream ss(fenStr);
195 std::memset(this, 0, sizeof(Position));
196 std::memset(si, 0, sizeof(StateInfo));
197 std::fill_n(&pieceList[0][0], sizeof(pieceList) / sizeof(Square), SQ_NONE);
202 // 1. Piece placement
203 while ((ss >> token) && !isspace(token))
206 sq += Square(token - '0'); // Advance the given number of files
208 else if (token == '/')
211 else if ((idx = PieceToChar.find(token)) != string::npos)
213 put_piece(Piece(idx), sq);
220 sideToMove = (token == 'w' ? WHITE : BLACK);
223 // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
224 // Shredder-FEN that uses the letters of the columns on which the rooks began
225 // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
226 // if an inner rook is associated with the castling right, the castling tag is
227 // replaced by the file letter of the involved rook, as for the Shredder-FEN.
228 while ((ss >> token) && !isspace(token))
231 Color c = islower(token) ? BLACK : WHITE;
232 Piece rook = make_piece(c, ROOK);
234 token = char(toupper(token));
237 for (rsq = relative_square(c, SQ_H1); piece_on(rsq) != rook; --rsq) {}
239 else if (token == 'Q')
240 for (rsq = relative_square(c, SQ_A1); piece_on(rsq) != rook; ++rsq) {}
242 else if (token >= 'A' && token <= 'H')
243 rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1));
248 set_castling_right(c, rsq);
251 // 4. En passant square. Ignore if no pawn capture is possible
252 if ( ((ss >> col) && (col >= 'a' && col <= 'h'))
253 && ((ss >> row) && (row == '3' || row == '6')))
255 st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
257 if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
258 st->epSquare = SQ_NONE;
261 st->epSquare = SQ_NONE;
263 // 5-6. Halfmove clock and fullmove number
264 ss >> std::skipws >> st->rule50 >> gamePly;
266 // Convert from fullmove starting from 1 to ply starting from 0,
267 // handle also common incorrect FEN with fullmove = 0.
268 gamePly = std::max(2 * (gamePly - 1), 0) + (sideToMove == BLACK);
270 chess960 = isChess960;
280 /// Position::set_castling_right() is a helper function used to set castling
281 /// rights given the corresponding color and the rook starting square.
283 void Position::set_castling_right(Color c, Square rfrom) {
285 Square kfrom = square<KING>(c);
286 CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
287 CastlingRight cr = (c | cs);
289 st->castlingRights |= cr;
290 castlingRightsMask[kfrom] |= cr;
291 castlingRightsMask[rfrom] |= cr;
292 castlingRookSquare[cr] = rfrom;
294 Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
295 Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
297 for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
298 if (s != kfrom && s != rfrom)
299 castlingPath[cr] |= s;
301 for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
302 if (s != kfrom && s != rfrom)
303 castlingPath[cr] |= s;
307 /// Position::set_check_info() sets king attacks to detect if a move gives check
309 void Position::set_check_info(StateInfo* si) const {
311 si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinnersForKing[WHITE]);
312 si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinnersForKing[BLACK]);
314 Square ksq = square<KING>(~sideToMove);
316 si->checkSquares[PAWN] = attacks_from<PAWN>(ksq, ~sideToMove);
317 si->checkSquares[KNIGHT] = attacks_from<KNIGHT>(ksq);
318 si->checkSquares[BISHOP] = attacks_from<BISHOP>(ksq);
319 si->checkSquares[ROOK] = attacks_from<ROOK>(ksq);
320 si->checkSquares[QUEEN] = si->checkSquares[BISHOP] | si->checkSquares[ROOK];
321 si->checkSquares[KING] = 0;
325 /// Position::set_state() computes the hash keys of the position, and other
326 /// data that once computed is updated incrementally as moves are made.
327 /// The function is only used when a new position is set up, and to verify
328 /// the correctness of the StateInfo data when running in debug mode.
330 void Position::set_state(StateInfo* si) const {
332 si->key = si->pawnKey = si->materialKey = 0;
333 si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO;
334 si->psq = SCORE_ZERO;
335 si->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);
339 for (Bitboard b = pieces(); b; )
341 Square s = pop_lsb(&b);
342 Piece pc = piece_on(s);
343 si->key ^= Zobrist::psq[pc][s];
344 si->psq += PSQT::psq[pc][s];
347 if (si->epSquare != SQ_NONE)
348 si->key ^= Zobrist::enpassant[file_of(si->epSquare)];
350 if (sideToMove == BLACK)
351 si->key ^= Zobrist::side;
353 si->key ^= Zobrist::castling[si->castlingRights];
355 for (Bitboard b = pieces(PAWN); b; )
357 Square s = pop_lsb(&b);
358 si->pawnKey ^= Zobrist::psq[piece_on(s)][s];
361 for (Piece pc : Pieces)
363 if (type_of(pc) != PAWN && type_of(pc) != KING)
364 si->nonPawnMaterial[color_of(pc)] += pieceCount[pc] * PieceValue[MG][pc];
366 for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)
367 si->materialKey ^= Zobrist::psq[pc][cnt];
372 /// Position::set() is an overload to initialize the position object with
373 /// the given endgame code string like "KBPKN". It is manily an helper to
374 /// get the material key out of an endgame code. Position is not playable,
375 /// indeed is even not guaranteed to be legal.
377 Position& Position::set(const string& code, Color c, StateInfo* si) {
379 assert(code.length() > 0 && code.length() < 8);
380 assert(code[0] == 'K');
382 string sides[] = { code.substr(code.find('K', 1)), // Weak
383 code.substr(0, code.find('K', 1)) }; // Strong
385 std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
387 string fenStr = sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/8/8/"
388 + sides[1] + char(8 - sides[1].length() + '0') + " w - - 0 10";
390 return set(fenStr, false, si, nullptr);
394 /// Position::fen() returns a FEN representation of the position. In case of
395 /// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
397 const string Position::fen() const {
400 std::ostringstream ss;
402 for (Rank r = RANK_8; r >= RANK_1; --r)
404 for (File f = FILE_A; f <= FILE_H; ++f)
406 for (emptyCnt = 0; f <= FILE_H && empty(make_square(f, r)); ++f)
413 ss << PieceToChar[piece_on(make_square(f, r))];
420 ss << (sideToMove == WHITE ? " w " : " b ");
422 if (can_castle(WHITE_OO))
423 ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE | KING_SIDE))) : 'K');
425 if (can_castle(WHITE_OOO))
426 ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE | QUEEN_SIDE))) : 'Q');
428 if (can_castle(BLACK_OO))
429 ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK | KING_SIDE))) : 'k');
431 if (can_castle(BLACK_OOO))
432 ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK | QUEEN_SIDE))) : 'q');
434 if (!can_castle(WHITE) && !can_castle(BLACK))
437 ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ")
438 << st->rule50 << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2;
444 /// Position::game_phase() calculates the game phase interpolating total non-pawn
445 /// material between endgame and midgame limits.
447 Phase Position::game_phase() const {
449 Value npm = st->nonPawnMaterial[WHITE] + st->nonPawnMaterial[BLACK];
451 npm = std::max(EndgameLimit, std::min(npm, MidgameLimit));
453 return Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
457 /// Position::slider_blockers() returns a bitboard of all the pieces (both colors)
458 /// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a
459 /// slider if removing that piece from the board would result in a position where
460 /// square 's' is attacked. For example, a king-attack blocking piece can be either
461 /// a pinned or a discovered check piece, according if its color is the opposite
462 /// or the same of the color of the slider.
464 Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const {
469 // Snipers are sliders that attack 's' when a piece is removed
470 Bitboard snipers = ( (PseudoAttacks[ROOK ][s] & pieces(QUEEN, ROOK))
471 | (PseudoAttacks[BISHOP][s] & pieces(QUEEN, BISHOP))) & sliders;
475 Square sniperSq = pop_lsb(&snipers);
476 Bitboard b = between_bb(s, sniperSq) & pieces();
478 if (!more_than_one(b))
481 if (b & pieces(color_of(piece_on(s))))
489 /// Position::attackers_to() computes a bitboard of all pieces which attack a
490 /// given square. Slider attacks use the occupied bitboard to indicate occupancy.
492 Bitboard Position::attackers_to(Square s, Bitboard occupied) const {
494 return (attacks_from<PAWN>(s, BLACK) & pieces(WHITE, PAWN))
495 | (attacks_from<PAWN>(s, WHITE) & pieces(BLACK, PAWN))
496 | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
497 | (attacks_bb<ROOK >(s, occupied) & pieces(ROOK, QUEEN))
498 | (attacks_bb<BISHOP>(s, occupied) & pieces(BISHOP, QUEEN))
499 | (attacks_from<KING>(s) & pieces(KING));
503 /// Position::legal() tests whether a pseudo-legal move is legal
505 bool Position::legal(Move m) const {
509 Color us = sideToMove;
510 Square from = from_sq(m);
512 assert(color_of(moved_piece(m)) == us);
513 assert(piece_on(square<KING>(us)) == make_piece(us, KING));
515 // En passant captures are a tricky special case. Because they are rather
516 // uncommon, we do it simply by testing whether the king is attacked after
518 if (type_of(m) == ENPASSANT)
520 Square ksq = square<KING>(us);
521 Square to = to_sq(m);
522 Square capsq = to - pawn_push(us);
523 Bitboard occupied = (pieces() ^ from ^ capsq) | to;
525 assert(to == ep_square());
526 assert(moved_piece(m) == make_piece(us, PAWN));
527 assert(piece_on(capsq) == make_piece(~us, PAWN));
528 assert(piece_on(to) == NO_PIECE);
530 return !(attacks_bb< ROOK>(ksq, occupied) & pieces(~us, QUEEN, ROOK))
531 && !(attacks_bb<BISHOP>(ksq, occupied) & pieces(~us, QUEEN, BISHOP));
534 // If the moving piece is a king, check whether the destination
535 // square is attacked by the opponent. Castling moves are checked
536 // for legality during move generation.
537 if (type_of(piece_on(from)) == KING)
538 return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
540 // A non-king move is legal if and only if it is not pinned or it
541 // is moving along the ray towards or away from the king.
542 return !(pinned_pieces(us) & from)
543 || aligned(from, to_sq(m), square<KING>(us));
547 /// Position::pseudo_legal() takes a random move and tests whether the move is
548 /// pseudo legal. It is used to validate moves from TT that can be corrupted
549 /// due to SMP concurrent access or hash position key aliasing.
551 bool Position::pseudo_legal(const Move m) const {
553 Color us = sideToMove;
554 Square from = from_sq(m);
555 Square to = to_sq(m);
556 Piece pc = moved_piece(m);
558 // Use a slower but simpler function for uncommon cases
559 if (type_of(m) != NORMAL)
560 return MoveList<LEGAL>(*this).contains(m);
562 // Is not a promotion, so promotion piece must be empty
563 if (promotion_type(m) - KNIGHT != NO_PIECE_TYPE)
566 // If the 'from' square is not occupied by a piece belonging to the side to
567 // move, the move is obviously not legal.
568 if (pc == NO_PIECE || color_of(pc) != us)
571 // The destination square cannot be occupied by a friendly piece
575 // Handle the special case of a pawn move
576 if (type_of(pc) == PAWN)
578 // We have already handled promotion moves, so destination
579 // cannot be on the 8th/1st rank.
580 if (rank_of(to) == relative_rank(us, RANK_8))
583 if ( !(attacks_from<PAWN>(from, us) & pieces(~us) & to) // Not a capture
584 && !((from + pawn_push(us) == to) && empty(to)) // Not a single push
585 && !( (from + 2 * pawn_push(us) == to) // Not a double push
586 && (rank_of(from) == relative_rank(us, RANK_2))
588 && empty(to - pawn_push(us))))
591 else if (!(attacks_from(pc, from) & to))
594 // Evasions generator already takes care to avoid some kind of illegal moves
595 // and legal() relies on this. We therefore have to take care that the same
596 // kind of moves are filtered out here.
599 if (type_of(pc) != KING)
601 // Double check? In this case a king move is required
602 if (more_than_one(checkers()))
605 // Our move must be a blocking evasion or a capture of the checking piece
606 if (!((between_bb(lsb(checkers()), square<KING>(us)) | checkers()) & to))
609 // In case of king moves under check we have to remove king so as to catch
610 // invalid moves like b1a1 when opposite queen is on c1.
611 else if (attackers_to(to, pieces() ^ from) & pieces(~us))
619 /// Position::gives_check() tests whether a pseudo-legal move gives a check
621 bool Position::gives_check(Move m) const {
624 assert(color_of(moved_piece(m)) == sideToMove);
626 Square from = from_sq(m);
627 Square to = to_sq(m);
629 // Is there a direct check?
630 if (st->checkSquares[type_of(piece_on(from))] & to)
633 // Is there a discovered check?
634 if ( (discovered_check_candidates() & from)
635 && !aligned(from, to, square<KING>(~sideToMove)))
644 return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & square<KING>(~sideToMove);
646 // En passant capture with check? We have already handled the case
647 // of direct checks and ordinary discovered check, so the only case we
648 // need to handle is the unusual case of a discovered check through
649 // the captured pawn.
652 Square capsq = make_square(file_of(to), rank_of(from));
653 Bitboard b = (pieces() ^ from ^ capsq) | to;
655 return (attacks_bb< ROOK>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, ROOK))
656 | (attacks_bb<BISHOP>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, BISHOP));
661 Square rfrom = to; // Castling is encoded as 'King captures the rook'
662 Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1);
663 Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1);
665 return (PseudoAttacks[ROOK][rto] & square<KING>(~sideToMove))
666 && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & square<KING>(~sideToMove));
675 /// Position::do_move() makes a move, and saves all information necessary
676 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
677 /// moves should be filtered out before this function is called.
679 void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
682 assert(&newSt != st);
685 Key k = st->key ^ Zobrist::side;
687 // Copy some fields of the old state to our new StateInfo object except the
688 // ones which are going to be recalculated from scratch anyway and then switch
689 // our state pointer to point to the new (ready to be updated) state.
690 std::memcpy(&newSt, st, offsetof(StateInfo, key));
694 // Increment ply counters. In particular, rule50 will be reset to zero later on
695 // in case of a capture or a pawn move.
700 Color us = sideToMove;
702 Square from = from_sq(m);
703 Square to = to_sq(m);
704 Piece pc = piece_on(from);
705 Piece captured = type_of(m) == ENPASSANT ? make_piece(them, PAWN) : piece_on(to);
707 assert(color_of(pc) == us);
708 assert(captured == NO_PIECE || color_of(captured) == (type_of(m) != CASTLING ? them : us));
709 assert(type_of(captured) != KING);
711 if (type_of(m) == CASTLING)
713 assert(pc == make_piece(us, KING));
714 assert(captured == make_piece(us, ROOK));
717 do_castling<true>(us, from, to, rfrom, rto);
719 st->psq += PSQT::psq[captured][rto] - PSQT::psq[captured][rfrom];
720 k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];
728 // If the captured piece is a pawn, update pawn hash key, otherwise
729 // update non-pawn material.
730 if (type_of(captured) == PAWN)
732 if (type_of(m) == ENPASSANT)
734 capsq -= pawn_push(us);
736 assert(pc == make_piece(us, PAWN));
737 assert(to == st->epSquare);
738 assert(relative_rank(us, to) == RANK_6);
739 assert(piece_on(to) == NO_PIECE);
740 assert(piece_on(capsq) == make_piece(them, PAWN));
742 board[capsq] = NO_PIECE; // Not done by remove_piece()
745 st->pawnKey ^= Zobrist::psq[captured][capsq];
748 st->nonPawnMaterial[them] -= PieceValue[MG][captured];
750 // Update board and piece lists
751 remove_piece(captured, capsq);
753 // Update material hash key and prefetch access to materialTable
754 k ^= Zobrist::psq[captured][capsq];
755 st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];
756 prefetch(thisThread->materialTable[st->materialKey]);
758 // Update incremental scores
759 st->psq -= PSQT::psq[captured][capsq];
761 // Reset rule 50 counter
766 k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
768 // Reset en passant square
769 if (st->epSquare != SQ_NONE)
771 k ^= Zobrist::enpassant[file_of(st->epSquare)];
772 st->epSquare = SQ_NONE;
775 // Update castling rights if needed
776 if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to]))
778 int cr = castlingRightsMask[from] | castlingRightsMask[to];
779 k ^= Zobrist::castling[st->castlingRights & cr];
780 st->castlingRights &= ~cr;
783 // Move the piece. The tricky Chess960 castling is handled earlier
784 if (type_of(m) != CASTLING)
785 move_piece(pc, from, to);
787 // If the moving piece is a pawn do some special extra work
788 if (type_of(pc) == PAWN)
790 // Set en-passant square if the moved pawn can be captured
791 if ( (int(to) ^ int(from)) == 16
792 && (attacks_from<PAWN>(to - pawn_push(us), us) & pieces(them, PAWN)))
794 st->epSquare = (from + to) / 2;
795 k ^= Zobrist::enpassant[file_of(st->epSquare)];
798 else if (type_of(m) == PROMOTION)
800 Piece promotion = make_piece(us, promotion_type(m));
802 assert(relative_rank(us, to) == RANK_8);
803 assert(type_of(promotion) >= KNIGHT && type_of(promotion) <= QUEEN);
805 remove_piece(pc, to);
806 put_piece(promotion, to);
809 k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to];
810 st->pawnKey ^= Zobrist::psq[pc][to];
811 st->materialKey ^= Zobrist::psq[promotion][pieceCount[promotion]-1]
812 ^ Zobrist::psq[pc][pieceCount[pc]];
814 // Update incremental score
815 st->psq += PSQT::psq[promotion][to] - PSQT::psq[pc][to];
818 st->nonPawnMaterial[us] += PieceValue[MG][promotion];
821 // Update pawn hash key and prefetch access to pawnsTable
822 st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
823 prefetch(thisThread->pawnsTable[st->pawnKey]);
825 // Reset rule 50 draw counter
829 // Update incremental scores
830 st->psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
833 st->capturedPiece = captured;
835 // Update the key with the final value
838 // Calculate checkers bitboard (if move gives check)
839 st->checkersBB = givesCheck ? attackers_to(square<KING>(them)) & pieces(us) : 0;
841 sideToMove = ~sideToMove;
843 // Update king attacks used for fast check detection
850 /// Position::undo_move() unmakes a move. When it returns, the position should
851 /// be restored to exactly the same state as before the move was made.
853 void Position::undo_move(Move m) {
857 sideToMove = ~sideToMove;
859 Color us = sideToMove;
860 Square from = from_sq(m);
861 Square to = to_sq(m);
862 Piece pc = piece_on(to);
864 assert(empty(from) || type_of(m) == CASTLING);
865 assert(type_of(st->capturedPiece) != KING);
867 if (type_of(m) == PROMOTION)
869 assert(relative_rank(us, to) == RANK_8);
870 assert(type_of(pc) == promotion_type(m));
871 assert(type_of(pc) >= KNIGHT && type_of(pc) <= QUEEN);
873 remove_piece(pc, to);
874 pc = make_piece(us, PAWN);
878 if (type_of(m) == CASTLING)
881 do_castling<false>(us, from, to, rfrom, rto);
885 move_piece(pc, to, from); // Put the piece back at the source square
887 if (st->capturedPiece)
891 if (type_of(m) == ENPASSANT)
893 capsq -= pawn_push(us);
895 assert(type_of(pc) == PAWN);
896 assert(to == st->previous->epSquare);
897 assert(relative_rank(us, to) == RANK_6);
898 assert(piece_on(capsq) == NO_PIECE);
899 assert(st->capturedPiece == make_piece(~us, PAWN));
902 put_piece(st->capturedPiece, capsq); // Restore the captured piece
906 // Finally point our state pointer back to the previous state
914 /// Position::do_castling() is a helper used to do/undo a castling move. This
915 /// is a bit tricky in Chess960 where from/to squares can overlap.
917 void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) {
919 bool kingSide = to > from;
920 rfrom = to; // Castling is encoded as "king captures friendly rook"
921 rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
922 to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
924 // Remove both pieces first since squares could overlap in Chess960
925 remove_piece(make_piece(us, KING), Do ? from : to);
926 remove_piece(make_piece(us, ROOK), Do ? rfrom : rto);
927 board[Do ? from : to] = board[Do ? rfrom : rto] = NO_PIECE; // Since remove_piece doesn't do it for us
928 put_piece(make_piece(us, KING), Do ? to : from);
929 put_piece(make_piece(us, ROOK), Do ? rto : rfrom);
933 /// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips
934 /// the side to move without executing any move on the board.
936 void Position::do_null_move(StateInfo& newSt) {
939 assert(&newSt != st);
941 std::memcpy(&newSt, st, sizeof(StateInfo));
945 if (st->epSquare != SQ_NONE)
947 st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
948 st->epSquare = SQ_NONE;
951 st->key ^= Zobrist::side;
952 prefetch(TT.first_entry(st->key));
955 st->pliesFromNull = 0;
957 sideToMove = ~sideToMove;
964 void Position::undo_null_move() {
969 sideToMove = ~sideToMove;
973 /// Position::key_after() computes the new hash key after the given move. Needed
974 /// for speculative prefetch. It doesn't recognize special moves like castling,
975 /// en-passant and promotions.
977 Key Position::key_after(Move m) const {
979 Square from = from_sq(m);
980 Square to = to_sq(m);
981 Piece pc = piece_on(from);
982 Piece captured = piece_on(to);
983 Key k = st->key ^ Zobrist::side;
986 k ^= Zobrist::psq[captured][to];
988 return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
992 /// Position::see_ge (Static Exchange Evaluation Greater or Equal) tests if the
993 /// SEE value of move is greater or equal to the given value. We'll use an
994 /// algorithm similar to alpha-beta pruning with a null window.
996 bool Position::see_ge(Move m, Value v) const {
1000 // Castling moves are implemented as king capturing the rook so cannot be
1001 // handled correctly. Simply assume the SEE value is VALUE_ZERO that is always
1002 // correct unless in the rare case the rook ends up under attack.
1003 if (type_of(m) == CASTLING)
1004 return VALUE_ZERO >= v;
1006 Square from = from_sq(m), to = to_sq(m);
1007 PieceType nextVictim = type_of(piece_on(from));
1008 Color stm = ~color_of(piece_on(from)); // First consider opponent's move
1009 Value balance; // Values of the pieces taken by us minus opponent's ones
1010 Bitboard occupied, stmAttackers;
1012 if (type_of(m) == ENPASSANT)
1014 occupied = SquareBB[to - pawn_push(~stm)]; // Remove the captured pawn
1015 balance = PieceValue[MG][PAWN];
1019 balance = PieceValue[MG][piece_on(to)];
1026 if (nextVictim == KING)
1029 balance -= PieceValue[MG][nextVictim];
1034 bool relativeStm = true; // True if the opponent is to move
1035 occupied ^= pieces() ^ from ^ to;
1037 // Find all attackers to the destination square, with the moving piece removed,
1038 // but possibly an X-ray attacker added behind it.
1039 Bitboard attackers = attackers_to(to, occupied) & occupied;
1043 stmAttackers = attackers & pieces(stm);
1045 // Don't allow pinned pieces to attack pieces except the king as long all
1046 // pinners are on their original square.
1047 if (!(st->pinnersForKing[stm] & ~occupied))
1048 stmAttackers &= ~st->blockersForKing[stm];
1053 // Locate and remove the next least valuable attacker
1054 nextVictim = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
1056 if (nextVictim == KING)
1057 return relativeStm == bool(attackers & pieces(~stm));
1059 balance += relativeStm ? PieceValue[MG][nextVictim]
1060 : -PieceValue[MG][nextVictim];
1062 relativeStm = !relativeStm;
1064 if (relativeStm == (balance >= v))
1072 /// Position::is_draw() tests whether the position is drawn by 50-move rule
1073 /// or by repetition. It does not detect stalemates.
1075 bool Position::is_draw() const {
1077 if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
1080 StateInfo* stp = st;
1081 for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2)
1083 stp = stp->previous->previous;
1085 if (stp->key == st->key)
1086 return true; // Draw at first repetition
1093 /// Position::flip() flips position with the white and black sides reversed. This
1094 /// is only useful for debugging e.g. for finding evaluation symmetry bugs.
1096 void Position::flip() {
1099 std::stringstream ss(fen());
1101 for (Rank r = RANK_8; r >= RANK_1; --r) // Piece placement
1103 std::getline(ss, token, r > RANK_1 ? '/' : ' ');
1104 f.insert(0, token + (f.empty() ? " " : "/"));
1107 ss >> token; // Active color
1108 f += (token == "w" ? "B " : "W "); // Will be lowercased later
1110 ss >> token; // Castling availability
1113 std::transform(f.begin(), f.end(), f.begin(),
1114 [](char c) { return char(islower(c) ? toupper(c) : tolower(c)); });
1116 ss >> token; // En passant square
1117 f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
1119 std::getline(ss, token); // Half and full moves
1122 set(f, is_chess960(), st, this_thread());
1124 assert(pos_is_ok());
1128 /// Position::pos_is_ok() performs some consistency checks for the position object.
1129 /// This is meant to be helpful when debugging.
1131 bool Position::pos_is_ok(int* failedStep) const {
1133 const bool Fast = true; // Quick (default) or full check?
1135 enum { Default, King, Bitboards, State, Lists, Castling };
1137 for (int step = Default; step <= (Fast ? Default : Castling); step++)
1142 if (step == Default)
1143 if ( (sideToMove != WHITE && sideToMove != BLACK)
1144 || piece_on(square<KING>(WHITE)) != W_KING
1145 || piece_on(square<KING>(BLACK)) != B_KING
1146 || ( ep_square() != SQ_NONE
1147 && relative_rank(sideToMove, ep_square()) != RANK_6))
1151 if ( std::count(board, board + SQUARE_NB, W_KING) != 1
1152 || std::count(board, board + SQUARE_NB, B_KING) != 1
1153 || attackers_to(square<KING>(~sideToMove)) & pieces(sideToMove))
1156 if (step == Bitboards)
1158 if ( (pieces(WHITE) & pieces(BLACK))
1159 ||(pieces(WHITE) | pieces(BLACK)) != pieces())
1162 for (PieceType p1 = PAWN; p1 <= KING; ++p1)
1163 for (PieceType p2 = PAWN; p2 <= KING; ++p2)
1164 if (p1 != p2 && (pieces(p1) & pieces(p2)))
1172 if (std::memcmp(&si, st, sizeof(StateInfo)))
1177 for (Piece pc : Pieces)
1179 if (pieceCount[pc] != popcount(pieces(color_of(pc), type_of(pc))))
1182 for (int i = 0; i < pieceCount[pc]; ++i)
1183 if (board[pieceList[pc][i]] != pc || index[pieceList[pc][i]] != i)
1187 if (step == Castling)
1188 for (Color c = WHITE; c <= BLACK; ++c)
1189 for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
1191 if (!can_castle(c | s))
1194 if ( piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
1195 || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)
1196 ||(castlingRightsMask[square<KING>(c)] & (c | s)) != (c | s))