kewb 0.4.3

A crate for manipulating and solving a 3x3 Rubik's cube with Kociemba's two phase algorithm
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::constants::{CO_COUNT, CP_COUNT, EO_COUNT, EP_COUNT};

use super::{cubie::CubieCube, index::*};
use rand::{rngs::ThreadRng, prelude::IndexedRandom, rng, Rng};

/// Randomly swaps corner or edges to fix parity.
fn fix_parity(state: &mut CubieCube, rng: &mut ThreadRng, corners: Vec<usize>, edges: Vec<usize>) {
    if rng.random_bool(0.5) {
        swap_edges(state, rng, edges)
    } else {
        swap_corners(state, rng, corners)
    }
}

fn swap_edges(state: &mut CubieCube, rng: &mut ThreadRng, edges: Vec<usize>) {
    let pos: Vec<&usize> = edges.choose_multiple(rng, 2).collect();
    let a = *pos[0];
    let b = *pos[1];
    state.ep.swap(a, b)
}

fn swap_corners(state: &mut CubieCube, rng: &mut ThreadRng, corners: Vec<usize>) {
    let pos: Vec<&usize> = corners.choose_multiple(rng, 2).collect();
    let a = *pos[0];
    let b = *pos[1];
    state.cp.swap(a, b)
}

/// Generates a random state with corners solved.
pub fn generate_state_corners_solved() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        ep: index_to_ep(rng.random_range(0..EP_COUNT)),
        eo: index_to_eo(rng.random_range(0..EO_COUNT)),
        ..Default::default()
    };

    if !state.is_solvable() {
        swap_edges(&mut state, &mut rng, (0..12).collect());
    }

    state
}

/// Generates a random state with edges solved.
pub fn generate_state_edges_solved() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        cp: index_to_cp(rng.random_range(0..CP_COUNT)),
        co: index_to_co(rng.random_range(0..CO_COUNT)),
        ..Default::default()
    };

    if !state.is_solvable() {
        swap_corners(&mut state, &mut rng, (0..8).collect());
    }

    state
}

/// Generates a random state with oriented solved last layer cross.
pub fn generate_state_oll_cross_solved() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        cp: index_to_cp_f2l(rng.random_range(0..4)),
        co: index_to_co_f2l(rng.random_range(0..27)),
        ep: index_to_ep_f2l(rng.random_range(0..24)),
        ..Default::default()
    };

    if !state.is_solvable() {
        fix_parity(&mut state, &mut rng, (0..4).collect(), (4..8).collect())
    }

    state
}

/// Generates a random state with oriented last layer corners and edges.
pub fn generate_state_oll_solved() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        cp: index_to_cp_f2l(rng.random_range(0..4)),
        ep: index_to_ep_f2l(rng.random_range(0..24)),
        ..Default::default()
    };

    if !state.is_solvable() {
        fix_parity(&mut state, &mut rng, (0..4).collect(), (4..8).collect())
    }

    state
}

/// Generates a random state with solved First two layer.
pub fn generate_state_f2l_solved() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        cp: index_to_cp_f2l(rng.random_range(0..4)),
        co: index_to_co_f2l(rng.random_range(0..27)),
        ep: index_to_ep_f2l(rng.random_range(0..24)),
        eo: index_to_eo_f2l(rng.random_range(0..8)),
    };

    if !state.is_solvable() {
        fix_parity(&mut state, &mut rng, (0..4).collect(), (4..8).collect())
    }

    state
}

/// Generates a random state with solved cross.
pub fn generate_state_cross_solved() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        cp: index_to_cp(rng.random_range(0..CP_COUNT)),
        co: index_to_co(rng.random_range(0..CO_COUNT)),
        ep: index_to_ep_cross(rng.random_range(0..40320)),
        eo: index_to_eo_cross(rng.random_range(0..128)),
    };

    if !state.is_solvable() {
        fix_parity(&mut state, &mut rng, (0..8).collect(), (0..8).collect())
    }

    state
}

/// Generates a random state on the cubie level.
pub fn generate_random_state() -> CubieCube {
    let mut rng = rng();
    let mut state = CubieCube {
        cp: index_to_cp(rng.random_range(0..CP_COUNT)),
        co: index_to_co(rng.random_range(0..CO_COUNT)),
        ep: index_to_ep(rng.random_range(0..EP_COUNT)),
        eo: index_to_eo(rng.random_range(0..EO_COUNT)),
    };

    if !state.is_solvable() {
        fix_parity(&mut state, &mut rng, (0..8).collect(), (0..12).collect())
    }

    state
}