X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=c814e7657a7e8505d557ff77c673e03889d580c4;hp=9f2ee1970c36e28db3c055361c2bd7bcf584f6a9;hb=f78b68b7ffd05888bd663acdf400276913126cd5;hpb=96d3b1c92b8db7d2238fc4993a4f3da49f04d614 diff --git a/src/position.cpp b/src/position.cpp index 9f2ee197..c814e765 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,12 +325,12 @@ 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; + std::ostringstream ss; Square sq; int emptyCnt; @@ -348,48 +348,48 @@ const string Position::to_fen() const { { if (emptyCnt > 0) { - fen << emptyCnt; + ss << emptyCnt; emptyCnt = 0; } - fen << PieceToChar[piece_on(sq)]; + ss << PieceToChar[piece_on(sq)]; } } if (emptyCnt > 0) - fen << emptyCnt; + ss << 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 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K'); if (can_castle(WHITE_OOO)) - fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q'); + ss << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : '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))) : '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))) : '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 +397,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 +529,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 +536,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 +554,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 +580,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 +625,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 +649,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 +661,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 +669,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 +704,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 +763,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) @@ -916,8 +909,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Prefetch pawn and material hash tables - prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]); - prefetch((char*)thisThread->materialTable.entries[st->materialKey]); + prefetch((char*)thisThread->pawnsTable[st->pawnKey]); + prefetch((char*)thisThread->materialTable[st->materialKey]); // Update incremental scores st->psqScore += psq_delta(piece, from, to); @@ -1159,7 +1152,7 @@ void Position::do_castle_move(Move m) { template void Position::do_null_move(StateInfo& backupSt) { - assert(!in_check()); + assert(!checkers()); // Back up the information necessary to undo the null move to the supplied // StateInfo object. Note that differently from normal case here backupSt @@ -1443,7 +1436,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)