twsearch 0.10.0

Twizzle Search — Twisty puzzle search 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
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

// Run using: cargo run --package twsearch --release --example 2x2x2_three_phase

use cubing::{alg::parse_move, kpuzzle::kpattern_from_json_file, puzzles::cube2x2x2_kpuzzle};
use twsearch::{
    _internal::{cli::args::VerbosityLevel, search::search_logger::SearchLogger},
    experimental_lib_api::{KPuzzleSimpleMaskPhase, MultiPhaseSearch, MultiPhaseSearchOptions},
    scramble::{random_scramble_for_event, Event},
};

kpattern_from_json_file!(
    pub(crate),
    phase1,
    "./2x2x2_three_phase/phase1-D-orientation.kpattern.json",
    cube2x2x2_kpuzzle()
);

kpattern_from_json_file!(
    pub(crate),
    phase2,
    "./2x2x2_three_phase/phase2-U-orientation.kpattern.json",
    cube2x2x2_kpuzzle()
);

pub fn main() {
    let kpuzzle = cube2x2x2_kpuzzle();

    // Note: this solver isn't really a "good idea". It's just a convenient test
    // of three phases, on a puzzle with few-ish states.
    let mut search = MultiPhaseSearch::try_new(
        kpuzzle.clone(),
        vec![
            Box::new(
                KPuzzleSimpleMaskPhase::try_new(
                    "D orientation".to_owned(),
                    phase1_kpattern().clone(),
                    vec![
                        parse_move!("U").to_owned(),
                        parse_move!("L").to_owned(),
                        parse_move!("F").to_owned(),
                        parse_move!("R").to_owned(),
                        parse_move!("B").to_owned(),
                        parse_move!("D").to_owned(),
                    ],
                    Default::default(),
                )
                .unwrap(),
            ),
            Box::new(
                KPuzzleSimpleMaskPhase::try_new(
                    "U orientation".to_owned(),
                    phase2_kpattern().clone(),
                    vec![
                        parse_move!("U").to_owned(),
                        parse_move!("F").to_owned(),
                        parse_move!("R").to_owned(),
                    ],
                    Default::default(),
                )
                .unwrap(),
            ),
            Box::new(
                KPuzzleSimpleMaskPhase::try_new(
                    "PBL".to_owned(),
                    kpuzzle.default_pattern().clone(),
                    vec![
                        parse_move!("U").to_owned(),
                        parse_move!("R2").to_owned(),
                        parse_move!("F2").to_owned(),
                        parse_move!("L2").to_owned(),
                        parse_move!("D").to_owned(),
                    ],
                    Default::default(),
                )
                .unwrap(),
            ),
        ],
        MultiPhaseSearchOptions {
            search_logger: SearchLogger {
                verbosity: VerbosityLevel::Info,
            },
            ..Default::default()
        },
    )
    .unwrap();

    let scramble_alg = random_scramble_for_event(Event::Cube2x2x2Speedsolving).unwrap();
    let scramble = kpuzzle.default_pattern().apply_alg(&scramble_alg).unwrap();
    println!(
        "{} // scramble alg
{} // solution",
        scramble_alg,
        search
            .chain_first_solution_for_each_phase(&scramble)
            .unwrap()
    );
}