Small cleanup in init_sliding_attacks()
authorMarco Costalba <mcostalba@gmail.com>
Wed, 19 Jan 2011 16:48:05 +0000 (17:48 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Wed, 19 Jan 2011 18:50:44 +0000 (19:50 +0100)
No functional change both in 32 and 64 bits.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/bitboard.cpp
src/bitboard.h

index ecf51cb1f572dfc9ad44d0d8bfcc2c4a0302be58..dd12dd3ad509775276ebee5345836b9b194ce35b 100644 (file)
@@ -235,7 +235,7 @@ namespace {
   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],
+  Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
                            int fmin, int fmax, int rmin, int rmax);
   void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
                             const int shift[], const Bitboard mult[], int deltas[][2]);
@@ -405,31 +405,33 @@ namespace {
            }
   }
 
-  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 = 0;
+  Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
+                           int fmin, int fmax, int rmin, int rmax) {
+    int dx, dy, f, r;
     int rk = sq / 8;
     int fl = sq % 8;
+    Bitboard attacks = EmptyBoardBB;
 
-    for (int i = 0; i < dirs; i++)
+    for (int i = 0; i < 4; i++)
     {
-        int dx = deltas[i][0];
-        int dy = deltas[i][1];
-        int f = fl + dx;
-        int r = rk + dy;
+        dx = deltas[i][0];
+        dy = deltas[i][1];
+        f = fl + dx;
+        r = rk + dy;
 
         while (   (dx == 0 || (f >= fmin && f <= fmax))
                && (dy == 0 || (r >= rmin && r <= rmax)))
         {
-            result |= (1ULL << (f + r*8));
-            if (block & (1ULL << (f + r*8)))
+            attacks |= (1ULL << (f + r * 8));
+
+            if (occupied & (1ULL << (f + r * 8)))
                 break;
 
             f += dx;
             r += dy;
         }
     }
-    return result;
+    return attacks;
   }
 
   Bitboard index_to_bitboard(int index, Bitboard mask) {
@@ -453,7 +455,7 @@ namespace {
     for (int i = 0, index = 0; i < 64; i++)
     {
         attackIndex[i] = index;
-        mask[i] = sliding_attacks(i, 0, 4, deltas, 1, 6, 1, 6);
+        mask[i] = sliding_attacks(i, 0, deltas, 1, 6, 1, 6);
 
 #if defined(IS_64BIT)
         int j = (1 << (64 - shift[i]));
@@ -463,14 +465,14 @@ namespace {
 
         for (int k = 0; k < j; k++)
         {
-#if defined(IS_64BIT)
             Bitboard b = index_to_bitboard(k, mask[i]);
-            attacks[index + ((b * mult[i]) >> shift[i])] = sliding_attacks(i, b, 4, deltas);
+
+#if defined(IS_64BIT)
+            Bitboard v = b * mult[i];
 #else
-            Bitboard b = index_to_bitboard(k, mask[i]);
             unsigned v = int(b) * int(mult[i]) ^ int(b >> 32) * int(mult[i] >> 32);
-            attacks[index + (v >> shift[i])] = sliding_attacks(i, b, 4, deltas);
 #endif
+            attacks[index + (v >> shift[i])] = sliding_attacks(i, b, deltas, 0, 7, 0, 7);
         }
         index += j;
     }
index 90deacd9e88fc1fe268b284730252051b0572e87..d846765b26b69d776ed189abc0744e4f51067662 100644 (file)
@@ -190,17 +190,13 @@ inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & RMask[s];
   return RAttacks[RAttackIndex[s] +
-                  (unsigned(int(b) * int(RMult[s]) ^
-                            int(b >> 32) * int(RMult[s] >> 32))
-                   >> RShift[s])];
+        (unsigned(int(b) * int(RMult[s]) ^ int(b >> 32) * int(RMult[s] >> 32)) >> RShift[s])];
 }
 
 inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & BMask[s];
   return BAttacks[BAttackIndex[s] +
-                  (unsigned(int(b) * int(BMult[s]) ^
-                            int(b >> 32) * int(BMult[s] >> 32))
-                   >> BShift[s])];
+        (unsigned(int(b) * int(BMult[s]) ^ int(b >> 32) * int(BMult[s] >> 32)) >> BShift[s])];
 }
 
 #endif