From 52a373a4778109c8bfb776c94e85c64238dcf74e Mon Sep 17 00:00:00 2001
From: Fabian Fichter <ianfab@users.noreply.github.com>
Date: Sat, 13 Apr 2019 16:41:22 +0200
Subject: [PATCH] Introduce rider types

No functional change.
---
 src/bitboard.cpp |   23 +++++++++++++++++++++++
 src/bitboard.h   |   16 ++++++++++++++--
 src/types.h      |   18 ++++++++++++++++++
 3 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index c0e0960..0c4c3d9 100644
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -35,6 +35,8 @@ Bitboard PseudoMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
 Bitboard LeaperAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
 Bitboard LeaperMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
 Bitboard BoardSizeBB[FILE_NB][RANK_NB];
+RiderType AttackRiderTypes[PIECE_TYPE_NB];
+RiderType MoveRiderTypes[PIECE_TYPE_NB];
 
 Magic RookMagics[SQUARE_NB];
 Magic BishopMagics[SQUARE_NB];
@@ -350,6 +352,27 @@ const std::string Bitboards::pretty(Bitboard b) {
 
 void Bitboards::init() {
 
+  // Initialize rider types
+  for (PieceType pt = PAWN; pt <= KING; ++pt)
+  {
+      const PieceInfo* pi = pieceMap.find(pt)->second;
+
+      for (Direction d : pi->sliderCapture)
+      {
+          if (d == NORTH_EAST || d == SOUTH_WEST || d == NORTH_WEST || d == SOUTH_EAST)
+              AttackRiderTypes[pt] |= RIDER_BISHOP;
+          if (d == NORTH || d == SOUTH || d == EAST || d == WEST)
+              AttackRiderTypes[pt] |= RIDER_ROOK;
+      }
+      for (Direction d : pi->sliderQuiet)
+      {
+          if (d == NORTH_EAST || d == SOUTH_WEST || d == NORTH_WEST || d == SOUTH_EAST)
+              MoveRiderTypes[pt] |= RIDER_BISHOP;
+          if (d == NORTH || d == SOUTH || d == EAST || d == WEST)
+              MoveRiderTypes[pt] |= RIDER_ROOK;
+      }
+  }
+
   for (unsigned i = 0; i < (1 << 16); ++i)
       PopCnt16[i] = std::bitset<16>(i).count();
 
diff --git a/src/bitboard.h b/src/bitboard.h
index 0424715..83ae696 100644
--- a/src/bitboard.h
+++ b/src/bitboard.h
@@ -109,6 +109,8 @@ extern Bitboard LeaperAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
 extern Bitboard LeaperMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
 extern Bitboard SquareBB[SQUARE_NB];
 extern Bitboard BoardSizeBB[FILE_NB][RANK_NB];
+extern RiderType AttackRiderTypes[PIECE_TYPE_NB];
+extern RiderType MoveRiderTypes[PIECE_TYPE_NB];
 
 #ifdef LARGEBOARDS
 int popcount(Bitboard b); // required for 128 bit pext
@@ -347,11 +349,21 @@ inline Bitboard attacks_bb(Square s, Bitboard occupied) {
 }
 
 inline Bitboard attacks_bb(Color c, PieceType pt, Square s, Bitboard occupied) {
-  return LeaperAttacks[c][pt][s] | (PseudoAttacks[c][pt][s] & (attacks_bb<BISHOP>(s, occupied) | attacks_bb<ROOK>(s, occupied)));
+  Bitboard b = LeaperAttacks[c][pt][s];
+  if (AttackRiderTypes[pt] & RIDER_BISHOP)
+      b |= attacks_bb<BISHOP>(s, occupied);
+  if (AttackRiderTypes[pt] & RIDER_ROOK)
+      b |= attacks_bb<ROOK>(s, occupied);
+  return b & PseudoAttacks[c][pt][s];
 }
 
 inline Bitboard moves_bb(Color c, PieceType pt, Square s, Bitboard occupied) {
-  return LeaperMoves[c][pt][s] | (PseudoMoves[c][pt][s] & (attacks_bb<BISHOP>(s, occupied) | attacks_bb<ROOK>(s, occupied)));
+  Bitboard b = LeaperMoves[c][pt][s];
+  if (MoveRiderTypes[pt] & RIDER_BISHOP)
+      b |= attacks_bb<BISHOP>(s, occupied);
+  if (MoveRiderTypes[pt] & RIDER_ROOK)
+      b |= attacks_bb<ROOK>(s, occupied);
+  return b & PseudoMoves[c][pt][s];
 }
 
 
diff --git a/src/types.h b/src/types.h
index 6762ccb..725827a 100644
--- a/src/types.h
+++ b/src/types.h
@@ -362,6 +362,12 @@ enum Piece {
   PIECE_NB = 2 * PIECE_TYPE_NB
 };
 
+enum RiderType {
+  NO_RIDER = 0,
+  RIDER_BISHOP = 1 << 0,
+  RIDER_ROOK = 1 << 1,
+};
+
 extern Value PieceValue[PHASE_NB][PIECE_NB];
 
 enum Depth : int {
@@ -474,6 +480,15 @@ inline Value mg_value(Score s) {
   return Value(mg.s);
 }
 
+#define ENABLE_BIT_OPERATORS_ON(T)                                    \
+inline T operator~ (T d) { return (T)~(int)d; }                       \
+inline T operator| (T d1, T d2) { return (T)((int)d1 | (int)d2); }        \
+inline T operator& (T d1, T d2) { return (T)((int)d1 & (int)d2); }        \
+inline T operator^ (T d1, T d2) { return (T)((int)d1 ^ (int)d2); }        \
+inline T& operator|= (T& d1, T d2) { return (T&)((int&)d1 |= (int)d2); }  \
+inline T& operator&= (T& d1, T d2) { return (T&)((int&)d1 &= (int)d2); }  \
+inline T& operator^= (T& d1, T d2) { return (T&)((int&)d1 ^= (int)d2); }
+
 #define ENABLE_BASE_OPERATORS_ON(T)                                \
 constexpr T operator+(T d1, T d2) { return T(int(d1) + int(d2)); } \
 constexpr T operator-(T d1, T d2) { return T(int(d1) - int(d2)); } \
@@ -508,9 +523,12 @@ ENABLE_INCR_OPERATORS_ON(CheckCount)
 
 ENABLE_BASE_OPERATORS_ON(Score)
 
+ENABLE_BIT_OPERATORS_ON(RiderType)
+
 #undef ENABLE_FULL_OPERATORS_ON
 #undef ENABLE_INCR_OPERATORS_ON
 #undef ENABLE_BASE_OPERATORS_ON
+#undef ENABLE_BIT_OPERATORS_ON
 
 /// Additional operators to add integers to a Value
 constexpr Value operator+(Value v, int i) { return Value(int(v) + i); }
-- 
1.7.0.4