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

use super::utils::*;
use crate::cube::{constants::*, cubie::CubieCube, index::*};
use bincode::{Decode, Encode};

/// Collection of moves table for navigating on the coordinate level.
#[derive(Encode, Decode)]
pub struct MoveTable {
    pub co: Table<u16>,
    pub eo: Table<u16>,
    pub e_combo: Table<u16>,
    pub cp: Table<u16>,
    pub ep: Table<u16>,
    pub e_ep: Table<u16>,
}

impl Default for MoveTable {
    fn default() -> Self {
        Self {
            co: get_co_table(),
            eo: get_eo_table(),
            e_combo: get_e_combo_table(),
            cp: get_cp_table(),
            ep: get_ud_ep_table(),
            e_ep: get_e_ep_table(),
        }
    }
}

pub fn get_co_table() -> Table<u16> {
    let mut co_table = vec![vec![0; 18]; CO_COUNT as usize];

    for i in 0..CO_COUNT {
        let state = CubieCube {
            co: index_to_co(i),
            ..Default::default()
        };

        for (j, m) in ALL_MOVES.iter().enumerate() {
            let new_state = state.apply_move(*m);
            co_table[i as usize][j] = co_to_index(&new_state.co);
        }
    }

    co_table
}

pub fn get_eo_table() -> Table<u16> {
    let mut eo_table = vec![vec![0; 18]; EO_COUNT as usize];

    for i in 0..EO_COUNT {
        let state = CubieCube {
            eo: index_to_eo(i),
            ..Default::default()
        };

        for (j, m) in ALL_MOVES.iter().enumerate() {
            let new_state = state.apply_move(*m);
            eo_table[i as usize][j] = eo_to_index(&new_state.eo);
        }
    }

    eo_table
}

pub fn get_e_combo_table() -> Table<u16> {
    let mut e_combo_table = vec![vec![0; 18]; E_COMBO_COUNT as usize];
    for i in 0..E_COMBO_COUNT {
        let state = CubieCube {
            ep: index_to_e_combo(i),
            ..Default::default()
        };

        for (j, m) in ALL_MOVES.iter().enumerate() {
            let new_state = state.apply_move(*m);
            e_combo_table[i as usize][j] = e_combo_to_index(&new_state.ep);
        }
    }

    e_combo_table
}

pub fn get_cp_table() -> Table<u16> {
    let mut cp_table = vec![vec![0; 10]; CP_COUNT as usize];

    for i in 0..CP_COUNT {
        let state = CubieCube {
            cp: index_to_cp(i),
            ..Default::default()
        };

        for (j, m) in PHASE2_MOVES.iter().enumerate() {
            let new_state = state.apply_move(*m);
            cp_table[i as usize][j] = cp_to_index(&new_state.cp);
        }
    }

    cp_table
}

pub fn get_ud_ep_table() -> Table<u16> {
    let mut ep_table = vec![vec![0; 10]; UD_EP_COUNT as usize];

    for i in 0..UD_EP_COUNT {
        let state = CubieCube {
            ep: index_to_ud_ep(i),
            ..Default::default()
        };

        for (j, m) in PHASE2_MOVES.iter().enumerate() {
            let new_state = state.apply_move(*m);
            ep_table[i as usize][j] = ud_ep_to_index(&new_state.ep);
        }
    }

    ep_table
}

pub fn get_e_ep_table() -> Table<u16> {
    let mut e_ep_table = vec![vec![0; 10]; E_EP_COUNT as usize];

    for i in 0..E_EP_COUNT {
        let state = CubieCube {
            ep: index_to_e_ep(i),
            ..Default::default()
        };

        for (j, m) in PHASE2_MOVES.iter().enumerate() {
            let new_state = state.apply_move(*m);
            e_ep_table[i as usize][j] = e_ep_to_index(&new_state.ep);
        }
    }

    e_ep_table
}