Retire direction.cpp

[stockfish] / src / bitboard.cpp

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index 063204c5020f7ec2f54a5104ee705a618068fc4b..72e208ffc7c3c2a95e15c84e58489768e1df57ff 100644 (file)
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -26,7 +26,6 @@
 
 #include "bitboard.h"
 #include "bitcount.h"
-#include "direction.h"
 
 
 #if defined(IS_64BIT)
@@ -163,7 +162,10 @@ const int RShift[64] = {
 
 #endif // defined(IS_64BIT)
 
-const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
+const Bitboard LightSquaresBB = 0x55AA55AA55AA55AAULL;
+const Bitboard DarkSquaresBB  = 0xAA55AA55AA55AA55ULL;
+
+const Bitboard SquaresByColorBB[2] = { DarkSquaresBB, LightSquaresBB };
 
 const Bitboard FileBB[8] = {
   FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
@@ -223,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];
@@ -235,6 +236,7 @@ Bitboard RookPseudoAttacks[64];
 Bitboard QueenPseudoAttacks[64];
 
 uint8_t BitCount8Bit[256];
+int8_t  DirectionTable[64][64];
 
 
 ////
@@ -243,8 +245,9 @@ uint8_t BitCount8Bit[256];
 
 namespace {
 
+  SquareDelta get_direction(Square orig, Square dest);
+  void init_direction_table();
   void init_masks();
-  void init_ray_bitboards();
   void init_attacks();
   void init_between_bitboards();
   void init_pseudo_attacks();
@@ -285,8 +288,8 @@ 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_ray_bitboards();
   init_attacks();
   init_between_bitboards();
   init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
@@ -381,6 +384,36 @@ 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;
@@ -400,23 +433,8 @@ namespace {
             AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
         }
 
-    for (Bitboard b = 0ULL; b < 256ULL; b++)
-        BitCount8Bit[b] = (uint8_t)count_1s(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)));
-        }
+    for (Bitboard b = 0; b < 256; b++)
+        BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
   }
 
   void init_attacks() {
@@ -471,27 +489,27 @@ namespace {
 
   void init_between_bitboards() {
 
-    const SquareDelta step[8] = { DELTA_E, DELTA_W, DELTA_N, DELTA_S,
-                                  DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE };
+    Square s1, s2, s3;
+    SquareDelta d;
 
-    for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-        for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
         {
             BetweenBB[s1][s2] = EmptyBoardBB;
-            SignedDirection d = signed_direction_between_squares(s1, s2);
+            d = SquareDelta(DirectionTable[s1][s2]);
 
-            if (d != SIGNED_DIR_NONE)
-            {
-                for (Square s3 = s1 + step[d]; s3 != s2; s3 += step[d])
-                    set_bit(&(BetweenBB[s1][s2]), s3);
-            }
+            if (d == DELTA_NONE)
+                continue;
+
+            for (s3 = s1 + d; s3 != s2; s3 += d)
+                set_bit(&(BetweenBB[s1][s2]), s3);
       }
   }
 
   Bitboard index_to_bitboard(int index, Bitboard mask) {
 
     Bitboard result = 0ULL;
-    int bits = count_1s(mask);
+    int bits = count_1s<CNT32>(mask);
 
     for (int i = 0; i < bits; i++)
     {
@@ -508,7 +526,7 @@ namespace {
     for (int i = 0, index = 0; i < 64; i++)
     {
         attackIndex[i] = index;
-        mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
+        mask[i] = sliding_attacks(i, 0, 4, deltas, 1, 6, 1, 6);
 
 #if defined(IS_64BIT)
         int j = (1 << (64 - shift[i]));