diff --git a/coverage/html/badges/flat.svg b/coverage/html/badges/flat.svg index cbcfb5c..b482db6 100644 --- a/coverage/html/badges/flat.svg +++ b/coverage/html/badges/flat.svg @@ -1,6 +1,6 @@ - coverage: 69% + xmlns:xlink="http://www.w3.org/1999/xlink" width="96" height="20" role="img" aria-label="coverage: 77%"> + coverage: 77% @@ -10,14 +10,14 @@ - + coverage - - 69% + + 77% \ No newline at end of file diff --git a/coverage/html/badges/flat_square.svg b/coverage/html/badges/flat_square.svg index 36d4829..cc89b0d 100644 --- a/coverage/html/badges/flat_square.svg +++ b/coverage/html/badges/flat_square.svg @@ -1,13 +1,13 @@ - coverage: 69% + xmlns:xlink="http://www.w3.org/1999/xlink" width="96" height="20" role="img" aria-label="coverage: 77%"> + coverage: 77% - + coverage - 69% + 77% \ No newline at end of file diff --git a/coverage/html/badges/for_the_badge.svg b/coverage/html/badges/for_the_badge.svg index 0cfc978..427f757 100644 --- a/coverage/html/badges/for_the_badge.svg +++ b/coverage/html/badges/for_the_badge.svg @@ -1,13 +1,13 @@ - COVERAGE: 69% + xmlns:xlink="http://www.w3.org/1999/xlink" width="142.5" height="28" role="img" aria-label="COVERAGE: 77%"> + COVERAGE: 77% - + COVERAGE - 69% + 77% \ No newline at end of file diff --git a/coverage/html/badges/plastic.svg b/coverage/html/badges/plastic.svg index 68d3549..5900c59 100644 --- a/coverage/html/badges/plastic.svg +++ b/coverage/html/badges/plastic.svg @@ -1,6 +1,6 @@ - coverage: 69% + xmlns:xlink="http://www.w3.org/1999/xlink" width="96" height="18" role="img" aria-label="coverage: 77%"> + coverage: 77% @@ -12,14 +12,14 @@ - + coverage - - 69% + + 77% \ No newline at end of file diff --git a/coverage/html/badges/social.svg b/coverage/html/badges/social.svg index 45c8c46..8aeabdb 100644 --- a/coverage/html/badges/social.svg +++ b/coverage/html/badges/social.svg @@ -1,6 +1,6 @@ - Coverage: 69% + xmlns:xlink="http://www.w3.org/1999/xlink" width="99" height="20" role="img" aria-label="Coverage: 77%"> + Coverage: 77% @@ -20,8 +20,8 @@ Coverage - - 69% + + 77% \ No newline at end of file diff --git a/src/craft.rs b/src/craft.rs index 9f4cd95..f5788f3 100644 --- a/src/craft.rs +++ b/src/craft.rs @@ -211,8 +211,8 @@ impl<'a> Craft<'a> { ) } - /// Create a "Three start" craft, testing only - pub fn three_star() -> Craft<'a> { + /// Create a "Two start" craft, testing only + pub fn two_star() -> Craft<'a> { Self::new( crate::specs::Recipe { durability: 70, @@ -237,6 +237,33 @@ impl<'a> Craft<'a> { }, ) } + + /// Create a "Zero star" craft for debbuging & testing + pub fn zero_star() -> Craft<'a> { + Self::new( + crate::specs::Recipe { + durability: 70, + progress: 4000, + quality: 10920, + progress_divider: 100, + quality_divider: 100, + progress_modifier: 100, + quality_modifier: 100, + }, + crate::specs::Stats { + craftsmanship: 4000, + control: 4000, + max_cp: 600, + }, + crate::io::Parameters { + threads: 8, + verbose: 2, + depth: 8, + desperate: false, + byregot_step: 10, + }, + ) + } } #[cfg(test)] @@ -245,9 +272,9 @@ mod test { // Struct Test #[test] pub fn struct_tests() { - let craft = crate::craft::Craft::default().clone(); - assert_eq!(craft.get_base_progression(), 22); - assert_eq!(craft.get_base_quality(), 55); + let craft = crate::craft::Craft::zero_star().clone(); + assert_eq!(craft.get_base_progression(), 402); + assert_eq!(craft.get_base_quality(), 435); format!("{}", craft); format!("{:?}", craft); diff --git a/src/solver.rs b/src/solver.rs index bbce062..7c7d569 100644 --- a/src/solver.rs +++ b/src/solver.rs @@ -108,9 +108,10 @@ pub fn generate_routes_phase1<'a>(craft: Craft<'a>) -> Vec> { continue; } else if 0.0 < remaining_prog && remaining_prog <= 1.2 { // pass // Will finish with basicSynth2 (free) - } else if 1.2 < remaining_prog && remaining_prog <= 1.2 { - craft.cp -= 7; // Will finish with carefulSynthesis (7cp) - } else if 1.2 < remaining_prog && remaining_prog <= 2.0 { + // TODO: Test replacing this value with 1.8 that should be the correct value but hasnt be tested + // } else if 1.2 < remaining_prog && remaining_prog <= 1.4 { + // craft.cp -= 7; // Will finish with carefulSynthesis (7cp) + } else if 1.4 < remaining_prog && remaining_prog <= 2.0 { craft.cp -= 12; // Will finish with observe+focusedSynthesis (12cp) } craft.durability -= 10; // Save the final step, since we always aim to end with -5dur, it doesn't matter @@ -247,253 +248,4 @@ pub fn generate_routes_phase2<'a>(craft: Craft<'a>) -> Option>> { Some(top_routes) } -#[cfg(test)] -mod test { - use crate::solver::{generate_routes_phase1, next_action_picker_1, ACTIONS}; - - #[test] - pub fn test_first_step() { - let mut craft = crate::craft::Craft::three_star(); - // Try a failed craft - craft.success = crate::specs::Success::Failure; - let vact = next_action_picker_1(&craft); - assert_eq!(vact, vec![None]); - craft.success = crate::specs::Success::Pending; - - // Try the first 4 steps - let vact = next_action_picker_1(&craft); - assert_eq!(vact, action_vec![ACTIONS.muscle_memory]); - craft.run_action(&ACTIONS.muscle_memory); - - let vact = next_action_picker_1(&craft); - assert_eq!(vact, action_vec![ACTIONS.manipulation]); - craft.run_action(&ACTIONS.manipulation); - - let vact = next_action_picker_1(&craft); - assert_eq!(vact, action_vec![ACTIONS.veneration]); - craft.run_action(&ACTIONS.veneration); - - let vact = next_action_picker_1(&craft); - assert_eq!(vact, action_vec![ACTIONS.waste_not_ii, ACTIONS.groundwork]); - craft.run_action(&ACTIONS.waste_not_ii); - - // Try the steps 5-8, deterministically - let vact = next_action_picker_1(&craft); - assert_eq!(vact, action_vec![ACTIONS.groundwork]); - craft.run_action(&ACTIONS.careful_synthesis); - - let vact = next_action_picker_1(&craft); - assert_eq!( - vact, - action_vec![ - ACTIONS.groundwork, - ACTIONS.basic_synthesis, - ACTIONS.careful_synthesis, - ACTIONS.delicate_synthesis - ] - ); - craft.run_action(&ACTIONS.careful_synthesis); - - let vact = next_action_picker_1(&craft); - assert_eq!( - vact, - action_vec![ - ACTIONS.groundwork, - ACTIONS.basic_synthesis, - ACTIONS.careful_synthesis, - ACTIONS.delicate_synthesis - ] - ); - craft.run_action(&ACTIONS.careful_synthesis); - - let vact = next_action_picker_1(&craft); - assert_eq!( - vact, - action_vec![ - ACTIONS.groundwork, - ACTIONS.basic_synthesis, - ACTIONS.careful_synthesis, - ACTIONS.delicate_synthesis - ] - ); - craft.run_action(&ACTIONS.careful_synthesis); - - // Check odd parameters - craft.buffs.waste_not = 0; - craft.progression = 0; - let vact = next_action_picker_1(&craft); - assert_eq!( - vact, - action_vec![ - ACTIONS.basic_synthesis, - ACTIONS.careful_synthesis, - ACTIONS.prudent_synthesis, - ACTIONS.delicate_synthesis - ] - ); - craft.run_action(&ACTIONS.delicate_synthesis); - - let vact = next_action_picker_1(&craft); - assert_eq!( - vact, - action_vec![ - ACTIONS.basic_synthesis, - ACTIONS.careful_synthesis, - ACTIONS.prudent_synthesis, - ACTIONS.delicate_synthesis, - ACTIONS.waste_not_ii, - ACTIONS.waste_not - ] - ); - - craft.args.desperate = true; - let vact = next_action_picker_1(&craft); - assert_eq!( - vact, - action_vec![ - ACTIONS.basic_synthesis, - ACTIONS.careful_synthesis, - ACTIONS.prudent_synthesis, - ACTIONS.delicate_synthesis, - ACTIONS.groundwork, - ACTIONS.masters_mend, - ACTIONS.waste_not_ii, - ACTIONS.waste_not - ] - ); - } - - #[test] - pub fn test_routes_p1() { - let craft = crate::craft::Craft::three_star(); - let mut routes1 = generate_routes_phase1(craft); - - for route in routes1.iter() { - println!("{:?}", route.actions); - } - // Literrally any change will break it - // An eq should be implmented to just check a vector of vector versus a route - assert_eq!(routes1.len(), 9); - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.waste_not_ii, - &ACTIONS.groundwork, - &ACTIONS.delicate_synthesis, - &ACTIONS.delicate_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.waste_not_ii, - &ACTIONS.groundwork, - &ACTIONS.delicate_synthesis, - &ACTIONS.basic_synthesis, - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.waste_not_ii, - &ACTIONS.groundwork, - &ACTIONS.careful_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.waste_not_ii, - &ACTIONS.groundwork, - &ACTIONS.basic_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.groundwork, - &ACTIONS.delicate_synthesis, - &ACTIONS.delicate_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.groundwork, - &ACTIONS.delicate_synthesis, - &ACTIONS.basic_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.groundwork, - &ACTIONS.prudent_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.groundwork, - &ACTIONS.careful_synthesis - ] - ); - - let route = routes1.pop().unwrap(); - assert_eq!( - route.actions, - vec![ - &ACTIONS.muscle_memory, - &ACTIONS.manipulation, - &ACTIONS.veneration, - &ACTIONS.groundwork, - &ACTIONS.basic_synthesis - ] - ); - - let route = routes1.pop(); - match route { - None => (), - Some(..) => panic!(), - } - } -} +mod test_solver; diff --git a/src/solver/test_solver.rs b/src/solver/test_solver.rs new file mode 100644 index 0000000..1535d72 --- /dev/null +++ b/src/solver/test_solver.rs @@ -0,0 +1,391 @@ +#[allow(unused_imports)] +use super::*; + +#[test] +pub fn test_first_step() { + let mut craft = crate::craft::Craft::two_star(); + // Try a failed craft + craft.success = crate::specs::Success::Failure; + let vact = next_action_picker_1(&craft); + assert_eq!(vact, vec![None]); + craft.success = crate::specs::Success::Pending; + + // Try the first 4 steps + let vact = next_action_picker_1(&craft); + assert_eq!(vact, action_vec![ACTIONS.muscle_memory]); + craft.run_action(&ACTIONS.muscle_memory); + + let vact = next_action_picker_1(&craft); + assert_eq!(vact, action_vec![ACTIONS.manipulation]); + craft.run_action(&ACTIONS.manipulation); + + let vact = next_action_picker_1(&craft); + assert_eq!(vact, action_vec![ACTIONS.veneration]); + craft.run_action(&ACTIONS.veneration); + + let vact = next_action_picker_1(&craft); + assert_eq!(vact, action_vec![ACTIONS.waste_not_ii, ACTIONS.groundwork]); + craft.run_action(&ACTIONS.waste_not_ii); + + // Try the steps 5-8, deterministically + let vact = next_action_picker_1(&craft); + assert_eq!(vact, action_vec![ACTIONS.groundwork]); + craft.run_action(&ACTIONS.careful_synthesis); + + let vact = next_action_picker_1(&craft); + assert_eq!( + vact, + action_vec![ + ACTIONS.groundwork, + ACTIONS.basic_synthesis, + ACTIONS.careful_synthesis, + ACTIONS.delicate_synthesis + ] + ); + craft.run_action(&ACTIONS.careful_synthesis); + + let vact = next_action_picker_1(&craft); + assert_eq!( + vact, + action_vec![ + ACTIONS.groundwork, + ACTIONS.basic_synthesis, + ACTIONS.careful_synthesis, + ACTIONS.delicate_synthesis + ] + ); + craft.run_action(&ACTIONS.careful_synthesis); + + let vact = next_action_picker_1(&craft); + assert_eq!( + vact, + action_vec![ + ACTIONS.groundwork, + ACTIONS.basic_synthesis, + ACTIONS.careful_synthesis, + ACTIONS.delicate_synthesis + ] + ); + craft.run_action(&ACTIONS.careful_synthesis); + + // Check odd parameters + craft.buffs.waste_not = 0; + craft.progression = 0; + let vact = next_action_picker_1(&craft); + assert_eq!( + vact, + action_vec![ + ACTIONS.basic_synthesis, + ACTIONS.careful_synthesis, + ACTIONS.prudent_synthesis, + ACTIONS.delicate_synthesis + ] + ); + craft.run_action(&ACTIONS.delicate_synthesis); + + let vact = next_action_picker_1(&craft); + assert_eq!( + vact, + action_vec![ + ACTIONS.basic_synthesis, + ACTIONS.careful_synthesis, + ACTIONS.prudent_synthesis, + ACTIONS.delicate_synthesis, + ACTIONS.waste_not_ii, + ACTIONS.waste_not + ] + ); + + craft.args.desperate = true; + let vact = next_action_picker_1(&craft); + assert_eq!( + vact, + action_vec![ + ACTIONS.basic_synthesis, + ACTIONS.careful_synthesis, + ACTIONS.prudent_synthesis, + ACTIONS.delicate_synthesis, + ACTIONS.groundwork, + ACTIONS.masters_mend, + ACTIONS.waste_not_ii, + ACTIONS.waste_not + ] + ); + assert_eq!(craft.progression, 250); + assert_eq!(craft.quality, 266); + assert_eq!(craft.cp, 317); +} + +#[test] +pub fn test_routes_p1() { + let craft = crate::craft::Craft::two_star(); + let mut routes1 = generate_routes_phase1(craft); + + for route in routes1.iter() { + println!("{:?}", route.actions); + } + // Literrally any change will break it + // An eq should be implmented to just check a vector of vector versus a route + assert_eq!(routes1.len(), 9); + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.waste_not_ii, + &ACTIONS.groundwork, + &ACTIONS.delicate_synthesis, + &ACTIONS.delicate_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.waste_not_ii, + &ACTIONS.groundwork, + &ACTIONS.delicate_synthesis, + &ACTIONS.basic_synthesis, + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.waste_not_ii, + &ACTIONS.groundwork, + &ACTIONS.careful_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.waste_not_ii, + &ACTIONS.groundwork, + &ACTIONS.basic_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.groundwork, + &ACTIONS.delicate_synthesis, + &ACTIONS.delicate_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.groundwork, + &ACTIONS.delicate_synthesis, + &ACTIONS.basic_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.groundwork, + &ACTIONS.prudent_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.groundwork, + &ACTIONS.careful_synthesis + ] + ); + + let route = routes1.pop().unwrap(); + assert_eq!( + route.actions, + vec![ + &ACTIONS.muscle_memory, + &ACTIONS.manipulation, + &ACTIONS.veneration, + &ACTIONS.groundwork, + &ACTIONS.basic_synthesis + ] + ); + + let route = routes1.pop(); + assert!(route.is_none()); +} + +// Test Custom routes (None and basic synthesis) +#[test] +pub fn test_custom_p1_routes() { + // None route, no more actions + let mut craft = crate::craft::Craft::zero_star(); + craft.success = crate::specs::Success::Failure; + let routes1 = generate_routes_phase1(craft.clone()); + assert!(routes1.is_empty()); +} + +// Test step 2 route-finding +#[test] +pub fn test_second_step() { + let mut craft = crate::craft::Craft::two_star(); + craft.cp = 10000; + let mut routes1 = generate_routes_phase1(craft); + let mut craft2 = routes1.pop().unwrap(); + let vact = next_action_phase_2(&craft2); + assert_eq!(vact, action_vec![ACTIONS.innovation]); + craft2.run_action(&ACTIONS.innovation); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.basic_touch, ACTIONS.preparatory_touch] + ); + craft2.run_action(&ACTIONS.basic_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.preparatory_touch, ACTIONS.standard_touch] + ); + craft2.run_action(&ACTIONS.standard_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.preparatory_touch, ACTIONS.advanced_touch] + ); + craft2.run_action(&ACTIONS.advanced_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ + ACTIONS.basic_touch, + ACTIONS.preparatory_touch, + ACTIONS.manipulation + ] + ); + craft2.run_action(&ACTIONS.manipulation); + + let vact = next_action_phase_2(&craft2); + assert_eq!(vact, action_vec![ACTIONS.innovation]); + craft2.run_action(&ACTIONS.innovation); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.basic_touch, ACTIONS.prudent_touch] + ); + craft2.run_action(&ACTIONS.basic_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.prudent_touch, ACTIONS.standard_touch] + ); + craft2.run_action(&ACTIONS.prudent_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.basic_touch, ACTIONS.prudent_touch] + ); + craft2.run_action(&ACTIONS.prudent_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.basic_touch, ACTIONS.prudent_touch] + ); + craft2.run_action(&ACTIONS.prudent_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!(vact, action_vec![ACTIONS.innovation]); + craft2.run_action(&ACTIONS.innovation); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ACTIONS.basic_touch, ACTIONS.prudent_touch] + ); + craft2.run_action(&ACTIONS.prudent_touch); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ + ACTIONS.basic_touch, + ACTIONS.prudent_touch, + ACTIONS.trained_finesse, + ACTIONS.great_strides + ] + ); + craft2.run_action(&ACTIONS.great_strides); + + let vact = next_action_phase_2(&craft2); + assert_eq!( + vact, + action_vec![ + ACTIONS.basic_touch, + ACTIONS.prudent_touch, + ACTIONS.byregot_blessing + ] + ); + + craft2.run_action(&ACTIONS.byregot_blessing); + craft2.success = crate::specs::Success::Success; + assert_eq!(next_action_phase_2(&craft2), vec![None]); + assert_eq!(craft2.progression, 3750); + assert_eq!(craft2.quality, 9899); + assert_eq!(craft2.cp, 9322); +} + +#[test] +pub fn test_generate_routes_p2() { + let craft = crate::craft::Craft::two_star(); + let mut routes1 = generate_routes_phase1(craft); + let craft1 = routes1.pop().unwrap(); + let routes2 = generate_routes_phase2(craft1); + assert_eq!(routes2.unwrap().len(), 241); + + // Any modification on the solving will break this test, same as before, + // maybe having a range of expected solution instead is the way to go. + + // Nonetheless the solver test will add qualitative testing so some + // results will be thoughrouly checked + + // Maybe sampling a handful results and expect them to always exits could also work +} diff --git a/tests/io.rs b/tests/io.rs deleted file mode 100644 index 8b13789..0000000 --- a/tests/io.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/tests/lib.rs b/tests/lib.rs deleted file mode 100644 index 8b13789..0000000 --- a/tests/lib.rs +++ /dev/null @@ -1 +0,0 @@ -