use std::fmt; use crate::{cubie::CubieCube, error::Error}; /// Names the colors of the cube facelets: up, right, front, down, left, back. #[rustfmt::skip] #[derive(Debug, PartialEq, PartialOrd, Clone, Copy)] pub enum Color { U, R, F, D, L, B, } impl fmt::Display for Color { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{:?}", self) } } impl TryFrom for Color { type Error = Error; fn try_from(value: char) -> Result { match value { 'U' => Ok(Color::U), 'R' => Ok(Color::R), 'F' => Ok(Color::F), 'D' => Ok(Color::D), 'L' => Ok(Color::L), 'B' => Ok(Color::B), _ => Err(Error::InvalidColor), } } } /// Cube on the facelet level. /// /// The facelet representation follows the ordering: U-R-F-D-L-B. /// /// A solved facelet is `UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB`. /// #[derive(Debug, PartialEq)] pub struct FaceCube { pub f: [Color; 54], } /// Solved cube on the facelet level. #[rustfmt::skip] pub const SOLVED_FACE_CUBE: FaceCube = FaceCube { f: [ Color::U, Color::U, Color::U, Color::U, Color::U, Color::U, Color::U, Color::U, Color::U, Color::R, Color::R, Color::R, Color::R, Color::R, Color::R, Color::R, Color::R, Color::R, Color::F, Color::F, Color::F, Color::F, Color::F, Color::F, Color::F, Color::F, Color::F, Color::D, Color::D, Color::D, Color::D, Color::D, Color::D, Color::D, Color::D, Color::D, Color::L, Color::L, Color::L, Color::L, Color::L, Color::L, Color::L, Color::L, Color::L, Color::B, Color::B, Color::B, Color::B, Color::B, Color::B, Color::B, Color::B, Color::B, ], }; impl Default for FaceCube { fn default() -> Self { SOLVED_FACE_CUBE } } impl TryFrom<&CubieCube> for FaceCube { type Error = Error; fn try_from(value: &CubieCube) -> Result { if !value.is_solvable() { return Err(Error::InvalidCubieValue); } let mut face = FaceCube::default(); for (i, corner_faces) in CORNER_FACELET.iter().enumerate() { let corner = value.cp[i] as usize; for (j, f) in corner_faces.iter().enumerate() { face.f[*f as usize] = CORNER_COLOR[corner][(j + (3 - value.co[i] as usize)) % 3]; } } for (i, edge_faces) in EDGE_FACELET.iter().enumerate() { let edge = value.ep[i] as usize; for (j, f) in edge_faces.iter().enumerate() { face.f[*f as usize] = EDGE_COLOR[edge][(j + value.eo[i] as usize) % 2]; } } Ok(face) } } impl TryFrom<&str> for FaceCube { type Error = Error; fn try_from(cube_string: &str) -> Result { if cube_string.len() != 54 { return Err(Error::InvalidFaceletString); } let mut face_cube = FaceCube::default(); for (i, c) in cube_string.chars().enumerate() { face_cube.f[i] = Color::try_from(c)?; } Ok(face_cube) } } impl fmt::Display for FaceCube { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let acc = String::new(); let s = self.f.iter().fold(acc, |acc, f| format!("{acc}{f}")); write!(f, "{s}") } } /// The names of the facelet positions of the cube. /// /// ```text /// |************| /// |*U1**U2**U3*| /// |************| /// |*U4**U5**U6*| /// |************| /// |*U7**U8**U9*| /// |************| /// ************|************|************|************| /// *L1**L2**L3*|*F1**F2**F3*|*R1**R2**F3*|*B1**B2**B3*| /// ************|************|************|************| /// *L4**L5**L6*|*F4**F5**F6*|*R4**R5**R6*|*B4**B5**B6*| /// ************|************|************|************| /// *L7**L8**L9*|*F7**F8**F9*|*R7**R8**R9*|*B7**B8**B9*| /// ************|************|************|************| /// |************| /// |*D1**D2**D3*| /// |************| /// |*D4**D5**D6*| /// |************| /// |*D7**D8**D9*| /// |************| /// ``` /// A cube definition string "UBL..." means for example: In position U1 we have the U-color, in position U2 we have the /// B-color, in position U3 we have the L color etc. according to the order U1, U2, U3, U4, U5, U6, U7, U8, U9, R1, R2, /// R3, R4, R5, R6, R7, R8, R9, F1, F2, F3, F4, F5, F6, F7, F8, F9, D1, D2, D3, D4, D5, D6, D7, D8, D9, L1, L2, L3, L4, /// L5, L6, L7, L8, L9, B1, B2, B3, B4, B5, B6, B7, B8, B9 of the enum constants. /// #[rustfmt::skip] #[derive(Debug, PartialEq, PartialOrd, Clone, Copy)] pub enum Facelet { U1, U2, U3, U4, _U5, U6, U7, U8, U9, R1, R2, R3, R4, _R5, R6, R7, R8, R9, F1, F2, F3, F4, _F5, F6, F7, F8, F9, D1, D2, D3, D4, _D5, D6, D7, D8, D9, L1, L2, L3, L4, _L5, L6, L7, L8, L9, B1, B2, B3, B4, _B5, B6, B7, B8, B9, } /// Map the corner positions to facelet positions. pub const CORNER_FACELET: [[Facelet; 3]; 8] = [ [Facelet::U9, Facelet::R1, Facelet::F3], //URF [Facelet::U7, Facelet::F1, Facelet::L3], //UFL [Facelet::U1, Facelet::L1, Facelet::B3], //ULB [Facelet::U3, Facelet::B1, Facelet::R3], //UBR [Facelet::D3, Facelet::F9, Facelet::R7], //DFR [Facelet::D1, Facelet::L9, Facelet::F7], //DLF [Facelet::D7, Facelet::B9, Facelet::L7], //DBL [Facelet::D9, Facelet::R9, Facelet::B7], //DRB ]; /// Map the edge positions to facelet positions. pub const EDGE_FACELET: [[Facelet; 2]; 12] = [ [Facelet::U6, Facelet::R2], [Facelet::U8, Facelet::F2], [Facelet::U4, Facelet::L2], [Facelet::U2, Facelet::B2], [Facelet::D6, Facelet::R8], [Facelet::D2, Facelet::F8], [Facelet::D4, Facelet::L8], [Facelet::D8, Facelet::B8], [Facelet::F6, Facelet::R4], [Facelet::F4, Facelet::L6], [Facelet::B6, Facelet::L4], [Facelet::B4, Facelet::R6], ]; /// Map the corner positions to facelet colors. pub const CORNER_COLOR: [[Color; 3]; 8] = [ [Color::U, Color::R, Color::F], [Color::U, Color::F, Color::L], [Color::U, Color::L, Color::B], [Color::U, Color::B, Color::R], [Color::D, Color::F, Color::R], [Color::D, Color::L, Color::F], [Color::D, Color::B, Color::L], [Color::D, Color::R, Color::B], ]; /// Map the edge positions to facelet colors. pub const EDGE_COLOR: [[Color; 2]; 12] = [ [Color::U, Color::R], [Color::U, Color::F], [Color::U, Color::L], [Color::U, Color::B], [Color::D, Color::R], [Color::D, Color::F], [Color::D, Color::L], [Color::D, Color::B], [Color::F, Color::R], [Color::F, Color::L], [Color::B, Color::L], [Color::B, Color::R], ]; #[cfg(test)] mod test { use crate::cubie::{Corner::*, Edge::*, SOLVED_CUBIE_CUBE}; use crate::facelet::*; #[test] fn test_facelet_to_cubie() { // One scramble that produces these faces: // F L' B R' U R U B' L2 R' F2 U2 L' F2 D F U R' D R U' L' R2 D2 let faces = "DRBLUURLDRBLRRBFLFFUBFFDRUDURRBDFBBULDUDLUDLBUFFDBFLRL"; let face_cube = FaceCube::try_from(faces).unwrap(); let actual_state = CubieCube::try_from(&face_cube).unwrap(); assert_eq!( actual_state, CubieCube { cp: [DRB, URF, DLF, ULB, DFR, UBR, DBL, UFL], co: [0, 2, 0, 1, 1, 0, 2, 0], ep: [UB, UL, DL, FR, FL, UR, BL, BR, DR, UF, DF, DB], eo: [0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0] } ); // One list of moves that solves this state: // L2 B' D R F B' L U B R' U' B2 D L2 D2 R2 B2 D' B2 D F2 U } #[test] fn test_cubie_to_facelet() { let face_cube = FaceCube::try_from(&SOLVED_CUBIE_CUBE).unwrap(); assert_eq!(face_cube, SOLVED_FACE_CUBE); let face_string = "DRBLUURLDRBLRRBFLFFUBFFDRUDURRBDFBBULDUDLUDLBUFFDBFLRL"; let expected = FaceCube::try_from(face_string).unwrap(); let cubie = CubieCube { cp: [DRB, URF, DLF, ULB, DFR, UBR, DBL, UFL], co: [0, 2, 0, 1, 1, 0, 2, 0], ep: [UB, UL, DL, FR, FL, UR, BL, BR, DR, UF, DF, DB], eo: [0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0], }; let face_cube = FaceCube::try_from(&cubie).unwrap(); assert_eq!(face_cube, expected); } }