X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fposition.cpp;h=2cdcb4aecca934f237adec65f63dc628d85f2908;hb=2218a5836a48a764e9b57f5996520b48e0b3d236;hp=9f2ee1970c36e28db3c055361c2bd7bcf584f6a9;hpb=96d3b1c92b8db7d2238fc4993a4f3da49f04d614;p=stockfish diff --git a/src/position.cpp b/src/position.cpp index 9f2ee197..2cdcb4ae 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -172,11 +172,11 @@ Position& Position::operator=(const Position& pos) { } -/// Position::from_fen() initializes the position object with the given FEN -/// string. This function is not very robust - make sure that input FENs are -/// correct (this is assumed to be the responsibility of the GUI). +/// Position::set() initializes the position object with the given FEN string. +/// This function is not very robust - make sure that input FENs are correct, +/// this is assumed to be the responsibility of the GUI. -void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { +void Position::set(const string& fenStr, bool isChess960, Thread* th) { /* A FEN string defines a particular position using only the ASCII character set. @@ -214,13 +214,13 @@ void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { char col, row, token; size_t p; Square sq = SQ_A8; - std::istringstream fen(fenStr); + std::istringstream ss(fenStr); clear(); - fen >> std::noskipws; + ss >> std::noskipws; // 1. Piece placement - while ((fen >> token) && !isspace(token)) + while ((ss >> token) && !isspace(token)) { if (isdigit(token)) sq += Square(token - '0'); // Advance the given number of files @@ -236,16 +236,16 @@ void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { } // 2. Active color - fen >> token; + ss >> token; sideToMove = (token == 'w' ? WHITE : BLACK); - fen >> token; + ss >> token; // 3. Castling availability. Compatible with 3 standards: Normal FEN standard, // Shredder-FEN that uses the letters of the columns on which the rooks began // the game instead of KQkq and also X-FEN standard that, in case of Chess960, // if an inner rook is associated with the castling right, the castling tag is // replaced by the file letter of the involved rook, as for the Shredder-FEN. - while ((fen >> token) && !isspace(token)) + while ((ss >> token) && !isspace(token)) { Square rsq; Color c = islower(token) ? BLACK : WHITE; @@ -268,8 +268,8 @@ void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { } // 4. En passant square. Ignore if no pawn capture is possible - if ( ((fen >> col) && (col >= 'a' && col <= 'h')) - && ((fen >> row) && (row == '3' || row == '6'))) + if ( ((ss >> col) && (col >= 'a' && col <= 'h')) + && ((ss >> row) && (row == '3' || row == '6'))) { st->epSquare = File(col - 'a') | Rank(row - '1'); @@ -278,7 +278,7 @@ void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { } // 5-6. Halfmove clock and fullmove number - fen >> std::skipws >> st->rule50 >> startPosPly; + ss >> std::skipws >> st->rule50 >> startPosPly; // Convert from fullmove starting from 1 to ply starting from 0, // handle also common incorrect FEN with fullmove = 0. @@ -325,71 +325,64 @@ void Position::set_castle_right(Color c, Square rfrom) { } -/// Position::to_fen() returns a FEN representation of the position. In case +/// Position::fen() returns a FEN representation of the position. In case /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function. -const string Position::to_fen() const { +const string Position::fen() const { - std::ostringstream fen; - Square sq; - int emptyCnt; + std::ostringstream ss; for (Rank rank = RANK_8; rank >= RANK_1; rank--) { - emptyCnt = 0; - for (File file = FILE_A; file <= FILE_H; file++) { - sq = file | rank; + Square sq = file | rank; if (is_empty(sq)) - emptyCnt++; - else { - if (emptyCnt > 0) - { - fen << emptyCnt; - emptyCnt = 0; - } - fen << PieceToChar[piece_on(sq)]; + int emptyCnt = 1; + + for ( ; file < FILE_H && is_empty(sq++); file++) + emptyCnt++; + + ss << emptyCnt; } + else + ss << PieceToChar[piece_on(sq)]; } - if (emptyCnt > 0) - fen << emptyCnt; - if (rank > RANK_1) - fen << '/'; + ss << '/'; } - fen << (sideToMove == WHITE ? " w " : " b "); + ss << (sideToMove == WHITE ? " w " : " b "); if (can_castle(WHITE_OO)) - fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K'); + ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE)), false) : 'K'); if (can_castle(WHITE_OOO)) - fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q'); + ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q'); if (can_castle(BLACK_OO)) - fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k'); + ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE)), true) : 'k'); if (can_castle(BLACK_OOO)) - fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q'); + ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE)), true) : 'q'); if (st->castleRights == CASTLES_NONE) - fen << '-'; + ss << '-'; - fen << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ") + ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ") << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2; - return fen.str(); + return ss.str(); } -/// Position::print() prints an ASCII representation of the position to -/// the standard output. If a move is given then also the san is printed. +/// Position::pretty() returns an ASCII representation of the position to be +/// printed to the standard output together with the move's san notation. -void Position::print(Move move) const { +const string Position::pretty(Move move) const { const string dottedLine = "\n+---+---+---+---+---+---+---+---+"; const string twoRows = dottedLine + "\n| | . | | . | | . | | . |" @@ -397,17 +390,26 @@ void Position::print(Move move) const { string brd = twoRows + twoRows + twoRows + twoRows + dottedLine; - sync_cout; + std::ostringstream ss; if (move) - cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") - << move_to_san(*const_cast(this), move); + ss << "\nMove: " << (sideToMove == BLACK ? ".." : "") + << move_to_san(*const_cast(this), move); for (Square sq = SQ_A1; sq <= SQ_H8; sq++) if (piece_on(sq) != NO_PIECE) brd[513 - 68*rank_of(sq) + 4*file_of(sq)] = PieceToChar[piece_on(sq)]; - cout << brd << "\nFen is: " << to_fen() << "\nKey is: " << st->key << sync_endl; + ss << brd << "\nFen: " << fen() << "\nKey: " << st->key << "\nCheckers: "; + + for (Bitboard b = checkers(); b; ) + ss << square_to_string(pop_lsb(&b)) << " "; + + ss << "\nLegal moves: "; + for (MoveList ml(*this); !ml.end(); ++ml) + ss << move_to_san(*const_cast(this), ml.move()) << " "; + + return ss.str(); } @@ -520,20 +522,6 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { } -/// Position::move_is_legal() takes a random move and tests whether the move -/// is legal. This version is not very fast and should be used only in non -/// time-critical paths. - -bool Position::move_is_legal(const Move m) const { - - for (MoveList ml(*this); !ml.end(); ++ml) - if (ml.move() == m) - return true; - - return false; -} - - /// Position::is_pseudo_legal() takes a random move and tests whether the move /// is pseudo legal. It is used to validate moves from TT that can be corrupted /// due to SMP concurrent access or hash position key aliasing. @@ -541,14 +529,13 @@ bool Position::move_is_legal(const Move m) const { bool Position::is_pseudo_legal(const Move m) const { Color us = sideToMove; - Color them = ~sideToMove; Square from = from_sq(m); Square to = to_sq(m); Piece pc = piece_moved(m); // Use a slower but simpler function for uncommon cases if (type_of(m) != NORMAL) - return move_is_legal(m); + return MoveList(*this).contains(m); // Is not a promotion, so promotion piece must be empty if (promotion_type(m) - 2 != NO_PIECE_TYPE) @@ -560,7 +547,7 @@ bool Position::is_pseudo_legal(const Move m) const { return false; // The destination square cannot be occupied by a friendly piece - if (color_of(piece_on(to)) == us) + if (piece_on(to) != NO_PIECE && color_of(piece_on(to)) == us) return false; // Handle the special case of a pawn move @@ -586,7 +573,7 @@ bool Position::is_pseudo_legal(const Move m) const { case DELTA_SE: // Capture. The destination square must be occupied by an enemy // piece (en passant captures was handled earlier). - if (color_of(piece_on(to)) != them) + if (piece_on(to) == NO_PIECE || color_of(piece_on(to)) != ~us) return false; // From and to files must be one file apart, avoids a7h5 @@ -631,18 +618,16 @@ bool Position::is_pseudo_legal(const Move m) const { // Evasions generator already takes care to avoid some kind of illegal moves // and pl_move_is_legal() relies on this. So we have to take care that the // same kind of moves are filtered out here. - if (in_check()) + if (checkers()) { if (type_of(pc) != KING) { - Bitboard b = checkers(); - Square checksq = pop_lsb(&b); - - if (b) // double check ? In this case a king move is required + // Double check? In this case a king move is required + if (more_than_one(checkers())) return false; // Our move must be a blocking evasion or a capture of the checking piece - if (!((between_bb(checksq, king_square(us)) | checkers()) & to)) + if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to)) return false; } // In case of king moves under check we have to remove king so to catch @@ -657,7 +642,7 @@ bool Position::is_pseudo_legal(const Move m) const { /// Position::move_gives_check() tests whether a pseudo-legal move gives a check -CheckType Position::move_gives_check(Move m, const CheckInfo& ci) const { +bool Position::move_gives_check(Move m, const CheckInfo& ci) const { assert(is_ok(m)); assert(ci.dcCandidates == discovered_check_candidates()); @@ -669,7 +654,7 @@ CheckType Position::move_gives_check(Move m, const CheckInfo& ci) const { // Direct check ? if (ci.checkSq[pt] & to) - return DIRECT_CHECK; + return true; // Discovery check ? if (ci.dcCandidates && (ci.dcCandidates & from)) @@ -677,35 +662,34 @@ CheckType Position::move_gives_check(Move m, const CheckInfo& ci) const { // For pawn and king moves we need to verify also direction if ( (pt != PAWN && pt != KING) || !squares_aligned(from, to, king_square(~sideToMove))) - return DISCO_CHECK; + return true; } // Can we skip the ugly special cases ? if (type_of(m) == NORMAL) - return NO_CHECK; + return false; Color us = sideToMove; Square ksq = king_square(~us); - // Promotion with check ? - if (type_of(m) == PROMOTION) - return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq ? DIRECT_CHECK : NO_CHECK; + switch (type_of(m)) + { + case PROMOTION: + return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq; // En passant capture with check ? We have already handled the case // of direct checks and ordinary discovered check, the only case we // need to handle is the unusual case of a discovered check through // the captured pawn. - if (type_of(m) == ENPASSANT) + case ENPASSANT: { Square capsq = file_of(to) | rank_of(from); Bitboard b = (pieces() ^ from ^ capsq) | to; return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK)) - | (attacks_bb(ksq, b) & pieces(us, QUEEN, BISHOP)) ? DISCO_CHECK : NO_CHECK; + | (attacks_bb(ksq, b) & pieces(us, QUEEN, BISHOP)); } - - // Castling with check ? - if (type_of(m) == CASTLE) + case CASTLE: { Square kfrom = from; Square rfrom = to; // 'King captures the rook' notation @@ -713,10 +697,12 @@ CheckType Position::move_gives_check(Move m, const CheckInfo& ci) const { Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1); Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto; - return attacks_bb(rto, b) & ksq ? DIRECT_CHECK : NO_CHECK; + return attacks_bb(rto, b) & ksq; + } + default: + assert(false); + return false; } - - return NO_CHECK; } @@ -770,7 +756,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); assert(color_of(piece) == us); - assert(color_of(piece_on(to)) != us); + assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them); assert(capture != KING); if (capture) @@ -816,9 +802,10 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI pieceList[them][capture][index[lastSquare]] = lastSquare; pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE; - // Update hash keys + // Update material hash key and prefetch access to materialTable k ^= Zobrist::psq[them][capture][capsq]; st->materialKey ^= Zobrist::psq[them][capture][pieceCount[them][capture]]; + prefetch((char*)thisThread->materialTable[st->materialKey]); // Update incremental scores st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq]; @@ -845,7 +832,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->castleRights &= ~cr; } - // Prefetch TT access as soon as we know key is updated + // Prefetch TT access as soon as we know the new hash key prefetch((char*)TT.first_entry(k)); // Move the piece @@ -908,17 +895,14 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->npMaterial[us] += PieceValue[MG][promotion]; } - // Update pawn hash key + // Update pawn hash key and prefetch access to pawnsTable st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to]; + prefetch((char*)thisThread->pawnsTable[st->pawnKey]); // Reset rule 50 draw counter st->rule50 = 0; } - // Prefetch pawn and material hash tables - prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]); - prefetch((char*)thisThread->materialTable.entries[st->materialKey]); - // Update incremental scores st->psqScore += psq_delta(piece, from, to); @@ -969,10 +953,7 @@ void Position::undo_move(Move m) { sideToMove = ~sideToMove; if (type_of(m) == CASTLE) - { - do_castle_move(m); - return; - } + return do_castle_move(m); Color us = sideToMove; Color them = ~us; @@ -1068,30 +1049,24 @@ void Position::do_castle_move(Move m) { assert(is_ok(m)); assert(type_of(m) == CASTLE); - Square kto, kfrom, rfrom, rto, kAfter, rAfter; - Color us = sideToMove; - Square kBefore = from_sq(m); - Square rBefore = to_sq(m); + Square kfrom, kto, rfrom, rto; - // Find after-castle squares for king and rook - if (rBefore > kBefore) // O-O + bool kingSide = to_sq(m) > from_sq(m); + kfrom = kto = from_sq(m); + rfrom = rto = to_sq(m); + + if (Do) { - kAfter = relative_square(us, SQ_G1); - rAfter = relative_square(us, SQ_F1); + kto = relative_square(us, kingSide ? SQ_G1 : SQ_C1); + rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1); } - else // O-O-O + else { - kAfter = relative_square(us, SQ_C1); - rAfter = relative_square(us, SQ_D1); + kfrom = relative_square(us, kingSide ? SQ_G1 : SQ_C1); + rfrom = relative_square(us, kingSide ? SQ_F1 : SQ_D1); } - kfrom = Do ? kBefore : kAfter; - rfrom = Do ? rBefore : rAfter; - - kto = Do ? kAfter : kBefore; - rto = Do ? rAfter : rBefore; - assert(piece_on(kfrom) == make_piece(us, KING)); assert(piece_on(rfrom) == make_piece(us, ROOK)); @@ -1104,11 +1079,9 @@ void Position::do_castle_move(Move m) { byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb; // Update board - Piece king = make_piece(us, KING); - Piece rook = make_piece(us, ROOK); board[kfrom] = board[rfrom] = NO_PIECE; - board[kto] = king; - board[rto] = rook; + board[kto] = make_piece(us, KING); + board[rto] = make_piece(us, ROOK); // Update piece lists pieceList[us][KING][index[kfrom]] = kto; @@ -1123,8 +1096,8 @@ void Position::do_castle_move(Move m) { st->capturedType = NO_PIECE_TYPE; // Update incremental scores - st->psqScore += psq_delta(king, kfrom, kto); - st->psqScore += psq_delta(rook, rfrom, rto); + st->psqScore += psq_delta(make_piece(us, KING), kfrom, kto); + st->psqScore += psq_delta(make_piece(us, ROOK), rfrom, rto); // Update hash key st->key ^= Zobrist::psq[us][KING][kfrom] ^ Zobrist::psq[us][KING][kto]; @@ -1154,47 +1127,42 @@ void Position::do_castle_move(Move m) { } -/// Position::do_null_move() is used to do/undo a "null move": It flips the side -/// to move and updates the hash key without executing any move on the board. -template -void Position::do_null_move(StateInfo& backupSt) { +/// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips +/// the side to move without executing any move on the board. - assert(!in_check()); +void Position::do_null_move(StateInfo& newSt) { - // Back up the information necessary to undo the null move to the supplied - // StateInfo object. Note that differently from normal case here backupSt - // is actually used as a backup storage not as the new state. This reduces - // the number of fields to be copied. - StateInfo* src = Do ? st : &backupSt; - StateInfo* dst = Do ? &backupSt : st; + assert(!checkers()); - dst->key = src->key; - dst->epSquare = src->epSquare; - dst->psqScore = src->psqScore; - dst->rule50 = src->rule50; - dst->pliesFromNull = src->pliesFromNull; + memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here - sideToMove = ~sideToMove; + newSt.previous = st; + st = &newSt; - if (Do) + if (st->epSquare != SQ_NONE) { - if (st->epSquare != SQ_NONE) - st->key ^= Zobrist::enpassant[file_of(st->epSquare)]; - - st->key ^= Zobrist::side; - prefetch((char*)TT.first_entry(st->key)); - + st->key ^= Zobrist::enpassant[file_of(st->epSquare)]; st->epSquare = SQ_NONE; - st->rule50++; - st->pliesFromNull = 0; } + st->key ^= Zobrist::side; + prefetch((char*)TT.first_entry(st->key)); + + st->rule50++; + st->pliesFromNull = 0; + + sideToMove = ~sideToMove; + assert(pos_is_ok()); } -// Explicit template instantiations -template void Position::do_null_move(StateInfo& backupSt); -template void Position::do_null_move(StateInfo& backupSt); +void Position::undo_null_move() { + + assert(!checkers()); + + st = st->previous; + sideToMove = ~sideToMove; +} /// Position::see() is a static exchange evaluator: It tries to estimate the @@ -1443,7 +1411,7 @@ bool Position::is_draw() const { && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg)) return true; - if (st->rule50 > 99 && (!in_check() || MoveList(*this).size())) + if (st->rule50 > 99 && (!checkers() || MoveList(*this).size())) return true; if (CheckRepetition)