Convert constants to decimal representation

[stockfish] / src / position.h

diff --git a/src/position.h b/src/position.h
index 2db3d9653cafb86ca88d994d94c537d4ba081b11..df97ab2c35e759db06e330dd983989fd993819ff 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -87,11 +87,12 @@ class Position {
 public:
   Position() {}
   Position(const Position& p) { *this = p; }
-  Position(const std::string& f, bool c960) { from_fen(f, c960); }
-  Position& operator=(const Position&);
+  Position(const Position& p, Thread* t) { *this = p; thisThread = t; }
+  Position(const std::string& f, bool c960, Thread* t) { from_fen(f, c960, t); }
+  void 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;
 
@@ -105,15 +106,15 @@ public:
   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;
@@ -171,6 +172,7 @@ public:
   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;
@@ -211,13 +213,14 @@ private:
   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;
 
@@ -246,7 +249,7 @@ inline Piece Position::piece_moved(Move m) const {
   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;
 }
 
@@ -294,20 +297,20 @@ inline Square Position::king_square(Color c) 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 {
+inline int Position::can_castle(Color c) const {
   return st->castleRights & ((WHITE_OO | WHITE_OOO) << 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>
@@ -413,18 +416,22 @@ 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 is_special(m) ? !is_castle(m) : !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)) && !is_castle(m)) || is_enpassant(m);
 }
 
 inline PieceType Position::captured_piece_type() const {
   return st->capturedType;
 }
 
+inline Thread* Position::this_thread() const {
+  return thisThread;
+}
+
 #endif // !defined(POSITION_H_INCLUDED)