X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=f6b8d0ce0633675040893eb2f4a29aebfddfccb9;hp=ec008338796cc4b8f422366899ff0e82358fd8d0;hb=f99cb3dc27719021e126690b7fd5aa5f43663ed8;hpb=13d1f0ae4301b86c610a58332c3c19d9101704da diff --git a/src/position.cpp b/src/position.cpp index ec008338..f6b8d0ce 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -21,7 +21,6 @@ #include #include #include -#include #include #include "bitcount.h" @@ -34,8 +33,6 @@ #include "tt.h" using std::string; -using std::cout; -using std::endl; static const string PieceToChar(" PNBRQK pnbrqk"); @@ -50,7 +47,7 @@ namespace Zobrist { Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Key enpassant[FILE_NB]; - Key castle[CASTLE_RIGHT_NB]; + Key castling[CASTLING_FLAG_NB]; Key side; Key exclusion; } @@ -128,13 +125,13 @@ void Position::init() { for (File f = FILE_A; f <= FILE_H; ++f) Zobrist::enpassant[f] = rk.rand(); - for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; ++cr) + for (int cf = NO_CASTLING; cf <= ANY_CASTLING; ++cf) { - Bitboard b = cr; + Bitboard b = cf; while (b) { - Key k = Zobrist::castle[1ULL << pop_lsb(&b)]; - Zobrist::castle[cr] ^= k ? k : rk.rand(); + Key k = Zobrist::castling[1ULL << pop_lsb(&b)]; + Zobrist::castling[cf] ^= k ? k : rk.rand(); } } @@ -266,7 +263,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { else continue; - set_castle_right(c, rsq); + set_castling_flag(c, rsq); } // 4. En passant square. Ignore if no pawn capture is possible @@ -300,30 +297,30 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { } -/// Position::set_castle_right() is an helper function used to set castling -/// rights given the corresponding color and the rook starting square. +/// Position::set_castling_flag() is an helper function used to set castling +/// flags given the corresponding color and the rook starting square. -void Position::set_castle_right(Color c, Square rfrom) { +void Position::set_castling_flag(Color c, Square rfrom) { Square kfrom = king_square(c); CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE; - CastleRight cr = make_castle_right(c, cs); + CastlingFlag cf = make_castling_flag(c, cs); - st->castleRights |= cr; - castleRightsMask[kfrom] |= cr; - castleRightsMask[rfrom] |= cr; - castleRookSquare[c][cs] = rfrom; + st->castlingFlags |= cf; + castlingFlagsMask[kfrom] |= cf; + castlingFlagsMask[rfrom] |= cf; + castlingRookSquare[c][cs] = rfrom; Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1); Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1); for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s) if (s != kfrom && s != rfrom) - castlePath[c][cs] |= s; + castlingPath[c][cs] |= s; for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s) if (s != kfrom && s != rfrom) - castlePath[c][cs] |= s; + castlingPath[c][cs] |= s; } @@ -360,18 +357,18 @@ const string Position::fen() const { ss << (sideToMove == WHITE ? " w " : " b "); if (can_castle(WHITE_OO)) - ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE)), false) : 'K'); + ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, KING_SIDE)), false) : 'K'); if (can_castle(WHITE_OOO)) - ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q'); + ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q'); if (can_castle(BLACK_OO)) - ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE)), true) : 'k'); + ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, KING_SIDE)), true) : 'k'); if (can_castle(BLACK_OOO)) - ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE)), true) : 'q'); + ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, QUEEN_SIDE)), true) : 'q'); - if (st->castleRights == CASTLES_NONE) + if (st->castlingFlags == NO_CASTLING) ss << '-'; ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ") @@ -455,29 +452,12 @@ Bitboard Position::attackers_to(Square s, Bitboard occ) const { } -/// Position::attacks_from() computes a bitboard of all attacks of a given piece -/// put in a given square. Slider attacks use occ bitboard as occupancy. - -Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) { - - assert(is_ok(s)); - - switch (type_of(p)) - { - case BISHOP: return attacks_bb(s, occ); - case ROOK : return attacks_bb(s, occ); - case QUEEN : return attacks_bb(s, occ) | attacks_bb(s, occ); - default : return StepAttacksBB[p][s]; - } -} - - /// Position::legal() tests whether a pseudo-legal move is legal bool Position::legal(Move m, Bitboard pinned) const { assert(is_ok(m)); - assert(pinned == pinned_pieces(pos.side_to_move())); + assert(pinned == pinned_pieces(sideToMove)); Color us = sideToMove; Square from = from_sq(m); @@ -509,13 +489,13 @@ bool Position::legal(Move m, Bitboard pinned) const { // square is attacked by the opponent. Castling moves are checked // for legality during move generation. if (type_of(piece_on(from)) == KING) - return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us)); + return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us)); // A non-king move is legal if and only if it is not pinned or it // is moving along the ray towards or away from the king. return !pinned || !(pinned & from) - || squares_aligned(from, to_sq(m), king_square(us)); + || aligned(from, to_sq(m), king_square(us)); } @@ -653,14 +633,11 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { if (ci.checkSq[pt] & to) return true; - // Discovery check ? - if (unlikely(ci.dcCandidates) && (ci.dcCandidates & from)) - { - // For pawn and king moves we need to verify also direction - if ( (pt != PAWN && pt != KING) - || !squares_aligned(from, to, king_square(~sideToMove))) - return true; - } + // Discovered check ? + if ( unlikely(ci.dcCandidates) + && (ci.dcCandidates & from) + && !aligned(from, to, king_square(~sideToMove))) + return true; // Can we skip the ugly special cases ? if (type_of(m) == NORMAL) @@ -672,7 +649,7 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { switch (type_of(m)) { case PROMOTION: - return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq; + return attacks_bb(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 @@ -686,10 +663,10 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK)) | (attacks_bb(ksq, b) & pieces(us, QUEEN, BISHOP)); } - case CASTLE: + case CASTLING: { Square kfrom = from; - Square rfrom = to; // 'King captures the rook' notation + Square rfrom = to; // Castling is encoded as 'King captures the rook' Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1); Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1); @@ -747,20 +724,20 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); assert(color_of(pc) == us); - assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLE); + assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING); assert(captured != KING); - if (type_of(m) == CASTLE) + if (type_of(m) == CASTLING) { assert(pc == make_piece(us, KING)); bool kingSide = to > from; - Square rfrom = to; // Castle is encoded as "king captures friendly rook" + Square rfrom = to; // Castling is encoded as "king captures friendly rook" Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1); to = relative_square(us, kingSide ? SQ_G1 : SQ_C1); captured = NO_PIECE_TYPE; - do_castle(from, to, rfrom, rto); + do_castling(from, to, rfrom, rto); st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom]; k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto]; @@ -817,19 +794,19 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->epSquare = SQ_NONE; } - // Update castle rights if needed - if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to])) + // Update castling flags if needed + if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to])) { - int cr = castleRightsMask[from] | castleRightsMask[to]; - k ^= Zobrist::castle[st->castleRights & cr]; - st->castleRights &= ~cr; + int cf = castlingFlagsMask[from] | castlingFlagsMask[to]; + k ^= Zobrist::castling[st->castlingFlags & cf]; + st->castlingFlags &= ~cf; } // Prefetch TT access as soon as we know the new hash key prefetch((char*)TT.first_entry(k)); - // Move the piece. The tricky Chess960 castle is handled earlier - if (type_of(m) != CASTLE) + // Move the piece. The tricky Chess960 castling is handled earlier + if (type_of(m) != CASTLING) move_piece(from, to, us, pt); // If the moving piece is a pawn do some special extra work @@ -930,7 +907,7 @@ void Position::undo_move(Move m) { PieceType pt = type_of(piece_on(to)); PieceType captured = st->capturedType; - assert(empty(from) || type_of(m) == CASTLE); + assert(empty(from) || type_of(m) == CASTLING); assert(captured != KING); if (type_of(m) == PROMOTION) @@ -946,15 +923,15 @@ void Position::undo_move(Move m) { pt = PAWN; } - if (type_of(m) == CASTLE) + if (type_of(m) == CASTLING) { bool kingSide = to > from; - Square rfrom = to; // Castle is encoded as "king captures friendly rook" + Square rfrom = to; // Castling is encoded as "king captures friendly rook" Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1); to = relative_square(us, kingSide ? SQ_G1 : SQ_C1); captured = NO_PIECE_TYPE; pt = KING; - do_castle(to, from, rto, rfrom); + do_castling(to, from, rto, rfrom); } else move_piece(to, from, us, pt); // Put the piece back at the source square @@ -984,10 +961,10 @@ void Position::undo_move(Move m) { } -/// Position::do_castle() is a helper used to do/undo a castling move. This +/// Position::do_castling() is a helper used to do/undo a castling move. This /// is a bit tricky, especially in Chess960. -void Position::do_castle(Square kfrom, Square kto, Square rfrom, Square rto) { +void Position::do_castling(Square kfrom, Square kto, Square rfrom, Square rto) { // Remove both pieces first since squares could overlap in Chess960 remove_piece(kfrom, sideToMove, KING); @@ -1071,10 +1048,10 @@ int Position::see(Move m, int asymmThreshold) const { stm = color_of(piece_on(from)); occupied = pieces() ^ from; - // Castle moves are implemented as king capturing the rook so cannot be + // Castling moves are implemented as king capturing the rook so cannot be // handled correctly. Simply return 0 that is always the correct value // unless in the rare case the rook ends up under attack. - if (type_of(m) == CASTLE) + if (type_of(m) == CASTLING) return 0; if (type_of(m) == ENPASSANT) @@ -1162,7 +1139,7 @@ void Position::clear() { Key Position::compute_key() const { - Key k = Zobrist::castle[st->castleRights]; + Key k = Zobrist::castling[st->castlingFlags]; for (Bitboard b = pieces(); b; ) { @@ -1349,7 +1326,7 @@ bool Position::pos_is_ok(int* failedStep) const { const bool debugNonPawnMaterial = all || false; const bool debugPieceCounts = all || false; const bool debugPieceList = all || false; - const bool debugCastleSquares = all || false; + const bool debugCastlingSquares = all || false; *step = 1; @@ -1433,18 +1410,18 @@ bool Position::pos_is_ok(int* failedStep) const { || index[pieceList[c][pt][i]] != i) return false; - if ((*step)++, debugCastleSquares) + if ((*step)++, debugCastlingSquares) for (Color c = WHITE; c <= BLACK; ++c) for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) { - CastleRight cr = make_castle_right(c, s); + CastlingFlag cf = make_castling_flag(c, s); - if (!can_castle(cr)) + if (!can_castle(cf)) continue; - if ( (castleRightsMask[king_square(c)] & cr) != cr - || piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK) - || castleRightsMask[castleRookSquare[c][s]] != cr) + if ( (castlingFlagsMask[king_square(c)] & cf) != cf + || piece_on(castlingRookSquare[c][s]) != make_piece(c, ROOK) + || castlingFlagsMask[castlingRookSquare[c][s]] != cf) return false; }