1
3
use crate::io::SolverResult;
2
use crate::{
3
    craft::Craft,
4
    io::Parameters,
5
    specs::{Recipe, Stats},
6
};
7
use std::sync::{Arc, Mutex};
8
use threadpool::ThreadPool;
9

            
10
pub mod action;
11
pub mod craft;
12
pub mod io;
13
mod solver;
14
mod specs;
15

            
16
/// Solve the craft with given arguments, this functions calls threads and must own it's values
17
pub fn solve_craft<'a>(
18
    recipe: Recipe,
19
    stats: Stats,
20
    params: Parameters,
21
) -> Option<Vec<SolverResult>> {
22
    // Load the craft with given arguments
23
    let craft = Craft::new(recipe, stats, params);
24

            
25
    // Start a threadpool
26
    let pool = ThreadPool::new(params.threads);
27

            
28
    #[cfg(feature = "verbose")]
29
    if params.verbose > 0 {
30
        println!("[P1] Starting phase 1...");
31
    }
32

            
33
    let phase1_routes = solver::generate_routes_phase1(craft);
34
    let nb_p1 = phase1_routes.len();
35

            
36
    #[cfg(feature = "verbose")]
37
    if params.verbose > 0 {
38
        println!(
39
            "[P1] Found {} routes, testing them all...",
40
            phase1_routes.len()
41
        );
42
        if params.verbose > 1 {
43
            for r in &phase1_routes {
44
                println!(
45
                    "[P1] {:?} p:{}% q:{}% c:{} d:{}",
46
                    r.actions,
47
                    r.progression,
48
                    r.quality * 100 / r.recipe.quality,
49
                    r.cp,
50
                    r.durability
51
                );
52
            }
53
        }
54
    }
55

            
56
    // Core algorithm, fill all found routes with the best route (doesn't branch, just replace)
57
    let arc_phase2_routes = Arc::new(Mutex::new(Vec::<Craft>::new()));
58

            
59
    for route in phase1_routes {
60
        let _phase2_routes = Arc::clone(&arc_phase2_routes);
61

            
62
        pool.execute(move || {
63
            if let Some(mut _route) = solver::generate_routes_phase2(route) {
64
                let mut shared = _phase2_routes.lock().unwrap();
65
                shared.append(&mut _route);
66
            };
67
        });
68
    }
69

            
70
    pool.join();
71
    let phase2_routes = arc_phase2_routes.lock().unwrap();
72
    let nb_p2 = phase2_routes.len();
73

            
74
    // Drop on empty results
75
    if phase2_routes.len() == 0 {
76
        return None;
77
    }
78

            
79
    // Print the results if verbose
80
    #[cfg(feature = "verbose")]
81
    if params.verbose > 0 {
82
        println!("[P2] Found {} solutions, sorting", phase2_routes.len());
83
        if params.verbose > 1 {
84
            for r in phase2_routes.iter() {
85
                println!(
86
                    "[P2] {:?} p:{}% q:{}% d:{}",
87
                    r.actions,
88
                    r.progression * 100 / r.recipe.progress,
89
                    r.quality * 100 / r.recipe.quality,
90
                    r.durability
91
                );
92
            }
93
        }
94
    }
95

            
96
    // Prune the results for analysis
97
    // let mut valid_routes : Vec<Craft> = vec![];
98
    let mut valid_solutions: Vec<SolverResult> = vec![];
99
    for route in phase2_routes.iter() {
100
        if route.quality >= route.recipe.quality {
101
            // valid_routes.push(route.clone());
102
            valid_solutions.push(SolverResult::from_craft(route, nb_p1, nb_p2, true));
103
        }
104
    }
105
    // If no craft can make it to 100% HQ, fallback to base results
106
    if valid_solutions.len() == 0 {
107
        for route in phase2_routes.iter() {
108
            valid_solutions.push(SolverResult::from_craft(route, nb_p1, nb_p2, false));
109
        }
110
    }
111

            
112
    Some(valid_solutions)
113
}
114

            
115
/// Load the config from args and make a craft from it
116
pub fn load_from_config<'a>(
117
    recipe_name: &str,
118
    file_name: &str,
119
    character_name: &str,
