cubesim 0.0.7

Rubik's Cube simulation and solving library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use derive_more::Display;
use cgmath::{Rotation, Vector3};

use crate::generic_cube::{Face, CubeSize}; 
use crate::geometric_cube::moves::{GeometricMove};

#[derive(Copy, Clone, Display, Eq, Hash, PartialEq)]
#[display(fmt = "({}, {}, {})", "initial.x", "initial.y", "initial.z")]
pub struct Sticker {
    pub size: CubeSize,
    pub current: Vector3<CubeSize>,
    pub initial: Vector3<CubeSize>,
    pub face: Face,
}

impl Sticker {
    pub fn new(size: CubeSize, x: CubeSize, y: CubeSize, z: CubeSize) -> Sticker {
        Self {
            size,
            current: Vector3::new(x, y, z),
            initial: Vector3::new(x, y, z),
            face: Self::compute_face(size, x, y, z),
        }
    }

    pub fn current_face(&self) -> Face {
        Self::compute_face(self.size, self.current.x, self.current.y, self.current.z)
    }

    pub fn initial_face(&self) -> Face {
        self.face
    }

    pub fn rotate(&self, mv: GeometricMove) -> Self {
        if !(mv.predicate)(self) {
            return *self;
        }

        let rotation_matrix = mv.get_rotation_matrix();
        let new_position = rotation_matrix.rotate_vector(
            Vector3::new(self.current.x as f64,
                         self.current.y as f64,
                         self.current.z as f64,
            )
        );

        Self {
            current: Vector3{ x: new_position.x.round() as CubeSize, 
                              y: new_position.y.round() as CubeSize, 
                              z: new_position.z.round() as CubeSize },
            ..*self
        }
    }

    pub fn compute_face(size: CubeSize, x: CubeSize, y: CubeSize, z: CubeSize) -> Face {
        if x == size { Face::R }
        else if x == -size { Face::L }
        else if y == size { Face::U }
        else if y == -size { Face::D }
        else if z == size { Face::F }
        else if z == -size { Face::B }
        else { Face::X }
    }

    pub fn set_solved(&self) -> Self {
        Self {
            current: self.initial,
            ..*self
        }
    }
}