Retire DirectionTable[]

With this patch even word 'direction' is disappeared !

No functional change.

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

src/bitboard.cpp

@@ -236,7 +236,6 @@ Bitboard RookPseudoAttacks[64];
 Bitboard QueenPseudoAttacks[64];
 
 uint8_t BitCount8Bit[256];
-int8_t  DirectionTable[64][64];
 
 
 ////
@@ -245,12 +244,11 @@ int8_t  DirectionTable[64][64];
 
 namespace {
 
-  SquareDelta get_direction(Square orig, Square dest);
-  void init_direction_table();
   void init_masks();
   void init_attacks();
   void init_between_bitboards();
   void init_pseudo_attacks();
+  SquareDelta squares_delta(Square orig, Square dest);
   Bitboard index_to_bitboard(int index, Bitboard mask);
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin, int fmax, int rmin, int rmax);
@@ -288,7 +286,6 @@ void init_bitboards() {
   int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
   int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
 
-  init_direction_table();
   init_masks();
   init_attacks();
   init_between_bitboards();
@@ -384,36 +381,6 @@ namespace {
   // understand, but they all seem to work correctly, and it should never
   // be necessary to touch any of them.
 
-  SquareDelta get_direction(Square orig, Square dest) {
-
-    const SquareDelta directions[] = {
-        DELTA_E, DELTA_N, DELTA_NE, DELTA_NW, DELTA_W, DELTA_S, DELTA_SW, DELTA_SE
-    };
-
-    for (int idx = 0; idx < 8; idx++)
-    {
-        Square from = orig;
-        Square to = from + directions[idx];
-
-        while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
-        {
-            from = to;
-            to += directions[idx];
-        }
-
-        if (to == dest && square_distance(from, to) == 1)
-            return directions[idx];
-    }
-    return DELTA_NONE;
-  }
-
-  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(get_direction(s1, s2));
-  }
-
   void init_masks() {
 
     SetMaskBB[SQ_NONE] = 0ULL;
@@ -487,6 +454,26 @@ namespace {
     return result;
   }
 
+  SquareDelta squares_delta(Square orig, Square dest) {
+
+    const SquareDelta deltas[] = { DELTA_N, DELTA_NE, DELTA_E, DELTA_SE,
+                                   DELTA_S, DELTA_SW, DELTA_W, DELTA_NW };
+
+    for (int idx = 0; idx < 8; idx++)
+    {
+        Square s = orig + deltas[idx];
+
+        while (square_is_ok(s) && square_distance(s, s - deltas[idx]) == 1)
+        {
+            if (s == dest)
+                return deltas[idx];
+
+            s += deltas[idx];
+        }
+    }
+    return DELTA_NONE;
+  }
+
   void init_between_bitboards() {
 
     Square s1, s2, s3;
@@ -496,13 +483,11 @@ namespace {
         for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
         {
             BetweenBB[s1][s2] = EmptyBoardBB;
-            d = SquareDelta(DirectionTable[s1][s2]);
+            d = squares_delta(s1, s2);
 
-            if (d == DELTA_NONE)
+            if (d != DELTA_NONE)
-                continue;
+                for (s3 = s1 + d; s3 != s2; s3 += d)
-
+                    set_bit(&(BetweenBB[s1][s2]), s3);
-            for (s3 = s1 + d; s3 != s2; s3 += d)
-                set_bit(&(BetweenBB[s1][s2]), s3);
       }
   }
 

src/bitboard.h

@@ -90,7 +90,6 @@ extern Bitboard RookPseudoAttacks[64];
 extern Bitboard QueenPseudoAttacks[64];
 
 extern uint8_t BitCount8Bit[256];
-extern int8_t DirectionTable[64][64];
 
 
 ////
@@ -302,17 +301,8 @@ inline Bitboard attack_span_mask(Color c, Square s) {
 /// either on a straight or on a diagonal line.
 
 inline bool squares_aligned(Square s1, Square s2, Square s3) {
-  return   DirectionTable[s1][s2] != DELTA_NONE
+  return  (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
-        && abs(DirectionTable[s1][s2]) ==  abs(DirectionTable[s2][s3]);
+        & ((1ULL << s1) | (1ULL << s2) | (1ULL << s3));
-}
-
-
-/// squares_straight_aligned returns true if the squares s1 and s2 are aligned
-/// on a straight line, either veritical or horizontal.
-
-inline bool squares_straight_aligned(Square s1, Square s2) {
-  return   abs(DirectionTable[s1][s2]) == DELTA_N
-        || abs(DirectionTable[s1][s2]) == DELTA_E;
 }
 
 

src/movegen.cpp

@@ -244,7 +244,7 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist) {
       case QUEEN:
           // In case of a queen remove also squares attacked in the other direction to
           // avoid possible illegal moves when queen and king are on adjacent squares.
-          if (squares_straight_aligned(checksq, ksq))
+          if (RookPseudoAttacks[checksq] & (1ULL << ksq))
               sliderAttacks |= RookPseudoAttacks[checksq] | pos.attacks_from<BISHOP>(checksq);
           else
               sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);