120
) -> (Recipe, Stats) {
121
    //read craft.toml
122
    let config: toml::Value = toml::from_str(
123
        &std::fs::read_to_string(file_name).expect(&format!("Can't open {}", file_name)),
124
    )
125
    .unwrap();
126

            
127
    let recp = match config.get(recipe_name) {
128
        Some(r) => r,
129
        None => panic!("Can't find value '{}' in '{}'", recipe_name, file_name),
130
    };
131

            
132
    // Load receipe values
133
    let recipe = Recipe {
134
        durability: recp
135
            .get("durability")
136
            .expect(&format!(
137
                "Can't find 'durability' in recipe '{}' on file '{}'",
138
                recipe_name, file_name
139
            ))
140
            .as_integer()
141
            .expect("Can't convert durability as an integer") as u32,
142
        progress: recp
143
            .get("progress")
144
            .expect(&format!(
145
                "Can't find 'progress' in recipe '{}' on '{}'",
146
                recipe_name, file_name
147
            ))
148
            .as_integer()
149
            .expect("Can't convert progress as an integer") as u32,
150
        quality: recp
151
            .get("quality")
152
            .expect(&format!(
153
                "Can't find 'quality' in recipe '{}' on '{}'",
154
                recipe_name, file_name
155
            ))
156
            .as_integer()
157
            .expect("Can't convert quality as an integer") as u32,
158
        progress_divider: recp
159
            .get("progress_divider")
160
            .expect(&format!(
161
                "Can't find 'progress_divider' in recipe '{}' on '{}'",
162
                recipe_name, file_name
163
            ))
164
            .as_integer()
165
            .expect("Can't convert progress_divider as an integer")
166
            as u32,
167
        quality_divider: recp
168
            .get("quality_divider")
169
            .expect(&format!(
170
                "Can't find 'quality_divider' in recipe '{}' on '{}'",
171
                recipe_name, file_name
172
            ))
173
            .as_integer()
174
            .expect("Can't convert quality_divider as an integer") as u32,
175
        progress_modifier: recp
176
            .get("progress_modifier")
177
            .expect(&format!(
178
                "Can't find 'progress_modifier' in recipe '{}' on '{}'",
179
                recipe_name, file_name
180
            ))
181
            .as_integer()
182
            .expect("Can't convert progress_modifier as an integer")
183
            as u32,
184
        quality_modifier: recp
185
            .get("quality_modifier")
186
            .expect(&format!(
187
                "Can't find 'quality_modifier' in recipe '{}' on '{}'",
188
                recipe_name, file_name
189
            ))
190
            .as_integer()
191
            .expect("Can't convert quality_modifier as an integer")
192
            as u32,
193
    };
194

            
195
    let cfg = match config.get(character_name) {
196
        Some(c) => c,
197
        None => panic!("Can't find '{}' in file '{}'", character_name, file_name),
198
    };
199
    let stats = Stats {
200
        craftsmanship: cfg
201
            .get("craftsmanship")
202
            .expect(&format!(
203
                "Can't find 'craftsmanship' in character '{}' on file '{}'",
204
                character_name, file_name
205
            ))
206
            .as_integer()
207
            .expect("Can't convert craftsmanship as an integer") as u32,
208
        control: cfg
209
            .get("control")
210
            .expect(&format!(
211
                "Can't find 'control' in character '{}' on file '{}'",
212
                character_name, file_name
213
            ))
214
            .as_integer()
215
            .expect("Can't convert control as an integer") as u32,
216
        max_cp: cfg
217
            .get("max_cp")
218
            .expect(&format!(
219
                "Can't find 'max_cp' in character '{}' on file '{}'",
220
                character_name, file_name
221
            ))
222
            .as_integer()
223
            .expect("Can't convert max_cp as an integer") as u32,
224
    };
225
    (recipe, stats)
226
}
227

            
228
/// Print all routes in the vect, verbose
229
pub fn print_routes<'a>(routes: &Option<Vec<SolverResult>>) {
230
    match routes {
231
        Some(r) => {
232
            println!("Showing {} routes", r.len());
233
            for c in r.iter() {
234
                println!(
235
                    "\n[{}ยค][{}@][{}#] {:?} ",
236
                    c.quality, c.durability, c.steps, c.actions
237
                )
238
            }
239
        }
240
        None => println!("No routes to print"),
241
    }
242
}
243

            
244
/// Find the route with the least amount of steps
245
pub fn find_fast_route(routes: &Option<Vec<SolverResult>>) -> Option<&SolverResult> {
246
    match routes {
247
        Some(_routes) => {
248
            if _routes.len() > 0 {
249
                _routes.iter().min_by_key(|key| key.steps)
250
            } else {
251
                None
252
            }
253
        }
254
        None => None,
255
    }
256
}
257

            
258
/// Find the route with the maximum amount of quality
259
pub fn find_quality_route(routes: &Option<Vec<SolverResult>>) -> Option<&SolverResult> {
260
    match routes {
261
        Some(_routes) => _routes.iter().max_by_key(|key| key.quality),
262
        None => None,
263
    }
264
}
265

            
266
/// Find the route with the maximum of durability left
267
pub fn find_safe_route(routes: &Option<Vec<SolverResult>>) -> Option<&SolverResult> {
268
    match routes {
269
        Some(_routes) => {
270
            if _routes.len() > 0 {
271
                _routes.iter().max_by_key(|key| key.durability)
272
            } else {
273
                None
274
            }
275
        }
276
        None => None,
277
    }
278
}