added a PieceSetDescriptor and removed the const generic of Piece

barbarosa/src/cube_n/cube3/heuristics/manhattan.rs

@@ -3,14 +3,14 @@ use nalgebra::Vector3;
 use crate::{
     cube3::Cube3,
     cube_n::{Corner, Edge},
-    generic::{Piece, PieceSet},
+    generic::{piece::PieceSetDescriptor, PieceSet},
 };
 
 fn vec_manhattan(a: &Vector3<f32>, b: &Vector3<f32>) -> f32 {
     a.iter().zip(b.iter()).map(|(a, b)| (a - b).abs()).sum()
 }
 
-fn piece_set_manhattan<P: Piece<N>, const N: usize>(
+fn piece_set_manhattan<P: PieceSetDescriptor<N>, const N: usize>(
     set: &PieceSet<P, N>,
     coords: impl Fn(&P::Position) -> Vector3<f32>,
 ) -> f32 {

barbarosa/src/cube_n/cube3/mus/index/implementations.rs

@@ -3,7 +3,7 @@ use crate::{
         mus::{CornersMUS, HalfEdgesMUS},
         Corner, Edge,
     },
-    generic::Piece,
+    generic::{piece::PieceSetDescriptor, Piece},
 };
 
 use super::{

barbarosa/src/cube_n/invariants.rs

@@ -32,7 +32,7 @@ use std::fmt::Debug;
 
 use crate::{
     cube_n::{cube3::mus::index::PositionIndexable, Cube3, Edge},
-    generic::Piece,
+    generic::piece::PieceSetDescriptor,
 };
 
 use super::pieces::{corner::CornerSet, edge::EdgeSet};

barbarosa/src/cube_n/moves/wide.rs

@@ -11,7 +11,7 @@ pub use crate::generic::{
     parse::{self, Parsable},
 };
 
-use self::generic::{Alg, Cube, Movable, Piece, PieceSet};
+use self::generic::{piece::PieceSetDescriptor, Alg, Cube, Movable, Piece, PieceSet};
 
 use super::{
     rotation::{AxisRotation, Rotatable},
@@ -183,13 +183,13 @@ impl Alg<AxisMove> {
 }
 
 /// A piece that can be moved by a wide move
-pub trait DepthPiece<const N: usize>: Piece<N> {
+pub trait DepthPiece: Piece {
     /// Whether the piece is in the wide move if it has the given normal and tangent depth.
-    fn is_in_wide_move<const M: u32>(
+    fn is_in_wide_move<const N: u32>(
         &self,
         normal_depth: u32,
         tangent_depth: u32,
-        m: &WideAxisMove<M>,
+        m: &WideAxisMove<N>,
     ) -> bool;
 }
 
@@ -199,7 +199,7 @@ pub trait DepthPiece<const N: usize>: Piece<N> {
 /// implements [`Movable`] for [`WideAxisMove`]s.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DepthPieceSet<
-    P: DepthPiece<N>,
+    P: DepthPiece + PieceSetDescriptor<N>,
     const N: usize,
     const NORMAL_DEPTH: u32,
     const TANGENT_DEPTH: u32 = 0,
@@ -208,15 +208,22 @@ pub struct DepthPieceSet<
     pub set: PieceSet<P, N>,
 }
 
-impl<P: DepthPiece<N>, const N: usize, const ND: u32, const TD: u32> DepthPieceSet<P, N, ND, TD> {
+impl<P: DepthPiece + PieceSetDescriptor<N>, const N: usize, const ND: u32, const TD: u32>
+    DepthPieceSet<P, N, ND, TD>
+{
     /// Alias to [`Piece::SOLVED`]
     pub const SOLVED: Self = Self {
         set: PieceSet::SOLVED,
     };
 }
 
-impl<P: DepthPiece<N> + Rotatable, const M: u32, const N: usize, const ND: u32, const TD: u32>
-    Movable<WideAxisMove<M>> for DepthPieceSet<P, N, ND, TD>
+impl<
+        P: DepthPiece + Rotatable + PieceSetDescriptor<N>,
+        const M: u32,
+        const N: usize,
+        const ND: u32,
+        const TD: u32,
+    > Movable<WideAxisMove<M>> for DepthPieceSet<P, N, ND, TD>
 {
     fn apply(&mut self, m: &WideAxisMove<M>) {
         self.set
@@ -226,7 +233,7 @@ impl<P: DepthPiece<N> + Rotatable, const M: u32, const N: usize, const ND: u32,
     }
 }
 
-impl<P: DepthPiece<N>, const N: usize, const ND: u32, const TD: u32> Deref
+impl<P: DepthPiece + PieceSetDescriptor<N>, const N: usize, const ND: u32, const TD: u32> Deref
     for DepthPieceSet<P, N, ND, TD>
 {
     type Target = PieceSet<P, N>;

barbarosa/src/cube_n/pieces/center/corner.rs

@@ -12,7 +12,7 @@ use crate::{
         space::{Axis, Direction},
         Vec3, WideAxisMove,
     },
-    generic,
+    generic::{self, piece::PieceSetDescriptor},
 };
 
 /// A center corner piece of the cube. There are 4 of these in each face of a cube.
@@ -22,9 +22,19 @@ pub struct CenterCorner {
     axis: Axis,
 }
 
-impl generic::Piece<24> for CenterCorner {
+impl generic::Piece for CenterCorner {
     type Position = Self;
 
+    fn position(&self) -> Self::Position {
+        self.clone()
+    }
+
+    fn is_solved(&self, original_pos: &Self::Position) -> bool {
+        self.position[self.axis] == original_pos.position[original_pos.axis]
+    }
+}
+
+impl PieceSetDescriptor<24> for CenterCorner {
     const SOLVED: [Self; 24] = {
         use Direction::*;
 
@@ -47,14 +57,6 @@ impl generic::Piece<24> for CenterCorner {
     };
 
     const REFERENCE_POSITIONS: [Self::Position; 24] = Self::SOLVED;
-
-    fn position(&self) -> Self::Position {
-        self.clone()
-    }
-
-    fn is_solved(&self, original_pos: &Self::Position) -> bool {
-        self.position[self.axis] == original_pos.position[original_pos.axis]
-    }
 }
 
 impl Rotatable for CenterCorner {
@@ -64,7 +66,7 @@ impl Rotatable for CenterCorner {
     }
 }
 
-impl DepthPiece<24> for CenterCorner {
+impl DepthPiece for CenterCorner {
     fn is_in_wide_move<const M: u32>(
         &self,
         normal_depth: u32,

barbarosa/src/cube_n/pieces/center/edge.rs

@@ -14,7 +14,7 @@ use crate::{
         space::{faces, Axis, Direction, Face},
         WideAxisMove,
     },
-    generic,
+    generic::{self, piece::PieceSetDescriptor},
 };
 
 /// A center edge piece of the cube. There are 4 of these in each face of a cube.
@@ -34,9 +34,19 @@ pub struct CenterEdge {
     pub side_direction: Direction,
 }
 
-impl generic::Piece<24> for CenterEdge {
+impl generic::Piece for CenterEdge {
     type Position = Self;
 
+    fn position(&self) -> Self::Position {
+        self.clone()
+    }
+
+    fn is_solved(&self, original_pos: &Self::Position) -> bool {
+        self.main_face == original_pos.main_face
+    }
+}
+
+impl PieceSetDescriptor<24> for CenterEdge {
     const REFERENCE_POSITIONS: [Self::Position; 24] = {
         use faces::*;
         use Direction::*;
@@ -50,14 +60,6 @@ impl generic::Piece<24> for CenterEdge {
     };
 
     const SOLVED: [Self; 24] = Self::REFERENCE_POSITIONS;
-
-    fn position(&self) -> Self::Position {
-        self.clone()
-    }
-
-    fn is_solved(&self, original_pos: &Self::Position) -> bool {
-        self.main_face == original_pos.main_face
-    }
 }
 
 impl Rotatable for CenterEdge {
@@ -120,7 +122,7 @@ impl CenterEdge {
     }
 }
 
-impl DepthPiece<24> for CenterEdge {
+impl DepthPiece for CenterEdge {
     fn is_in_wide_move<const M: u32>(
         &self,
         normal_depth: u32,

barbarosa/src/cube_n/pieces/center/wing.rs

@@ -13,7 +13,7 @@ use crate::{
         space::{faces, Axis, Direction, Face},
         WideAxisMove,
     },
-    generic,
+    generic::{self, piece::PieceSetDescriptor},
 };
 
 use super::edge::CenterEdge;
@@ -28,9 +28,19 @@ pub struct CenterWing {
     pseudo_oriented: bool,
 }
 
-impl generic::Piece<48> for CenterWing {
+impl generic::Piece for CenterWing {
     type Position = Self;
 
+    fn position(&self) -> Self::Position {
+        self.clone()
+    }
+
+    fn is_solved(&self, original_pos: &Self::Position) -> bool {
+        self.main_face() == original_pos.main_face()
+    }
+}
+
+impl PieceSetDescriptor<48> for CenterWing {
     const REFERENCE_POSITIONS: [Self::Position; 48] = {
         use faces::*;
         use Direction::*;
@@ -45,14 +55,6 @@ impl generic::Piece<48> for CenterWing {
     };
 
     const SOLVED: [Self; 48] = Self::REFERENCE_POSITIONS;
-
-    fn position(&self) -> Self::Position {
-        self.clone()
-    }
-
-    fn is_solved(&self, original_pos: &Self::Position) -> bool {
-        self.main_face() == original_pos.main_face()
-    }
 }
 
 impl Rotatable for CenterWing {
@@ -139,7 +141,7 @@ impl std::fmt::Debug for CenterWing {
     }
 }
 
-impl DepthPiece<48> for CenterWing {
+impl DepthPiece for CenterWing {
     fn is_in_wide_move<const M: u32>(
         &self,
         normal_depth: u32,

barbarosa/src/cube_n/pieces/corner.rs

@@ -11,7 +11,10 @@ use crate::{
         space::{Axis, Direction, Face},
         AxisMove, Vec3,
     },
-    generic::{self, moves::impl_movable_array, utils::map_array_const, PieceSet},
+    generic::{
+        self, moves::impl_movable_array, piece::PieceSetDescriptor, utils::map_array_const,
+        PieceSet,
+    },
 };
 
 /// A corner piece of the cube.
@@ -25,9 +28,19 @@ pub struct Corner {
     pub orientation_axis: Axis,
 }
 
-impl generic::Piece<8> for Corner {
+impl generic::Piece for Corner {
     type Position = Vec3;
 
+    fn position(&self) -> Self::Position {
+        self.position
+    }
+
+    fn is_solved(&self, original_pos: &Self::Position) -> bool {
+        self.position() == *original_pos && self.is_oriented()
+    }
+}
+
+impl PieceSetDescriptor<8> for Corner {
     const REFERENCE_POSITIONS: [Self::Position; 8] = {
         use Direction::*;
 
@@ -38,14 +51,6 @@ impl generic::Piece<8> for Corner {
     };
 
     const SOLVED: [Self; 8] = map_array_const!(Corner::REFERENCE_POSITIONS, 8, Corner::oriented);
-
-    fn position(&self) -> Self::Position {
-        self.position
-    }
-
-    fn is_solved(&self, original_pos: &Self::Position) -> bool {
-        self.position() == *original_pos && self.is_oriented()
-    }
 }
 
 impl Rotatable for Corner {

barbarosa/src/cube_n/pieces/edge.rs

@@ -11,7 +11,10 @@ use crate::{
         space::{Axis, Direction, Face},
         AxisMove, Vec2,
     },
-    generic::{self, moves::impl_movable_array, utils::map_array_const, Piece, PieceSet},
+    generic::{
+        self, moves::impl_movable_array, piece::PieceSetDescriptor, utils::map_array_const, Piece,
+        PieceSet,
+    },
 };
 
 // use super::{ContainedInMove, Corner};
@@ -44,9 +47,19 @@ pub struct Edge {
     pub oriented: bool,
 }
 
-impl generic::Piece<12> for Edge {
+impl generic::Piece for Edge {
     type Position = (Axis, Vec2);
 
+    fn position(&self) -> Self::Position {
+        (self.normal_axis, self.slice_position)
+    }
+
+    fn is_solved(&self, original_pos: &Self::Position) -> bool {
+        self.position() == *original_pos && self.oriented
+    }
+}
+
+impl PieceSetDescriptor<12> for Edge {
     // TODO: Try to use cartesian product to make this nicer
     const REFERENCE_POSITIONS: [(Axis, Vec2); 12] = {
         use Axis::*;
@@ -77,20 +90,12 @@ impl generic::Piece<12> for Edge {
     ///
     /// See [crate::cube_n::cube3::mus] for more information.
     const SOLVED: [Edge; 12] = {
-        const fn from_tuple((axis, pos): (Axis, Vec2)) -> Edge {
+        const fn from_tuple((axis, pos): <Edge as Piece>::Position) -> Edge {
             Edge::oriented(axis, pos)
         }
 
         map_array_const!(Edge::REFERENCE_POSITIONS, 12, from_tuple)
     };
-
-    fn position(&self) -> Self::Position {
-        (self.normal_axis, self.slice_position)
-    }
-
-    fn is_solved(&self, original_pos: &Self::Position) -> bool {
-        self.position() == *original_pos && self.oriented
-    }
 }
 
 impl Rotatable for Edge {
@@ -191,7 +196,7 @@ impl Edge {
 
     /// Returns the standard coordinates of the edge
     pub fn coordinates(
-        (normal_axis, slice_position): &<Edge as Piece<12>>::Position,
+        (normal_axis, slice_position): &<Edge as Piece>::Position,
     ) -> nalgebra::Vector3<f32> {
         normal_axis.map_on_slice(Vector3::zeros(), |_| {
             slice_position.map(|dir| dir.scalar() as f32)