chore: fix all tests

Author: raklaptudirm

games/src/ataxx/bitboard.rs

@@ -24,3 +24,125 @@ bitboard_type! {
         FirstRank = Self(0x000000000007f);
     }
 }
+
+use crate::interface::{BitBoardType, RepresentableType};
+
+impl BitBoard {
+    pub fn singles(bb: BitBoard) -> BitBoard {
+        let bar = bb | bb.east() | bb.west();
+        bar | bar.north() | bar.south()
+    }
+
+    /// single returns the targets of a singular Move from the given Square.
+    pub const fn single(square: Square) -> BitBoard {
+        SINGLES[square as usize]
+    }
+
+    /// double returns the targets of a jump Move from the given Square.
+    pub const fn double(square: Square) -> BitBoard {
+        DOUBLES[square as usize]
+    }
+}
+
+const SINGLES: [BitBoard; Square::N] = [
+    BitBoard(0x0000000000182),
+    BitBoard(0x0000000000385),
+    BitBoard(0x000000000070a),
+    BitBoard(0x0000000000e14),
+    BitBoard(0x0000000001c28),
+    BitBoard(0x0000000003850),
+    BitBoard(0x0000000003020),
+    BitBoard(0x000000000c103),
+    BitBoard(0x000000001c287),
+    BitBoard(0x000000003850e),
+    BitBoard(0x0000000070a1c),
+    BitBoard(0x00000000e1438),
+    BitBoard(0x00000001c2870),
+    BitBoard(0x0000000181060),
+    BitBoard(0x0000000608180),
+    BitBoard(0x0000000e14380),
+    BitBoard(0x0000001c28700),
+    BitBoard(0x0000003850e00),
+    BitBoard(0x00000070a1c00),
+    BitBoard(0x000000e143800),
+    BitBoard(0x000000c083000),
+    BitBoard(0x000003040c000),
+    BitBoard(0x0000070a1c000),
+    BitBoard(0x00000e1438000),
+    BitBoard(0x00001c2870000),
+    BitBoard(0x00003850e0000),
+    BitBoard(0x000070a1c0000),
+    BitBoard(0x0000604180000),
+    BitBoard(0x0001820600000),
+    BitBoard(0x0003850e00000),
+    BitBoard(0x00070a1c00000),
+    BitBoard(0x000e143800000),
+    BitBoard(0x001c287000000),
+    BitBoard(0x003850e000000),
+    BitBoard(0x003020c000000),
+    BitBoard(0x00c1030000000),
+    BitBoard(0x01c2870000000),
+    BitBoard(0x03850e0000000),
+    BitBoard(0x070a1c0000000),
+    BitBoard(0x0e14380000000),
+    BitBoard(0x1c28700000000),
+    BitBoard(0x1810600000000),
+    BitBoard(0x0081800000000),
+    BitBoard(0x0143800000000),
+    BitBoard(0x0287000000000),
+    BitBoard(0x050e000000000),
+    BitBoard(0x0a1c000000000),
+    BitBoard(0x1438000000000),
+    BitBoard(0x0830000000000),
+];
+const DOUBLES: [BitBoard; Square::N] = [
+    BitBoard(0x000000001c204),
+    BitBoard(0x000000003c408),
+    BitBoard(0x000000007c891),
+    BitBoard(0x00000000f9122),
+    BitBoard(0x00000001f2244),
+    BitBoard(0x00000001e0408),
+    BitBoard(0x00000001c0810),
+    BitBoard(0x0000000e10204),
+    BitBoard(0x0000001e20408),
+    BitBoard(0x0000003e44891),
+    BitBoard(0x0000007c89122),
+    BitBoard(0x000000f912244),
+    BitBoard(0x000000f020408),
+    BitBoard(0x000000e040810),
+    BitBoard(0x0000070810207),
+    BitBoard(0x00000f102040f),
+    BitBoard(0x00001f224489f),
+    BitBoard(0x00003e448913e),
+    BitBoard(0x00007c891227c),
+    BitBoard(0x0000781020478),
+    BitBoard(0x0000702040870),
+    BitBoard(0x0003840810380),
+    BitBoard(0x0007881020780),
+    BitBoard(0x000f912244f80),
+    BitBoard(0x001f224489f00),
+    BitBoard(0x003e448913e00),
+    BitBoard(0x003c081023c00),
+    BitBoard(0x0038102043800),
+    BitBoard(0x01c204081c000),
+    BitBoard(0x03c408103c000),
+    BitBoard(0x07c891227c000),
+    BitBoard(0x0f912244f8000),
+    BitBoard(0x1f224489f0000),
+    BitBoard(0x1e040811e0000),
+    BitBoard(0x1c081021c0000),
+    BitBoard(0x0102040e00000),
+    BitBoard(0x0204081e00000),
+    BitBoard(0x0448913e00000),
+    BitBoard(0x0891227c00000),
+    BitBoard(0x112244f800000),
+    BitBoard(0x020408f000000),
+    BitBoard(0x040810e000000),
+    BitBoard(0x0102070000000),
+    BitBoard(0x02040f0000000),
+    BitBoard(0x04489f0000000),
+    BitBoard(0x08913e0000000),
+    BitBoard(0x11227c0000000),
+    BitBoard(0x0204780000000),
+    BitBoard(0x0408700000000),
+];

