Retire Position::set_castling_rights()

[stockfish] / src / position.h

diff --git a/src/position.h b/src/position.h
index 431d059c7efb2570305b752807dc10ac60c2266e..d6c79ee181840553b6858c6dcfcf5416898db506 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -48,10 +48,10 @@ class Position;
 
 struct StateInfo {
   Key pawnKey, materialKey;
-  int castleRights, rule50, gamePly, pliesFromNull;
-  Square epSquare;
-  Score value;
   Value npMaterial[2];
+  int castleRights, rule50, pliesFromNull;
+  Score value;
+  Square epSquare;
 
   Key key;
   Bitboard checkersBB;
@@ -148,13 +148,13 @@ public:
   template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // Properties of moves
-  bool pl_move_is_legal(Move m, Bitboard pinned) const;
-  bool move_is_pl(const Move m) const;
   bool move_gives_check(Move m, const CheckInfo& ci) const;
-  bool move_is_capture(Move m) const;
-  bool move_is_capture_or_promotion(Move m) const;
-  bool move_is_passed_pawn_push(Move m) const;
   bool move_attacks_square(Move m, Square s) 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 captured with previous moves
   PieceType captured_piece_type() const;
@@ -163,7 +163,6 @@ public:
   bool pawn_is_passed(Color c, Square s) const;
 
   // Doing and undoing moves
-  void do_setup_move(Move m, StateInfo& st);
   void do_move(Move m, StateInfo& st);
   void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
   void undo_move(Move m);
@@ -189,7 +188,7 @@ public:
   bool is_mate() const;
   template<bool SkipRepetition> bool is_draw() const;
 
-  // Number of plies from starting position
+  // Plies from start position to the beginning of search
   int startpos_ply_counter() const;
 
   // Other properties of the position
@@ -204,8 +203,8 @@ public:
   void set_nodes_searched(int64_t n);
 
   // Position consistency check, for debugging
-  bool is_ok(int* failedStep = NULL) const;
-  void flip();
+  bool pos_is_ok(int* failedStep = NULL) const;
+  void flip_me();
 
   // Global initialization
   static void init();
@@ -215,8 +214,7 @@ private:
   // Initialization helper functions (used while setting up a position)
   void clear();
   void put_piece(Piece p, Square s);
-  void set_castle(int f, Square ksq, Square rsq);
-  void set_castling_rights(char token);
+  void set_castle_right(Square ksq, Square rsq);
   bool move_is_legal(const Move m) const;
 
   // Helper functions for doing and undoing moves
@@ -256,15 +254,15 @@ private:
   Square castleRookSquare[16]; // [castleRight]
   StateInfo startState;
   int64_t nodes;
+  int startPosPly;
   Color sideToMove;
-  int fullMoves;
   int threadID;
   StateInfo* st;
   int chess960;
 
   // Static variables
   static Score pieceSquareTable[16][64]; // [piece][square]
-  static Key zobrist[2][8][64];          // [color][pieceType][square]
+  static Key zobrist[2][8][64];          // [color][pieceType][square]/[piece count]
   static Key zobEp[64];                  // [square]
   static Key zobCastle[16];              // [castleRight]
   static Key zobSideToMove;
@@ -284,7 +282,7 @@ inline Piece Position::piece_on(Square s) const {
 }
 
 inline bool Position::square_is_empty(Square s) const {
-  return piece_on(s) == PIECE_NONE;
+  return board[s] == PIECE_NONE;
 }
 
 inline Color Position::side_to_move() const {
@@ -296,7 +294,7 @@ inline Bitboard Position::occupied_squares() const {
 }
 
 inline Bitboard Position::empty_squares() const {
-  return ~occupied_squares();
+  return ~byTypeBB[0];
 }
 
 inline Bitboard Position::pieces(Color c) const {
@@ -372,16 +370,24 @@ inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
   return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
 }
 
+inline Bitboard Position::attacks_from(Piece p, Square s) const {
+  return attacks_from(p, s, occupied_squares());
+}
+
+inline Bitboard Position::attackers_to(Square s) const {
+  return attackers_to(s, occupied_squares());
+}
+
 inline Bitboard Position::checkers() const {
   return st->checkersBB;
 }
 
 inline bool Position::in_check() const {
-  return st->checkersBB != EmptyBoardBB;
+  return st->checkersBB != 0;
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
+  return !(pieces(PAWN, flip(c)) & passed_pawn_mask(c, s));
 }
 
 inline Key Position::get_key() const {
@@ -416,22 +422,21 @@ inline Value Position::non_pawn_material(Color c) const {
   return st->npMaterial[c];
 }
 
-inline bool Position::move_is_passed_pawn_push(Move m) const {
+inline bool Position::is_passed_pawn_push(Move m) const {
 
-  Color c = side_to_move();
-  return   piece_on(move_from(m)) == make_piece(c, PAWN)
-        && pawn_is_passed(c, move_to(m));
+  return   board[move_from(m)] == make_piece(sideToMove, PAWN)
+        && pawn_is_passed(sideToMove, move_to(m));
 }
 
 inline int Position::startpos_ply_counter() const {
-  return Max(2 * (fullMoves - 1), 0) + int(sideToMove == BLACK);
+  return startPosPly + st->pliesFromNull; // HACK
 }
 
 inline bool Position::opposite_colored_bishops() const {
 
-  return   piece_count(WHITE, BISHOP) == 1
-        && piece_count(BLACK, BISHOP) == 1
-        && opposite_color_squares(piece_list(WHITE, BISHOP)[0], piece_list(BLACK, BISHOP)[0]);
+  return   pieceCount[WHITE][BISHOP] == 1
+        && pieceCount[BLACK][BISHOP] == 1
+        && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
 }
 
 inline bool Position::has_pawn_on_7th(Color c) const {
@@ -442,17 +447,17 @@ inline bool Position::is_chess960() const {
   return chess960;
 }
 
-inline bool Position::move_is_capture_or_promotion(Move m) const {
+inline bool Position::is_capture_or_promotion(Move m) const {
 
-  assert(move_is_ok(m));
-  return move_is_special(m) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+  assert(is_ok(m));
+  return is_special(m) ? !is_castle(m) : !square_is_empty(move_to(m));
 }
 
-inline bool Position::move_is_capture(Move m) const {
+inline bool Position::is_capture(Move m) const {
 
   // Note that castle is coded as "king captures the rook"
-  assert(move_is_ok(m));
-  return (!square_is_empty(move_to(m)) && !move_is_castle(m)) || move_is_ep(m);
+  assert(is_ok(m));
+  return (!square_is_empty(move_to(m)) && !is_castle(m)) || is_enpassant(m);
 }
 
 inline PieceType Position::captured_piece_type() const {