Another round of bitboard.cpp cleanups

Also renamed StepAttackBB[] in NonSlidingAttacksBB[]

No functional change.

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

diff --git a/src/bitbase.cpp b/src/bitbase.cpp
index ac03120f5f97cb59a6c868fca9698f4ffc38d6a9..5d20fbc6d896aa51c14188c3998cf46ed8c8585b 100644 (file)
--- a/src/bitbase.cpp
+++ b/src/bitbase.cpp
@@ -47,9 +47,9 @@ namespace {
     bool is_legal() const;
     bool is_immediate_draw() const;
     bool is_immediate_win() const;
     bool is_legal() const;
     bool is_immediate_draw() const;
     bool is_immediate_win() const;

-    Bitboard wk_attacks()   const { return StepAttackBB[WK][whiteKingSquare]; }
-    Bitboard bk_attacks()   const { return StepAttackBB[BK][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttackBB[WP][pawnSquare]; }
+    Bitboard wk_attacks()   const { return NonSlidingAttacksBB[WK][whiteKingSquare]; }
+    Bitboard bk_attacks()   const { return NonSlidingAttacksBB[BK][blackKingSquare]; }
+    Bitboard pawn_attacks() const { return NonSlidingAttacksBB[WP][pawnSquare]; }

 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;
 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index 1e07c8ce32bda3cc2eba58cd98a7aec83fcc2360..8c1be7390a14a02a04dba241710a27c6550123a1 100644 (file)
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -213,6 +213,8 @@ const Bitboard InFrontBB[2][8] = {
   }
 };
 
   }
 };
 

+// Global bitboards definitions with static storage duration are
+// automatically set to zero before enter main().

 Bitboard RMask[64];
 int RAttackIndex[64];
 Bitboard RAttacks[0x19000];
 Bitboard RMask[64];
 int RAttackIndex[64];
 Bitboard RAttacks[0x19000];


@@ -224,7 +226,7 @@ Bitboard BAttacks[0x1480];
 Bitboard SetMaskBB[65];
 Bitboard ClearMaskBB[65];
 
 Bitboard SetMaskBB[65];
 Bitboard ClearMaskBB[65];
 

-Bitboard StepAttackBB[16][64];
+Bitboard NonSlidingAttacksBB[16][64];

 Bitboard BetweenBB[64][64];
 
 Bitboard SquaresInFrontMask[2][64];
 Bitboard BetweenBB[64][64];
 
 Bitboard SquaresInFrontMask[2][64];


@@ -238,16 +240,12 @@ Bitboard QueenPseudoAttacks[64];
 uint8_t BitCount8Bit[256];
 
 
 uint8_t BitCount8Bit[256];
 
 

-////
-//// Local definitions
-////
-

 namespace {
 
   void init_masks();
 namespace {
 
   void init_masks();

-  void init_attacks();
-  void init_between_bitboards();
+  void init_non_sliding_attacks();

   void init_pseudo_attacks();
   void init_pseudo_attacks();

+  void init_between_bitboards();

   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);
   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);


@@ -256,44 +254,23 @@ namespace {
 }
 
 
 }
 
 

-////
-//// Functions
-////
-

 /// print_bitboard() prints a bitboard in an easily readable format to the
 /// print_bitboard() prints a bitboard in an easily readable format to the

-/// standard output.  This is sometimes useful for debugging.
+/// standard output. This is sometimes useful for debugging.

 
 void print_bitboard(Bitboard b) {
 
   for (Rank r = RANK_8; r >= RANK_1; r--)
   {
 
 void print_bitboard(Bitboard b) {
 
   for (Rank r = RANK_8; r >= RANK_1; r--)
   {

-      std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
+      std::cout << "+---+---+---+---+---+---+---+---+" << '\n';

       for (File f = FILE_A; f <= FILE_H; f++)
           std::cout << "| " << (bit_is_set(b, make_square(f, r))? 'X' : ' ') << ' ';
 
       for (File f = FILE_A; f <= FILE_H; f++)
           std::cout << "| " << (bit_is_set(b, make_square(f, r))? 'X' : ' ') << ' ';
 

-      std::cout << "|" << std::endl;
+      std::cout << "|\n";

   }
   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
 }
 
 
   }
   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
 }
 
 