games/src/ataxx/mod.rs

@@ -14,4 +14,5 @@ mod piece;
 mod position;
 mod square;
 
-pub mod moves;
+#[cfg(test)]
+mod tests;

games/src/ataxx/move.rs

@@ -58,7 +58,8 @@ impl Move {
     pub const NULL: Move = Move(1 << 15);
     /// PASS Move represents a no move, where only the side to move changes.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
+    /// use tetka_games::interface::PositionType;
     /// use std::str::FromStr;
     ///
     /// let old_pos = Position::from_str("x5o/7/7/7/7/7/o5x x 0 1").unwrap();
@@ -74,7 +75,7 @@ impl Move {
     /// target Square. For a singular Move, [`Move::source`] and [`Move::target`]
     /// are equal since the source Square is irrelevant to the Move.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     ///
     /// let mov = Move::new_single(Square::A1);
     ///
@@ -90,7 +91,7 @@ impl Move {
     /// target Square. These Squares can be recovered with the [`Move::source`] and
     /// [`Move::target`] methods respectively.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     ///
     /// let mov = Move::new(Square::A1, Square::A3);
     ///
@@ -109,7 +110,7 @@ impl Move {
     /// Source returns the source Square of the moving piece. This is equal to the
     /// target Square if the given Move is of singular type.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     ///
     /// let mov = Move::new(Square::A1, Square::A3);
     ///
@@ -121,7 +122,7 @@ impl Move {
 
     /// Target returns the target Square of the moving piece.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     ///
     /// let mov = Move::new(Square::A1, Square::A3);
     ///
@@ -134,7 +135,7 @@ impl Move {
     /// is_single checks if the given Move is singular in nature. The result of this
     /// function for [`Move::NULL`] and [`Move::PASS`] is undefined.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     ///
     /// let sing = Move::new_single(Square::A1);
     /// let jump = Move::new(Square::A1, Square::A3);
@@ -166,7 +167,7 @@ impl FromStr for Move {
     /// [`Square::FromStr`](Square::from_str). This function can be treated as the
     /// inverse of the [`fmt::Display`] trait for [Move].
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     /// use std::str::FromStr;
     ///
     /// let pass = Move::PASS;
@@ -207,7 +208,7 @@ impl fmt::Display for Move {
     /// refer to `Square::Display`. [`Move::NULL`] is  formatted as `null`, while
     /// [`Move::PASS`] is formatted as `0000`.
     /// ```
-    /// use ataxx::*;
+    /// use tetka_games::ataxx::*;
     ///
     /// let null = Move::NULL;
     /// let pass = Move::PASS;

games/src/ataxx/moves.rs

@@ -31,8 +31,6 @@ use crate::ataxx::{
 };
 use crate::interface::MoveStore;
 
-use super::moves;
-
 /// Position represents the snapshot of an Ataxx Board, the state of the an
 /// ataxx game at a single point in time. It also provides all of the methods
 /// necessary to manipulate such a snapshot.
@@ -171,7 +169,7 @@ impl PositionType for Position {
         let stm_pieces = self.color_bb(stm);
         let xtm_pieces = self.color_bb(!stm);
 
-        let captured = moves::single(m.target()) & xtm_pieces;
+        let captured = BitBoard::single(m.target()) & xtm_pieces;
         let from_to = BitBoard::from(m.target()) | BitBoard::from(m.source());
 
         // Move the captured pieces from xtm to stm.
@@ -219,14 +217,14 @@ impl PositionType for Position {
         // Pieces can only move to unoccupied Squares.
         let allowed = !(stm | xtm | gap);
 
-        for target in moves::singles(stm) & allowed {
+        for target in BitBoard::singles(stm) & allowed {
             movelist.push(Move::new_single(target));
         }
 
         for piece in stm {
             // There may be multiple jump moves to a single Square, so they need to be
             // verified (& allowed) and serialized into the movelist immediately.
-            let double = moves::double(piece) & allowed;
+            let double = BitBoard::double(piece) & allowed;
             for target in double {
                 movelist.push(Move::new(piece, target));
             }
@@ -256,12 +254,12 @@ impl PositionType for Position {
         let allowed = !(stm | xtm | gap);
 
         // Count the number single moves in the Position.
-        let mut moves: usize = (moves::singles(stm) & allowed).cardinality();
+        let mut moves: usize = (BitBoard::singles(stm) & allowed).cardinality();
 
         for piece in stm {
             // There may be multiple jump moves to a single Square, so they need to be
             // verified (& allowed) and counted into the Position total immediately.
-            let double = moves::double(piece) & allowed;
+            let double = BitBoard::double(piece) & allowed;
             moves += double.cardinality();
         }
 

games/src/ataxx/position.rs

@@ -1,12 +1,13 @@
-use ataxx::{perft, Position};
+use crate::ataxx::Position;
+use crate::perft;
 use std::str::FromStr;
 
 macro_rules! perft_test {
     ($name:ident $pos:literal $depth:literal $nodes:literal) => {
         #[test]
         fn $name() {
             let position = Position::from_str($pos).unwrap();
-            assert_eq!(perft::<true, true>(position, $depth), $nodes)
+            assert_eq!(perft::<true, true, _>(position, $depth), $nodes)
         }
     };
 }