Fix size overflow of rook attack magic bitboard

src/movegen/attack_generator.rs

@@ -36,7 +36,8 @@ static PAWN_ATTACKS: LazyLock<[[Bitboard; 2]; 64]> = LazyLock::new(init_pawn_att
 static KNIGHT_ATTACKS: LazyLock<[Bitboard; 64]> = LazyLock::new(init_knight_attacks);
 static KING_ATTACKS: LazyLock<[Bitboard; 64]> = LazyLock::new(init_king_attacks);
 static BISHOP_ATTACKS: LazyLock<Box<[[Bitboard; 512]; 64]>> = LazyLock::new(init_bishop_attacks);
-static ROOK_ATTACKS: LazyLock<Box<[[Bitboard; 4096]; 64]>> = LazyLock::new(init_rook_attacks);
+static ROOK_ATTACKS: LazyLock<HashMap<usize, HashMap<usize, u64>>> =
+    LazyLock::new(init_rook_attacks);
 
 const fn pawn_attacks(bitboard: Bitboard, color: Color) -> Bitboard {
     let mut attacks = EMPTY;
@@ -235,7 +236,7 @@ pub fn fetch_rook_attacks(mut occupancy: Bitboard, square: usize) -> Bitboard {
     occupancy &= mask_rook_attacks(square_to_bitboard_wrapping(square));
     occupancy = occupancy.wrapping_mul(ROOK_MAGIC[square]);
     occupancy >>= 64 - ROOK_RELEVANT_BITS[square];
-    ROOK_ATTACKS[square][occupancy as usize]
+    ROOK_ATTACKS[&square][&(occupancy as usize)]
 }
 
 pub fn fetch_queen_attacks(occupancy: Bitboard, square: usize) -> Bitboard {
@@ -280,25 +281,34 @@ pub fn init_bishop_attacks() -> Box<[[Bitboard; 512]; 64]> {
     bishop_atks
 }
 
+use std::collections::HashMap;
+
 #[allow(clippy::large_stack_frames)]
-pub fn init_rook_attacks() -> Box<[[Bitboard; 4096]; 64]> {
+pub fn init_rook_attacks() -> HashMap<usize, HashMap<usize, Bitboard>> {
-    let mut rook_masks = [0; 64];
+    let mut rook_masks: Vec<Bitboard> = vec![0; 64];
-    let mut rook_atks: Box<[[Bitboard; 4096]; 64]> = Box::new([[0; 4096]; 64]);
+    let mut rook_atks: HashMap<usize, HashMap<usize, Bitboard>> = HashMap::new();
 
     for square in 0..64 {
         rook_masks[square] = mask_rook_attacks(square_to_bitboard(square));
         let attack_mask = rook_masks[square];
         let occupancy_indices = square_to_bitboard(ROOK_RELEVANT_BITS[square]);
 
+        let mut square_map: HashMap<usize, Bitboard> = HashMap::new();
+
         for idx in 0..occupancy_indices {
             let occupancy = set_occupancy(idx, ROOK_RELEVANT_BITS[square], attack_mask);
             let magic_index = (occupancy.wrapping_mul(ROOK_MAGIC[square])
                 >> (64 - ROOK_RELEVANT_BITS[square])) as usize;
 
-            rook_atks[square][magic_index] =
+            square_map.insert(
-                rook_attacks_on_the_fly(square_to_bitboard(square), occupancy);
+                magic_index,
+                rook_attacks_on_the_fly(square_to_bitboard(square), occupancy),
+            );
         }
+
+        rook_atks.insert(square, square_map);
     }
+
     rook_atks
 }