-/// init_bitboards() initializes various bitboard arrays.  It is called during
-/// program initialization.
-
-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_masks();
-  init_attacks();
-  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
-  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
-  init_pseudo_attacks();
-  init_between_bitboards();
-}
-
-

 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.


@@ -373,6 +350,22 @@ Square pop_1st_bit(Bitboard* bb) {
 #endif
 
 
 #endif
 
 

+/// init_bitboards() initializes various bitboard arrays. It is called during
+/// program initialization.
+
+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_masks();
+  init_non_sliding_attacks();
+  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
+  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
+  init_pseudo_attacks();
+  init_between_bitboards();
+}
+

 namespace {
 
   // All functions below are used to precompute various bitboards during
 namespace {
 
   // All functions below are used to precompute various bitboards during


@@ -382,7 +375,7 @@ namespace {
 
   void init_masks() {
 
 
   void init_masks() {
 

-    SetMaskBB[SQ_NONE] = 0ULL;
+    SetMaskBB[SQ_NONE] = EmptyBoardBB;

     ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
 
     for (Square s = SQ_A1; s <= SQ_H8; s++)
     ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
 
     for (Square s = SQ_A1; s <= SQ_H8; s++)


@@ -403,32 +396,30 @@ namespace {
         BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
   }
 
         BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
   }
 

-  void init_attacks() {
+  void init_non_sliding_attacks() {

 
 

-    const int step[16][8] =  {
+    const int step[][9] =  {

       {0},
       {0},

-      {7,9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}, {0}, {0},
-      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}
+      {7,9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
+      {9,7,-7,-9,8,1,-1,-8,0}, {0}, {0},
+      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
+      {9,7,-7,-9,8,1,-1,-8,0}

     };
 
     };
 

-    for (int i = 0; i < 64; i++)
-        for (int j = 0; j <= int(BK); j++)
-        {
-            StepAttackBB[j][i] = EmptyBoardBB;
-            for (int k = 0; k < 8 && step[j][k] != 0; k++)
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
+        for (Piece pc = WP; pc <= BK; pc++)
+            for (int k = 0; step[pc][k] != 0; k++)

             {
             {

-                int l = i + step[j][k];
-                if (l >= 0 && l < 64 && abs((i & 7) - (l & 7)) < 3)
-                    StepAttackBB[j][i] |= (1ULL << l);
+                Square to = s + Square(step[pc][k]);
+
+                if (square_is_ok(to) && square_distance(s, to) < 3)
+                    set_bit(&NonSlidingAttacksBB[pc][s], to);

            }
            }

-        }

   }
 
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin=0, int fmax=7, int rmin=0, int rmax=7) {
   }
 
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin=0, int fmax=7, int rmin=0, int rmax=7) {

-    Bitboard result = 0ULL;
+    Bitboard result = 0;

     int rk = sq / 8;
     int fl = sq % 8;
 
     int rk = sq / 8;
     int fl = sq % 8;
 


@@ -453,40 +444,17 @@ namespace {
     return result;
   }
 
     return result;
   }
 

-  void init_between_bitboards() {
-
-    Square s1, s2, s3;
-    SquareDelta d;
-    int f, r;
-
-    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
-        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
-        {
-            BetweenBB[s1][s2] = EmptyBoardBB;
-
-            if (bit_is_set(QueenPseudoAttacks[s1], s2))
-            {
-                f = file_distance(s1, s2);
-                r = rank_distance(s1, s2);
-
-                d = SquareDelta(s2 - s1) / Max(f, r);
-
-                for (s3 = s1 + d; s3 != s2; s3 += d)
-                    set_bit(&(BetweenBB[s1][s2]), s3);
-            }
-      }
-  }
-

   Bitboard index_to_bitboard(int index, Bitboard mask) {
 
   Bitboard index_to_bitboard(int index, Bitboard mask) {
 

-    Bitboard result = 0ULL;
-    int bits = count_1s<CNT32>(mask);
+    Bitboard result = EmptyBoardBB;
+    int sq, cnt = 0;

 
 

-    for (int i = 0; i < bits; i++)
+    while (mask)

     {
     {

-        int j = pop_1st_bit(&mask);
-        if (index & (1 << i))
-            result |= (1ULL << j);
+        sq = pop_1st_bit(&mask);
+
+        if (index & (1 << cnt++))
+            result |= (1ULL << sq);

     }
     return result;
   }
     }
     return result;
   }


@@ -530,4 +498,24 @@ namespace {
     }
   }
 
     }
   }
 

