StateInfo* previous;
};
+struct ReducedStateInfo {
+ Key pawnKey, materialKey;
+ Value npMaterial[2];
+ int castleRights, rule50, pliesFromNull;
+ Score psqScore;
+ Square epSquare;
+};
+
/// The position data structure. A position consists of the following data:
///
public:
Position() {}
Position(const Position& p) { *this = p; }
- Position(const std::string& f, bool c960) { from_fen(f, c960); }
+ Position(const Position& p, Thread* t) { *this = p; thisThread = t; }
+ Position(const std::string& f, bool c960, Thread* t) { from_fen(f, c960, t); }
Position& operator=(const Position&);
// Text input/output
- void from_fen(const std::string& fen, bool isChess960);
+ void from_fen(const std::string& fen, bool isChess960, Thread* th);
const std::string to_fen() const;
void print(Move m = MOVE_NONE) const;
// Position representation
Bitboard pieces() const;
- Bitboard pieces(Color c) const;
Bitboard pieces(PieceType pt) const;
- Bitboard pieces(PieceType pt, Color c) const;
Bitboard pieces(PieceType pt1, PieceType pt2) const;
- Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
+ Bitboard pieces(Color c) const;
+ Bitboard pieces(Color c, PieceType pt) const;
+ Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
Piece piece_on(Square s) const;
Square king_square(Color c) const;
Square ep_square() const;
- bool square_empty(Square s) const;
+ bool is_empty(Square s) const;
const Square* piece_list(Color c, PieceType pt) const;
int piece_count(Color c, PieceType pt) const;
// Castling
- bool can_castle(CastleRight f) const;
- bool can_castle(Color c) const;
- bool castle_impeded(CastleRight f) const;
- Square castle_rook_square(CastleRight f) const;
+ int can_castle(CastleRight f) const;
+ int can_castle(Color c) const;
+ bool castle_impeded(Color c, CastlingSide s) const;
+ Square castle_rook_square(Color c, CastlingSide s) const;
// Checking
bool in_check() const;
// Properties of moves
bool move_gives_check(Move m, const CheckInfo& ci) const;
bool move_attacks_square(Move m, Square s) const;
+ bool move_is_legal(const Move m) 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;
Color side_to_move() const;
int startpos_ply_counter() const;
bool is_chess960() const;
+ Thread* this_thread() const;
int64_t nodes_searched() const;
void set_nodes_searched(int64_t n);
template<bool SkipRepetition> bool is_draw() const;
void clear();
void put_piece(Piece p, Square s);
void set_castle_right(Color c, Square rfrom);
- bool move_is_legal(const Move m) const;
// Helper template functions
template<bool Do> void do_castle_move(Move m);
int index[64]; // [square]
// Other info
- int castleRightsMask[64]; // [square]
- Square castleRookSquare[16]; // [castleRight]
- Bitboard castlePath[16]; // [castleRight]
+ int castleRightsMask[64]; // [square]
+ Square castleRookSquare[2][2]; // [color][side]
+ Bitboard castlePath[2][2]; // [color][side]
StateInfo startState;
int64_t nodes;
int startPosPly;
Color sideToMove;
+ Thread* thisThread;
StateInfo* st;
int chess960;
return board[from_sq(m)];
}
-inline bool Position::square_empty(Square s) const {
+inline bool Position::is_empty(Square s) const {
return board[s] == NO_PIECE;
}
return byTypeBB[ALL_PIECES];
}
-inline Bitboard Position::pieces(Color c) const {
- return byColorBB[c];
-}
-
inline Bitboard Position::pieces(PieceType pt) const {
return byTypeBB[pt];
}
-inline Bitboard Position::pieces(PieceType pt, Color c) const {
- return byTypeBB[pt] & byColorBB[c];
-}
-
inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
return byTypeBB[pt1] | byTypeBB[pt2];
}
-inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
- return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
+inline Bitboard Position::pieces(Color c) const {
+ return byColorBB[c];
+}
+
+inline Bitboard Position::pieces(Color c, PieceType pt) const {
+ return byColorBB[c] & byTypeBB[pt];
+}
+
+inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
+ return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
}
inline int Position::piece_count(Color c, PieceType pt) const {
return pieceList[c][KING][0];
}
-inline bool Position::can_castle(CastleRight f) const {
+inline int Position::can_castle(CastleRight f) const {
return st->castleRights & f;
}
-inline bool Position::can_castle(Color c) const {
- return st->castleRights & ((WHITE_OO | WHITE_OOO) << c);
+inline int Position::can_castle(Color c) const {
+ return st->castleRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
}
-inline bool Position::castle_impeded(CastleRight f) const {
- return byTypeBB[ALL_PIECES] & castlePath[f];
+inline bool Position::castle_impeded(Color c, CastlingSide s) const {
+ return byTypeBB[ALL_PIECES] & castlePath[c][s];
}
-inline Square Position::castle_rook_square(CastleRight f) const {
- return castleRookSquare[f];
+inline Square Position::castle_rook_square(Color c, CastlingSide s) const {
+ return castleRookSquare[c][s];
}
template<PieceType Pt>
}
inline bool Position::pawn_is_passed(Color c, Square s) const {
- return !(pieces(PAWN, ~c) & passed_pawn_mask(c, s));
+ return !(pieces(~c, PAWN) & passed_pawn_mask(c, s));
}
inline Key Position::key() const {
}
inline bool Position::pawn_on_7th(Color c) const {
- return pieces(PAWN, c) & rank_bb(relative_rank(c, RANK_7));
+ return pieces(c, PAWN) & rank_bb(relative_rank(c, RANK_7));
}
inline bool Position::is_chess960() const {
inline bool Position::is_capture_or_promotion(Move m) const {
assert(is_ok(m));
- return is_special(m) ? !is_castle(m) : !square_empty(to_sq(m));
+ return type_of(m) ? type_of(m) != CASTLE : !is_empty(to_sq(m));
}
inline bool Position::is_capture(Move m) const {
// Note that castle is coded as "king captures the rook"
assert(is_ok(m));
- return (!square_empty(to_sq(m)) && !is_castle(m)) || is_enpassant(m);
+ return (!is_empty(to_sq(m)) && type_of(m) != CASTLE) || type_of(m) == ENPASSANT;
}
inline PieceType Position::captured_piece_type() const {
return st->capturedType;
}
+inline Thread* Position::this_thread() const {
+ return thisThread;
+}
+
#endif // !defined(POSITION_H_INCLUDED)