Retire SignedDirectionTable[] and RayBB[]

Function ray_bb() was used just in one endgame where can
be used squares_in_front_of() instead.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

src/bitboard.cpp

@@ -225,7 +225,6 @@ Bitboard SetMaskBB[65];
 Bitboard ClearMaskBB[65];
 
 Bitboard StepAttackBB[16][64];
-Bitboard RayBB[64][8];
 Bitboard BetweenBB[64][64];
 
 Bitboard SquaresInFrontMask[2][64];
@@ -246,7 +245,6 @@ uint8_t BitCount8Bit[256];
 namespace {
 
   void init_masks();
-  void init_ray_bitboards();
   void init_attacks();
   void init_between_bitboards();
   void init_pseudo_attacks();
@@ -288,7 +286,6 @@ void init_bitboards() {
   int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
 
   init_masks();
-  init_ray_bitboards();
   init_attacks();
   init_between_bitboards();
   init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
@@ -406,21 +403,6 @@ namespace {
         BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
   }
 
-  int remove_bit_8(int i) { return ((i & ~15) >> 1) | (i & 7); }
-
-  void init_ray_bitboards() {
-
-    int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-
-    for (int i = 0; i < 128; i = (i + 9) & ~8)
-        for (int j = 0; j < 8; j++)
-        {
-            RayBB[remove_bit_8(i)][j] = EmptyBoardBB;
-            for (int k = i + d[j]; (k & 0x88) == 0; k += d[j])
-                set_bit(&(RayBB[remove_bit_8(i)][j]), Square(remove_bit_8(k)));
-        }
-  }
-
   void init_attacks() {
 
     const int step[16][8] =  {
@@ -473,20 +455,26 @@ namespace {
 
   void init_between_bitboards() {
 
-    const SquareDelta step[8] = { DELTA_E, DELTA_W, DELTA_N, DELTA_S,
+    const SquareDelta directionToDelta[] = {
-                                  DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE };
+        DELTA_E, DELTA_N, DELTA_NE, DELTA_NW, DELTA_W, DELTA_S, DELTA_SW, DELTA_SE
+    };
 
-    for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
+    Square s1, s2, s3;
-        for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+    Direction d;
+
+    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
         {
             BetweenBB[s1][s2] = EmptyBoardBB;
-            SignedDirection d = SignedDirection(SignedDirectionTable[s1][s2]);
+            d = direction_between_squares(s1, s2);
 
-            if (d != SIGNED_DIR_NONE)
+            if (d == DIR_NONE)
-            {
+                continue;
-                for (Square s3 = s1 + step[d]; s3 != s2; s3 += step[d])
+
-                    set_bit(&(BetweenBB[s1][s2]), s3);
+            SquareDelta sd = directionToDelta[s2 > s1 ? d : d + 4];
-            }
+
+            for (s3 = s1 + sd; s3 != s2; s3 += sd)
+                set_bit(&(BetweenBB[s1][s2]), s3);
       }
   }
 

src/bitboard.h

@@ -67,7 +67,6 @@ extern Bitboard SetMaskBB[65];
 extern Bitboard ClearMaskBB[65];
 
 extern Bitboard StepAttackBB[16][64];
-extern Bitboard RayBB[64][8];
 extern Bitboard BetweenBB[64][64];
 
 extern Bitboard SquaresInFrontMask[2][64];
@@ -208,14 +207,6 @@ inline Bitboard behind_bb(Color c, Square s) {
 }
 
 
-/// ray_bb() gives a bitboard representing all squares along the ray in a
-/// given direction from a given square.
-
-inline Bitboard ray_bb(Square s, SignedDirection d) {
-  return RayBB[s][d];
-}
-
-
 /// Functions for computing sliding attack bitboards. rook_attacks_bb(),
 /// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
 /// bitboard of occupied squares as input, and return a bitboard representing

src/direction.cpp

@@ -24,61 +24,42 @@
 
 #include "square.h"
 
+uint8_t DirectionTable[64][64];
 
-////
-//// Local definitions
-////
 
-namespace {
+static bool reachable(Square orig, Square dest, Direction d) {
 
   const SquareDelta directionToDelta[] = {
-      DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
+      DELTA_E, DELTA_N, DELTA_NE, DELTA_NW, DELTA_W, DELTA_S, DELTA_SW, DELTA_SE
   };
 
-  bool reachable(Square orig, Square dest, SignedDirection dir) {
+  SquareDelta delta = directionToDelta[dest > orig ? d : d + 4];
+  Square from = orig;
+  Square to = from + delta;
 
-    SquareDelta delta = directionToDelta[dir];
+  while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
-    Square from = orig;
+  {
-    Square to = from + delta;
+      from = to;
-    while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
+      to += delta;
-    {
-        from = to;
-        to += delta;
-    }
-    return (to == dest && square_distance(from, to) == 1);
   }
-
+  return to == dest && square_distance(from, to) == 1;
 }
 
-
-////
-//// Variables
-////
-
-uint8_t DirectionTable[64][64];
-uint8_t SignedDirectionTable[64][64];
-
-
-////
-//// Functions
-////
-
 void init_direction_table() {
 
   for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
       for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
       {
           DirectionTable[s1][s2] = uint8_t(DIR_NONE);
-          SignedDirectionTable[s1][s2] = uint8_t(SIGNED_DIR_NONE);
+
           if (s1 == s2)
               continue;
 
-          for (SignedDirection d = SIGNED_DIR_E; d != SIGNED_DIR_NONE; d++)
+          for (Direction d = DIR_E; d != DIR_NONE; d++)
           {
               if (reachable(s1, s2, d))
               {
-                  SignedDirectionTable[s1][s2] = uint8_t(d);
+                  DirectionTable[s1][s2] = uint8_t(d);
-                  DirectionTable[s1][s2] = uint8_t(d / 2);
                   break;
               }
           }

src/endgame.cpp

@@ -699,11 +699,12 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
           return SCALE_FACTOR_ZERO;
       else
       {
-          Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S);
+          Bitboard path = squares_in_front_of(strongerSide, pawnSq);
-          if (ray & pos.pieces(KING, weakerSide))
+
+          if (path & pos.pieces(KING, weakerSide))
               return SCALE_FACTOR_ZERO;
 
-          if (  (pos.attacks_from<BISHOP>(weakerBishopSq) & ray)
+          if (  (pos.attacks_from<BISHOP>(weakerBishopSq) & path)
               && square_distance(weakerBishopSq, pawnSq) >= 3)
               return SCALE_FACTOR_ZERO;
       }

src/square.h

@@ -72,19 +72,12 @@ enum Direction {
   DIR_E = 0, DIR_N = 1, DIR_NE = 2, DIR_NW = 3, DIR_NONE = 4
 };
 
-enum SignedDirection {
-  SIGNED_DIR_E  = 0, SIGNED_DIR_W  = 1,
-  SIGNED_DIR_N  = 2, SIGNED_DIR_S  = 3,
-  SIGNED_DIR_NE = 4, SIGNED_DIR_SW = 5,
-  SIGNED_DIR_NW = 6, SIGNED_DIR_SE = 7,
-  SIGNED_DIR_NONE = 8
-};
 
 ENABLE_OPERATORS_ON(Square);
 ENABLE_OPERATORS_ON(File);
 ENABLE_OPERATORS_ON(Rank);
 ENABLE_OPERATORS_ON(SquareDelta);
-ENABLE_OPERATORS_ON(SignedDirection);
+ENABLE_OPERATORS_ON(Direction);
 
 
 ////
@@ -95,7 +88,6 @@ const int FlipMask = 56;
 const int FlopMask =  7;
 
 extern uint8_t DirectionTable[64][64];
-extern uint8_t SignedDirectionTable[64][64];
 
 
 ////