+  void init_between_bitboards() {
+
+    Square s1, s2, s3;
+    SquareDelta d;
+    int f, r;
+
+    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
+            if (bit_is_set(QueenPseudoAttacks[s1], s2))
+            {
+                f = file_distance(s1, s2);
+                r = rank_distance(s1, s2);
+
+                d = SquareDelta(s2 - s1) / Max(f, r);
+
+                for (s3 = s1 + d; s3 != s2; s3 += d)
+                    set_bit(&(BetweenBB[s1][s2]), s3);
+            }
+  }
+

 }
 }

diff --git a/src/bitboard.h b/src/bitboard.h
index 6239953e9de2c245c2c866a8a2a5665569c23e54..42c096d1992ad50d82c78dfaa11b993dd624f57c 100644 (file)
--- a/src/bitboard.h
+++ b/src/bitboard.h
@@ -66,7 +66,7 @@ extern const Bitboard InFrontBB[2][8];
 extern Bitboard SetMaskBB[65];
 extern Bitboard ClearMaskBB[65];
 
 extern Bitboard SetMaskBB[65];
 extern Bitboard ClearMaskBB[65];
 

-extern Bitboard StepAttackBB[16][64];
+extern Bitboard NonSlidingAttacksBB[16][64];

 extern Bitboard BetweenBB[64][64];
 
 extern Bitboard SquaresInFrontMask[2][64];
 extern Bitboard BetweenBB[64][64];
 
 extern Bitboard SquaresInFrontMask[2][64];

diff --git a/src/position.cpp b/src/position.cpp
index bc6efb7f646d05bb242b94b3f3d5eea48b426eb6..cf2c7bac5c7d7852624186bf45b4a2f6c95e106b 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -524,7 +524,7 @@ Bitboard Position::attacks_from(Piece p, Square s) const {
   case WB: case BB: return attacks_from<BISHOP>(s);
   case WR: case BR: return attacks_from<ROOK>(s);
   case WQ: case BQ: return attacks_from<QUEEN>(s);
   case WB: case BB: return attacks_from<BISHOP>(s);
   case WR: case BR: return attacks_from<ROOK>(s);
   case WQ: case BQ: return attacks_from<QUEEN>(s);

-  default: return StepAttackBB[p][s];
+  default: return NonSlidingAttacksBB[p][s];

   }
 }
 
   }
 }
 


@@ -537,7 +537,7 @@ Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
   case WB: case BB: return bishop_attacks_bb(s, occ);
   case WR: case BR: return rook_attacks_bb(s, occ);
   case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
   case WB: case BB: return bishop_attacks_bb(s, occ);
   case WR: case BR: return rook_attacks_bb(s, occ);
   case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);

-  default: return StepAttackBB[p][s];
+  default: return NonSlidingAttacksBB[p][s];

   }
 }
 
   }
 }
 

diff --git a/src/position.h b/src/position.h
index 600c1648205f2d7cf9e6c4e8a7d7032c004de921..91b341ad0ec428469415b424be6b67cce0d181d7 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -456,12 +456,12 @@ inline Square Position::initial_qr_square(Color c) const {
 
 template<>
 inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
 
 template<>
 inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {

-  return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
+  return NonSlidingAttacksBB[piece_of_color_and_type(c, PAWN)][s];

 }
 
 template<PieceType Piece> // Knight and King and white pawns
 inline Bitboard Position::attacks_from(Square s) const {
 }
 
 template<PieceType Piece> // Knight and King and white pawns
 inline Bitboard Position::attacks_from(Square s) const {

-  return StepAttackBB[Piece][s];
+  return NonSlidingAttacksBB[Piece][s];

 }
 
 template<>
 }
 
 template<>