chore: only the covering problem remains :slight_smile:

Author: raklaptudirm

games/src/games/chess/mod.rs

@@ -1,3 +1,4 @@
+use std::usize;
 use std::{ops, sync::LazyLock};
 
 use crate::interface::{RepresentableType, SetType};
@@ -30,7 +31,7 @@ crate::interface::game_details!(
 
 impl BitBoard {
     pub fn new(raw: u64) -> BitBoard {
-        BitBoard(raw)
+        BitBoard::from(raw)
     }
 
     pub fn shift(&self, dir: Direction) -> BitBoard {
@@ -59,16 +60,16 @@ impl BitBoard {
     }
 
     pub fn between(sq_1: Square, sq_2: Square) -> BitBoard {
-        BETWEEN[sq_1 as usize][sq_2 as usize]
+        BETWEEN[u8::from(sq_1) as usize][sq_2.into()]
     }
 
     pub fn between2(sq_1: Square, sq_2: Square) -> BitBoard {
-        BETWEEN[sq_1 as usize][sq_2 as usize] | sq_2
+        BETWEEN[u8::from(sq_1) as usize][sq_2.into()] | sq_2
     }
 }
 
 static DIAGONAL: LazyLock<[BitBoard; 15]> = LazyLock::new(|| {
-    const MAIN_DIAGONAL: BitBoard = BitBoard(0x8040201008040201u64);
+    const MAIN_DIAGONAL: BitBoard = BitBoard::from(0x8040201008040201u64);
 
     let mut diagonals = [BitBoard::EMPTY; 15];
 
@@ -90,7 +91,7 @@ static DIAGONAL: LazyLock<[BitBoard; 15]> = LazyLock::new(|| {
 });
 
 static ANTI_DIAGONAL: LazyLock<[BitBoard; 15]> = LazyLock::new(|| {
-    const MAIN_ANTI_DIAGONAL: BitBoard = BitBoard(0x0102040810204080u64);
+    const MAIN_ANTI_DIAGONAL: BitBoard = BitBoard::from(0x0102040810204080u64);
 
     let mut anti_diagonals = [BitBoard::EMPTY; 15];
 
@@ -147,7 +148,7 @@ static BETWEEN: LazyLock<[[BitBoard; Square::N]; Square::N]> =
                 // The intersection between the two blocked rays will be the between
                 // BitBoard + Squares 1 and 2. Therefore, to get the between BitBoard, a
                 // final intersection operator with the union of Squares 1 and 2 is do
-                between[square_1 as usize][square_2 as usize] =
+                between[square_1.into()][square_2.into()] =
                     moves::hyperbola(square_1, blockers, mask)
                         & moves::hyperbola(square_2, blockers, mask);
             }
@@ -172,15 +173,15 @@ impl Square {
     }
 
     pub fn shift(self, dir: Direction) -> Square {
-        unsafe { Square::unsafe_from((self as i8 + dir as i8) as u8) }
+        unsafe { Square::unsafe_from((u8::from(self) as i8 + dir as i8) as u8) }
     }
 
     pub fn diagonal(self) -> usize {
-        7 + self.rank() as usize - self.file() as usize
+        7usize + u8::from(self.rank()) as usize - self.file().into()
     }
 
     pub fn anti_diagonal(self) -> usize {
-        self.rank() as usize + self.file() as usize
+        self.rank().into() + self.file().into()
     }
 }
 

games/src/games/chess/move.rs

@@ -63,8 +63,8 @@ impl Move {
     pub fn new(source: Square, target: Square, mvflag: MoveFlag) -> Move {
         Move(
             (mvflag as u16) << Move::MVFLAG_OFFSET
-                | (source as u16) << Move::SOURCE_OFFSET
-                | (target as u16) << Move::TARGET_OFFSET,
+                | (u8::from(source) as u16) << Move::SOURCE_OFFSET
+                | (target.into() as u16) << Move::TARGET_OFFSET,
         )
     }
 
@@ -90,8 +90,8 @@ impl Move {
     ) -> Move {
         Move(
             (promotion as u16) << Move::MVFLAG_OFFSET
-                | (source as u16) << Move::SOURCE_OFFSET
-                | (target as u16) << Move::TARGET_OFFSET,
+                | (u8::from(source) as u16) << Move::SOURCE_OFFSET
+                | (target.into()) << Move::TARGET_OFFSET,
         )
     }
 

games/src/interface/bitboard.rs

@@ -203,6 +203,14 @@ impl<B: PrimInt, const F: u8, const R: u8> From<CartesianSquareSet<B, F, R>>
     }
 }
 
+impl<B: PrimInt, const F: u8, const R: u8> From<u64>
+    for CartesianSquareSet<B, F, R>
+{
+    fn from(value: u64) -> Self {
+        Self(value, PhantomData)
+    }
+}
+
 // a -> {a}
 impl<B: PrimInt, const F: u8, const R: u8> From<CartesianSquare<B, F, R>>
     for CartesianSquareSet<B, F, R>