X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.h;h=cd297df737839e15967b37a280f7cc054c8a70c0;hp=512313921458cae7d843214644026f2d7399fe25;hb=034a2b04f2fc1017721b4f3fc12895e5f8a190bd;hpb=002062ae934c1fae3e56157e8e7e6451b552ada5 diff --git a/src/position.h b/src/position.h index 51231392..cd297df7 100644 --- a/src/position.h +++ b/src/position.h @@ -43,10 +43,10 @@ struct CheckInfo { }; -/// The StateInfo struct stores information we need to restore a Position +/// The StateInfo struct stores information needed to restore a Position /// object to its previous state when we retract a move. Whenever a move -/// is made on the board (by calling Position::do_move), a StateInfo object -/// must be passed as a parameter. +/// is made on the board (by calling Position::do_move), a StateInfo +/// object must be passed as a parameter. struct StateInfo { Key pawnKey, materialKey; @@ -67,27 +67,10 @@ struct StateInfo { const size_t StateCopySize64 = offsetof(StateInfo, key) / sizeof(uint64_t) + 1; -/// The position data structure. A position consists of the following data: -/// -/// * For each piece type, a bitboard representing the squares occupied -/// by pieces of that type. -/// * For each color, a bitboard representing the squares occupied by -/// pieces of that color. -/// * A bitboard of all occupied squares. -/// * A bitboard of all checking pieces. -/// * A 64-entry array of pieces, indexed by the squares of the board. -/// * The current side to move. -/// * Information about the castling rights for both sides. -/// * The initial files of the kings and both pairs of rooks. This is -/// used to implement the Chess960 castling rules. -/// * The en passant square (which is SQ_NONE if no en passant capture is -/// possible). -/// * The squares of the kings for both sides. -/// * Hash keys for the position itself, the current pawn structure, and -/// the current material situation. -/// * Hash keys for all previous positions in the game for detecting -/// repetition draws. -/// * A counter for detecting 50 move rule draws. +/// The Position class stores the information regarding the board representation +/// like pieces, side to move, hash keys, castling info, etc. The most important +/// methods are do_move() and undo_move(), used by the search to update node info +/// when traversing the search tree. class Position { public: @@ -112,7 +95,7 @@ public: Piece piece_on(Square s) const; Square king_square(Color c) const; Square ep_square() const; - bool is_empty(Square s) const; + bool empty(Square s) const; template int count(Color c) const; template const Square* list(Color c) const; @@ -125,31 +108,30 @@ public: // Checking Bitboard checkers() const; Bitboard discovered_check_candidates() const; - Bitboard pinned_pieces() const; + Bitboard pinned_pieces(Color toMove) const; // Attacks to/from a given square Bitboard attackers_to(Square s) const; Bitboard attackers_to(Square s, Bitboard occ) const; Bitboard attacks_from(Piece p, Square s) const; - static Bitboard attacks_from(Piece p, Square s, Bitboard occ); template Bitboard attacks_from(Square s) const; template Bitboard attacks_from(Square s, Color c) const; // Properties of moves - bool move_gives_check(Move m, const CheckInfo& ci) const; - bool pl_move_is_legal(Move m, Bitboard pinned) const; - bool is_pseudo_legal(const Move m) const; - bool is_capture(Move m) const; - bool is_capture_or_promotion(Move m) const; - bool is_passed_pawn_push(Move m) const; - Piece piece_moved(Move m) const; + bool legal(Move m, Bitboard pinned) const; + bool pseudo_legal(const Move m) const; + bool capture(Move m) const; + bool capture_or_promotion(Move m) const; + bool gives_check(Move m, const CheckInfo& ci) const; + bool passed_pawn_push(Move m) const; + Piece moved_piece(Move m) const; PieceType captured_piece_type() const; // Piece specific - bool pawn_is_passed(Color c, Square s) const; + bool pawn_passed(Color c, Square s) const; bool pawn_on_7th(Color c) const; - bool opposite_bishops() const; bool bishop_pair(Color c) const; + bool opposite_bishops() const; // Doing and undoing moves void do_move(Move m, StateInfo& st); @@ -188,12 +170,14 @@ public: private: // Initialization helpers (used while setting up a position) void clear(); - void put_piece(Piece p, Square s); void set_castle_right(Color c, Square rfrom); // Helper functions void do_castle(Square kfrom, Square kto, Square rfrom, Square rto); - Bitboard hidden_checkers(Square ksq, Color c) const; + Bitboard hidden_checkers(Square ksq, Color c, Color toMove) const; + void put_piece(Square s, Color c, PieceType pt); + void remove_piece(Square s, Color c, PieceType pt); + void move_piece(Square from, Square to, Color c, PieceType pt); // Computing hash keys from scratch (for initialization and debugging) Key compute_key() const; @@ -237,11 +221,11 @@ inline Piece Position::piece_on(Square s) const { return board[s]; } -inline Piece Position::piece_moved(Move m) const { +inline Piece Position::moved_piece(Move m) const { return board[from_sq(m)]; } -inline bool Position::is_empty(Square s) const { +inline bool Position::empty(Square s) const { return board[s] == NO_PIECE; } @@ -319,7 +303,7 @@ inline Bitboard Position::attacks_from(Square s, Color c) const { } inline Bitboard Position::attacks_from(Piece p, Square s) const { - return attacks_from(p, s, byTypeBB[ALL_PIECES]); + return attacks_bb(p, s, byTypeBB[ALL_PIECES]); } inline Bitboard Position::attackers_to(Square s) const { @@ -331,17 +315,23 @@ inline Bitboard Position::checkers() const { } inline Bitboard Position::discovered_check_candidates() const { - return hidden_checkers(king_square(~sideToMove), sideToMove); + return hidden_checkers(king_square(~sideToMove), sideToMove, sideToMove); } -inline Bitboard Position::pinned_pieces() const { - return hidden_checkers(king_square(sideToMove), ~sideToMove); +inline Bitboard Position::pinned_pieces(Color toMove) const { + return hidden_checkers(king_square(toMove), ~toMove, toMove); } -inline bool Position::pawn_is_passed(Color c, Square s) const { +inline bool Position::pawn_passed(Color c, Square s) const { return !(pieces(~c, PAWN) & passed_pawn_mask(c, s)); } +inline bool Position::passed_pawn_push(Move m) const { + + return type_of(moved_piece(m)) == PAWN + && pawn_passed(sideToMove, to_sq(m)); +} + inline Key Position::key() const { return st->key; } @@ -362,12 +352,6 @@ inline Value Position::non_pawn_material(Color c) const { return st->npMaterial[c]; } -inline bool Position::is_passed_pawn_push(Move m) const { - - return type_of(piece_moved(m)) == PAWN - && pawn_is_passed(sideToMove, to_sq(m)); -} - inline int Position::game_ply() const { return gamePly; } @@ -393,17 +377,17 @@ inline bool Position::is_chess960() const { return chess960; } -inline bool Position::is_capture_or_promotion(Move m) const { +inline bool Position::capture_or_promotion(Move m) const { assert(is_ok(m)); - return type_of(m) ? type_of(m) != CASTLE : !is_empty(to_sq(m)); + return type_of(m) ? type_of(m) != CASTLE : !empty(to_sq(m)); } -inline bool Position::is_capture(Move m) const { +inline bool Position::capture(Move m) const { // Note that castle is coded as "king captures the rook" assert(is_ok(m)); - return (!is_empty(to_sq(m)) && type_of(m) != CASTLE) || type_of(m) == ENPASSANT; + return (!empty(to_sq(m)) && type_of(m) != CASTLE) || type_of(m) == ENPASSANT; } inline PieceType Position::captured_piece_type() const { @@ -414,4 +398,46 @@ inline Thread* Position::this_thread() const { return thisThread; } +inline void Position::put_piece(Square s, Color c, PieceType pt) { + + board[s] = make_piece(c, pt); + byTypeBB[ALL_PIECES] |= s; + byTypeBB[pt] |= s; + byColorBB[c] |= s; + pieceCount[c][ALL_PIECES]++; + index[s] = pieceCount[c][pt]++; + pieceList[c][pt][index[s]] = s; +} + +inline void Position::move_piece(Square from, Square to, Color c, PieceType pt) { + + // index[from] is not updated and becomes stale. This works as long + // as index[] is accessed just by known occupied squares. + Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to]; + byTypeBB[ALL_PIECES] ^= from_to_bb; + byTypeBB[pt] ^= from_to_bb; + byColorBB[c] ^= from_to_bb; + board[from] = NO_PIECE; + board[to] = make_piece(c, pt); + index[to] = index[from]; + pieceList[c][pt][index[to]] = to; +} + +inline void Position::remove_piece(Square s, Color c, PieceType pt) { + + // WARNING: This is not a reversible operation. If we remove a piece in + // do_move() and then replace it in undo_move() we will put it at the end of + // the list and not in its original place, it means index[] and pieceList[] + // are not guaranteed to be invariant to a do_move() + undo_move() sequence. + byTypeBB[ALL_PIECES] ^= s; + byTypeBB[pt] ^= s; + byColorBB[c] ^= s; + /* board[s] = NO_PIECE; */ // Not needed, will be overwritten by capturing + pieceCount[c][ALL_PIECES]--; + Square lastSquare = pieceList[c][pt][--pieceCount[c][pt]]; + index[lastSquare] = index[s]; + pieceList[c][pt][index[lastSquare]] = lastSquare; + pieceList[c][pt][pieceCount[c][pt]] = SQ_NONE; +} + #endif // #ifndef POSITION_H_INCLUDED