Correctly define operators in types.h

[stockfish] / src / types.h

diff --git a/src/types.h b/src/types.h
index 9ac0787e1c08b045c6f45b48c3f15c43395e8a7a..ff7cc76684b7b5eb17b7a4b6c3bafdde55df80df 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -46,9 +46,6 @@ typedef unsigned __int64 uint64_t;
 
 #endif
 
-#define Min(x, y) (((x) < (y)) ? (x) : (y))
-#define Max(x, y) (((x) < (y)) ? (y) : (x))
-
 ////
 //// Configuration
 ////
@@ -158,9 +155,53 @@ const bool CpuIs64Bit = false;
 typedef uint64_t Key;
 typedef uint64_t Bitboard;
 
+const int MAX_MOVES = 256;
 const int PLY_MAX = 100;
 const int PLY_MAX_PLUS_2 = PLY_MAX + 2;
 
+const Bitboard FileABB = 0x0101010101010101ULL;
+const Bitboard FileBBB = FileABB << 1;
+const Bitboard FileCBB = FileABB << 2;
+const Bitboard FileDBB = FileABB << 3;
+const Bitboard FileEBB = FileABB << 4;
+const Bitboard FileFBB = FileABB << 5;
+const Bitboard FileGBB = FileABB << 6;
+const Bitboard FileHBB = FileABB << 7;
+
+const Bitboard Rank1BB = 0xFF;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
+
+/// A move needs 16 bits to be stored
+///
+/// bit  0- 5: destination square (from 0 to 63)
+/// bit  6-11: origin square (from 0 to 63)
+/// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2)
+/// bit 14-15: special move flag: promotion (1), en passant (2), castle (3)
+///
+/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in because in
+/// any normal move destination square is always different from origin square
+/// while MOVE_NONE and MOVE_NULL have the same origin and destination square.
+
+enum Move {
+  MOVE_NONE = 0,
+  MOVE_NULL = 65
+};
+
+struct MoveStack {
+  Move move;
+  int score;
+};
+
+inline bool operator<(const MoveStack& f, const MoveStack& s) {
+  return f.score < s.score;
+}
+
 enum ValueType {
   VALUE_TYPE_NONE  = 0,
   VALUE_TYPE_UPPER = 1,
@@ -246,7 +287,7 @@ enum SquareColor {
 };
 
 enum ScaleFactor {
-  SCALE_FACTOR_ZERO   = 0,
+  SCALE_FACTOR_DRAW   = 0,
   SCALE_FACTOR_NORMAL = 64,
   SCALE_FACTOR_MAX    = 128,
   SCALE_FACTOR_NONE   = 255
@@ -282,10 +323,10 @@ inline T operator/ (const T d, int i) { return T(int(d) / i); } \
 inline T operator- (const T d) { return T(-int(d)); } \
 inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \
 inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \
-inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \
-inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \
-inline void operator*= (T& d, int i) { d = T(int(d) * i); } \
-inline void operator/= (T& d, int i) { d = T(int(d) / i); }
+inline T& operator+= (T& d1, const T d2) { d1 = d1 + d2; return d1; } \
+inline T& operator-= (T& d1, const T d2) { d1 = d1 - d2; return d1; } \
+inline T& operator*= (T& d, int i) { d = T(int(d) * i); return d; } \
+inline T& operator/= (T& d, int i) { d = T(int(d) / i); return d; }
 
 ENABLE_OPERATORS_ON(Value)
 ENABLE_OPERATORS_ON(PieceType)
@@ -452,4 +493,73 @@ inline Square pawn_push(Color c) {
   return c == WHITE ? DELTA_N : DELTA_S;
 }
 
+// An helper insertion sort implementation, works with pointers and iterators
+template<typename T, typename K>
+inline void sort(K firstMove, K lastMove)
+{
+  T value;
+  K cur, p, d;
+
+  if (firstMove != lastMove)
+      for (cur = firstMove + 1; cur != lastMove; cur++)
+      {
+          p = d = cur;
+          value = *p--;
+          if (*p < value)
+          {
+              do *d = *p;
+              while (--d != firstMove && *--p < value);
+              *d = value;
+          }
+      }
+}
+
+inline Square move_from(Move m) {
+  return Square((m >> 6) & 0x3F);
+}
+
+inline Square move_to(Move m) {
+  return Square(m & 0x3F);
+}
+
+inline bool is_special(Move m) {
+  return m & (3 << 14);
+}
+
+inline bool is_promotion(Move m) {
+  return (m & (3 << 14)) == (1 << 14);
+}
+
+inline int is_enpassant(Move m) {
+  return (m & (3 << 14)) == (2 << 14);
+}
+
+inline int is_castle(Move m) {
+  return (m & (3 << 14)) == (3 << 14);
+}
+
+inline PieceType promotion_piece_type(Move m) {
+  return PieceType(((m >> 12) & 3) + 2);
+}
+
+inline Move make_move(Square from, Square to) {
+  return Move(to | (from << 6));
+}
+
+inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
+  return Move(to | (from << 6) | (1 << 14) | ((promotion - 2) << 12)) ;
+}
+
+inline Move make_enpassant_move(Square from, Square to) {
+  return Move(to | (from << 6) | (2 << 14));
+}
+
+inline Move make_castle_move(Square from, Square to) {
+  return Move(to | (from << 6) | (3 << 14));
+}
+
+inline bool is_ok(Move m) {
+  return move_from(m) != move_to(m); // Catches also MOVE_NULL and MOVE_NONE
+}
+
 #endif // !defined(TYPES_H_INCLUDED)