From e97c4ee400cf941a51c565540a995ce05c8b3c3c Mon Sep 17 00:00:00 2001 From: Rika Date: Sat, 17 Sep 2022 19:18:52 +0800 Subject: [PATCH] readme --- .gitignore | 3 + Cargo.lock | 103 ++++++++++++++++++++++++ Cargo.toml | 12 +++ README.md | 45 +++++++++++ craft.toml | 13 +++ img.png | Bin 0 -> 9961 bytes img_1.png | Bin 0 -> 3127 bytes src/action.rs | 214 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/craft.rs | 81 +++++++++++++++++++ src/main.rs | 59 ++++++++++++++ src/solver.rs | 147 ++++++++++++++++++++++++++++++++++ src/specs.rs | 118 ++++++++++++++++++++++++++++ 12 files changed, 795 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 README.md create mode 100644 craft.toml create mode 100644 img.png create mode 100644 img_1.png create mode 100644 src/action.rs create mode 100644 src/craft.rs create mode 100644 src/main.rs create mode 100644 src/solver.rs create mode 100644 src/specs.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..15bdd96 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/target +/.idea +*.iml diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..61ff896 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,103 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "heck" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "proc-macro2" +version = "1.0.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustversion" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8" + +[[package]] +name = "serde" +version = "1.0.144" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f747710de3dcd43b88c9168773254e809d8ddbdf9653b84e2554ab219f17860" + +[[package]] +name = "strum" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.24.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "rustversion", + "syn", +] + +[[package]] +name = "syn" +version = "1.0.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "toml" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7" +dependencies = [ + "serde", +] + +[[package]] +name = "unicode-ident" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf" + +[[package]] +name = "xiv_craft_simulator" +version = "0.1.0" +dependencies = [ + "lazy_static", + "strum", + "strum_macros", + "toml", +] diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..145ed15 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "xiv_craft_simulator" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +strum_macros = "0.24" +strum = { version = "0.24", features = ["derive"] } +lazy_static = "1.4.0" +toml = "0.5.9" \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..53ade66 --- /dev/null +++ b/README.md @@ -0,0 +1,45 @@ +# xiv_craft_solver +A rust program for solving FFXIV craft recipe. **Only normal lv90 recipes with stars works.** + +## Usage +1. Download the latest release. +2. Unzip the file. +3. Edit the `craft.toml` file. +4. Run the program. +5. Wait for about 1 minute. +6. Copy the output. +7. Import to other simulators. + +#### Example +Note: The recipe data can be retrieved from [FFXIV Crafting Optimizer](https://yyyy.games/crafter/#/simulator) +with checking of **Custom Recipe** after selecting the recipe. +![img.png](img.png) +```toml +[recipe] +durability = 70 +progress = 5060 +quality = 12628 +progress_divider = 130 # as Progress Difficulty +quality_divider = 115 # as Quality Difficulty +progress_modifier = 80 # as Extra Progress Difficulty +quality_modifier = 70 # as Extra Quality Difficulty + +[stats] # including food and potion +craftsmanship = 3745 +control = 3636 +max_cp = 670 +``` + +#### Output +``` +Solving... + +Quality: 11126/12628 + ["muscleMemory", "manipulation", "veneration", "groundwork2", "basicSynth2", "prudentSynthesis", "prudentSynthesis", "prudentSynthesis", "prudentTouch", "prudentTouch", "manipulation", "innovation", "prudentTouch", "basicTouch", "standardTouch", "advancedTouch", "innovation", "prudentTouch", "basicTouch", "standardTouch", "advancedTouch", "innovation", "trainedFinesse", "trainedFinesse", "greatStrides", "byregotsBlessing", "basicSynth2"] + +Press enter to exit... +``` + +You can copy the array part and import to other simulators. + +![img_1.png](img_1.png) \ No newline at end of file diff --git a/craft.toml b/craft.toml new file mode 100644 index 0000000..fceb4ec --- /dev/null +++ b/craft.toml @@ -0,0 +1,13 @@ +[recipe] +durability = 70 +progress = 5060 +quality = 12628 +progress_divider = 130 +quality_divider = 115 +progress_modifier = 80 +quality_modifier = 70 + +[stats] +craftsmanship = 3745 +control = 3636 +max_cp = 670 \ No newline at end of file diff --git a/img.png b/img.png new file mode 100644 index 0000000000000000000000000000000000000000..51412a64b983245341ad8accb348732c7739c29b GIT binary patch literal 9961 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 literal 0 HcmV?d00001 diff --git a/src/action.rs b/src/action.rs new file mode 100644 index 0000000..ea63002 --- /dev/null +++ b/src/action.rs @@ -0,0 +1,214 @@ +use std::fmt::Debug; +use lazy_static::lazy_static; +use crate::craft::Craft; +use crate::specs::{Buff, Success}; + +pub struct Action { + pub name: String, + pub dur: u32, + pub cp: u32, + pub progress: u32, + pub quality: u32, + pub buff: Option<(Buff, u8)>, + pub short_name: String, +} + +pub struct ActionBuilder { + action: Action, +} + +impl ActionBuilder { + pub fn new(name: &str) -> Self { + let mut short_name = name.to_string(); + short_name = short_name.replace("II", "2"); + short_name.retain(|c| !c.is_whitespace() && c != '\''); + short_name[0..1].make_ascii_lowercase(); + if name == "Basic Synthesis" { short_name = "basicSynth2".to_string(); } + if name == "Groundwork" { short_name = "groundwork2".to_string(); } + + Self { + action: Action { + name: name.to_string(), + dur: 10, + cp: 0, + progress: 0, + quality: 0, + buff: None, + short_name, + } + } + } + pub fn dur(mut self, dur: u32) -> Self { + self.action.dur = dur; + self + } + pub fn cp(mut self, cp: u32) -> Self { + self.action.cp = cp; + self + } + pub fn progress(mut self, progress: u32) -> Self { + self.action.progress = progress; + self + } + pub fn quality(mut self, quality: u32) -> Self { + self.action.quality = quality; + self + } + pub fn buff(mut self, buff: Option<(Buff, u8)>) -> Self { + self.action.buff = buff; + self + } + pub fn build(self) -> Action { + self.action + } +} + +impl PartialEq for Action { + fn eq(&self, other: &Self) -> bool { + self.cp == other.cp && self.dur == other.dur && self.progress == other.progress && self.quality == other.quality + } +} + +impl Action { + pub fn get_name(&self) -> String { + self.name.clone() + } + pub fn get_cp_cost(&self, _craft: &Craft) -> u32 { + if self == &ACTIONS.standard_touch && _craft.buffs.basic_touch > 0 { return 18; }; + if self == &ACTIONS.advanced_touch && _craft.buffs.standard_touch > 0 { return 18; }; + self.cp + } + pub fn get_durability_cost(&self, _craft: &Craft) -> u32 { + if self == &ACTIONS.masters_mend { return 30; } + if self.dur == 0 || self.progress == 0 && self.quality == 0 { + return 0; + } + let mut dur = self.dur; + if _craft.buffs.waste_not > 0 { + dur /= 2; + } + if dur < 5 { + dur = 5; + } + dur + } + pub fn get_progress(&self, _craft: &Craft) -> u32 { + let mut prog = self.progress as f64; + if self.dur == 20 && _craft.durability < self.get_durability_cost(_craft) as i32 { + prog /= 2.0; + } + let mut mult = 1.0; + if _craft.buffs.muscle_memory > 0 { + mult += 1.0; + } + if _craft.buffs.veneration > 0 { + mult += 0.5; + } + (prog * mult).floor() as u32 + } + pub fn get_quality(&self, _craft: &Craft) -> u32 { + let mut qual = self.quality as f64; + if self == &ACTIONS.byregot_blessing { + qual = (100 + 20 * _craft.buffs.inner_quiet as u32) as f64; + } + if self.dur == 20 && _craft.durability < self.get_durability_cost(_craft) as i32 { + qual /= 2.0; + } + let mut mult = 1.0; + if _craft.buffs.great_strides > 0 { + mult += 1.0; + } + if _craft.buffs.innovation > 0 { + mult += 0.5; + } + let iq_mult = (_craft.buffs.inner_quiet as f64 * 0.1) + 1.0; + (qual * mult * iq_mult).floor() as u32 + } + pub fn get_buff(&self) -> Option<(Buff, u8)> { + self.buff + } + pub fn can_use(&self, _craft: &Craft) -> bool { + if self.get_cp_cost(_craft) > _craft.cp as u32 { + return false; + } + if _craft.success != Success::Pending { + return false; + } + if self == &ACTIONS.byregot_blessing { + return _craft.buffs.inner_quiet > 0; + } + if self == &ACTIONS.muscle_memory || self == &ACTIONS.reflect { + return _craft.step_count == 0; + } + if self == &ACTIONS.trained_finesse { + return _craft.buffs.inner_quiet >= 10; + } + true + } +} + +impl Debug for Action { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&self.name) + } +} + + +pub struct ActionList { + pub muscle_memory: Action, + pub reflect: Action, + pub basic_synthesis: Action, + pub careful_synthesis: Action, + pub groundwork: Action, + pub prudent_synthesis: Action, + pub delicate_synthesis: Action, + pub basic_touch: Action, + pub standard_touch: Action, + pub byregot_blessing: Action, + pub prudent_touch: Action, + pub preparatory_touch: Action, + pub advanced_touch: Action, + pub trained_finesse: Action, + pub masters_mend: Action, + pub waste_not: Action, + pub waste_not_ii: Action, + pub manipulation: Action, + pub veneration: Action, + pub great_strides: Action, + pub innovation: Action, +} + +impl Default for ActionList { + fn default() -> Self { + Self { + muscle_memory: ActionBuilder::new("Muscle Memory").cp(6).progress(300).buff(Some((Buff::MuscleMemory, 5))).build(), + reflect: ActionBuilder::new("Reflect").cp(6).quality(100).buff(Some((Buff::InnerQuiet, 1))).build(), + + basic_synthesis: ActionBuilder::new("Basic Synthesis").progress(120).build(), + careful_synthesis: ActionBuilder::new("Careful Synthesis").cp(7).progress(180).build(), + groundwork: ActionBuilder::new("Groundwork").cp(18).dur(20).progress(360).build(), + prudent_synthesis: ActionBuilder::new("Prudent Synthesis").cp(18).dur(5).progress(180).build(), + delicate_synthesis: ActionBuilder::new("Delicate Synthesis").cp(32).progress(100).quality(100).build(), + + basic_touch: ActionBuilder::new("Basic Touch").cp(18).quality(100).buff(Some((Buff::BasicTouch, 1))).build(), + standard_touch: ActionBuilder::new("Standard Touch").quality(125).cp(32).buff(Some((Buff::StandardTouch, 1))).build(), + byregot_blessing: ActionBuilder::new("Byregot's Blessing").cp(24).quality(100).buff(Some((Buff::InnerQuiet, 0))).build(), + prudent_touch: ActionBuilder::new("Prudent Touch").cp(25).dur(5).quality(100).build(), + preparatory_touch: ActionBuilder::new("Preparatory Touch").cp(40).dur(20).quality(200).buff(Some((Buff::InnerQuiet, 1))).build(), + advanced_touch: ActionBuilder::new("Advanced Touch").quality(150).cp(46).build(), + trained_finesse: ActionBuilder::new("Trained Finesse").cp(32).quality(100).dur(0).build(), + + masters_mend: ActionBuilder::new("Master's Mend").cp(88).build(), + waste_not: ActionBuilder::new("Waste Not").cp(56).buff(Some((Buff::WasteNot, 4))).build(), + waste_not_ii: ActionBuilder::new("Waste Not II").cp(98).buff(Some((Buff::WasteNot, 8))).build(), + manipulation: ActionBuilder::new("Manipulation").cp(96).buff(Some((Buff::Manipulation, 8))).build(), + veneration: ActionBuilder::new("Veneration").cp(18).buff(Some((Buff::Veneration, 4))).build(), + great_strides: ActionBuilder::new("Great Strides").cp(32).buff(Some((Buff::GreatStrides, 3))).build(), + innovation: ActionBuilder::new("Innovation").cp(18).buff(Some((Buff::Innovation, 4))).build(), + } + } +} + +lazy_static! { +pub static ref ACTIONS: ActionList = ActionList::default(); +} \ No newline at end of file diff --git a/src/craft.rs b/src/craft.rs new file mode 100644 index 0000000..6dbb578 --- /dev/null +++ b/src/craft.rs @@ -0,0 +1,81 @@ +use std::fmt::{Debug, Formatter}; +use crate::action::Action; +use crate::specs::{Buff, BuffState, Recipe, Stats, Success}; + +#[derive(Clone)] +pub struct Craft<'a> { + pub recipe: &'a Recipe, + pub stats: &'a Stats, + pub buffs: BuffState, + pub step_count: u32, + pub durability: i32, + pub progression: u32, + pub quality: u32, + pub cp: i32, + pub success: Success, + pub actions: Vec<&'a Action>, +} + +impl<'a> Craft<'a> { + pub fn new(recipe: &'a Recipe, stats: &'a Stats) -> Craft<'a> { + Self { + recipe, + stats, + buffs: BuffState::default(), + step_count: 0, + durability: recipe.durability as i32, + progression: 0, + quality: 0, + cp: stats.max_cp as i32, + success: Success::Pending, + actions: Vec::new(), + } + } + + pub fn get_base_progression(&self) -> u32 { + let base_value = (self.stats.craftsmanship as f64 / 10.0) / (self.recipe.progress_divider as f64 / 100.0) + 2.0; + (base_value * (self.recipe.progress_modifier as f64 / 100.0) as f64).floor() as u32 + } + + pub fn get_base_quality(&self) -> u32 { + let base_value = (self.stats.control as f64 / 10.0) / (self.recipe.quality_divider as f64 / 100.0) + 35.0; + (base_value * (self.recipe.quality_modifier as f64 / 100.0) as f64).floor() as u32 + } + + pub fn run_action(&mut self, action: &'a Action) -> &mut Craft<'a> { + if !action.can_use(self) { + self.success = Success::Failure; + return self; + } + self.step_count += 1; + self.cp -= action.get_cp_cost(self) as i32; + self.durability -= action.get_durability_cost(self) as i32; + self.progression += (action.get_progress(self) as f64 * (self.get_base_progression() as f64 / 100.0)).floor() as u32; + self.quality += (action.get_quality(self) as f64 * (self.get_base_quality() as f64 / 100.0)).floor() as u32; + if self.progression >= self.recipe.progress { self.success = Success::Success; } + if self.durability <= 0 { self.success = Success::Failure; } + if self.buffs.manipulation > 0 { self.durability += 5; } + if action.quality > 0 { self.buffs.inner_quiet += 1; } + self.buffs.tick(); + if action.progress > 0 { self.buffs.remove(Buff::MuscleMemory); } + if action.quality > 0 { self.buffs.remove(Buff::GreatStrides); } + if let Some((buff, duration)) = action.get_buff() { self.buffs.apply(buff, duration); } + if self.durability > self.recipe.durability as i32 { self.durability = self.recipe.durability as i32; } + if self.buffs.inner_quiet > 10 { self.buffs.inner_quiet = 10; } + + self.actions.push(action); + return self; + } +} + +impl<'a> Debug for Craft<'a> { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Craft") + .field("step_count", &self.step_count) + .field("progression", &format!("{:?}/{:?}", &self.progression, &self.recipe.progress)) + .field("quality", &format!("{:?}/{:?}", &self.quality, &self.recipe.quality)) + .field("durability", &format!("{:?}/{:?}", &self.durability, &self.recipe.durability)) + .field("cp", &format!("{:?}/{:?}", &self.cp, &self.stats.max_cp)) + .finish() + } +} \ No newline at end of file diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..a93acc1 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,59 @@ +use crate::craft::Craft; +use crate::solver::{generate_routes_phase1, generate_routes_phase2}; +use crate::specs::{Recipe, Stats}; + +mod specs; +pub mod action; +pub mod craft; +mod solver; + +fn main() { + //read craft.toml + let config: toml::Value = toml::from_str(&std::fs::read_to_string("craft.toml").unwrap()).unwrap(); + let recipe = Recipe { + durability: config["recipe"]["durability"].as_integer().unwrap() as u32, + progress: config["recipe"]["progress"].as_integer().unwrap() as u32, + quality: config["recipe"]["quality"].as_integer().unwrap() as u32, + progress_divider: config["recipe"]["progress_divider"].as_integer().unwrap() as u32, + quality_divider: config["recipe"]["quality_divider"].as_integer().unwrap() as u32, + progress_modifier: config["recipe"]["progress_modifier"].as_integer().unwrap() as u32, + quality_modifier: config["recipe"]["quality_modifier"].as_integer().unwrap() as u32, + }; + let stats = Stats { + craftsmanship: config["stats"]["craftsmanship"].as_integer().unwrap() as u32, + control: config["stats"]["control"].as_integer().unwrap() as u32, + max_cp: config["stats"]["max_cp"].as_integer().unwrap() as u32, + }; + let craft = Craft::new(&recipe, &stats); + println!("Solving..."); + println!(); + let phase1_routes = generate_routes_phase1(craft); + let mut phase2_routes = Vec::new(); + for route in phase1_routes { + if let Some(route) = generate_routes_phase2(route) { + phase2_routes.push(route); + } + } + let top_route = phase2_routes.iter().max_by_key(|route| route.quality).unwrap(); + let mut content = (&top_route.actions) + .iter() + .map(|action| { + format!("\"{}\"", action.short_name.clone()) + }) + .collect::>(); + let arg = (top_route.recipe.progress as f32 - top_route.progression as f32) / top_route.get_base_progression() as f32; + if 0.0 < arg && arg < 1.2 { content.push("\"basicSynth2\"".to_string()); } + if 1.2 <= arg && arg < 1.8 { content.push("\"carefulSynthesis\"".to_string()); } + if 1.8 <= arg && arg < 2.0 { + content.push("\"observe\"".to_string()); + content.push("\"focusedSynthesis\"".to_string()); + } + println!("Quality: {}/{}", top_route.quality, top_route.recipe.quality); + println!("\t[{}]", content.join(", ")); + // wait for enter + println!(); + println!("Press enter to exit..."); + let mut input = String::new(); + std::io::stdin().read_line(&mut input).unwrap(); + () +} diff --git a/src/solver.rs b/src/solver.rs new file mode 100644 index 0000000..8388134 --- /dev/null +++ b/src/solver.rs @@ -0,0 +1,147 @@ +use std::collections::VecDeque; +use std::ops::Not; +use crate::action::{Action, ACTIONS}; +use crate::craft::Craft; +use crate::specs::Success; + +macro_rules! action_vec { + ($($tt:expr),*) => { vec![ $(Some(&$tt),)*]}; +} +pub fn next_action_picker_1<'a>(craft: &Craft) -> Vec> { + if craft.success != Success::Pending { return vec![None]; } + let mut available_actions = Vec::>::new(); + let mut forbidden_actions = Vec::>::new(); + if craft.step_count == 0 { return action_vec![ACTIONS.muscle_memory]; } + if craft.step_count == 1 { return action_vec![ACTIONS.manipulation]; } + if craft.step_count == 2 { return action_vec![ACTIONS.veneration]; } + if craft.step_count == 3 { available_actions.append(&mut action_vec![ACTIONS.waste_not_ii/*,ACTIONS.waste_not*/]) } + if craft.buffs.waste_not > 0 || craft.buffs.muscle_memory > 0 { available_actions.append(&mut action_vec![ACTIONS.groundwork]) } + if craft.buffs.muscle_memory > 0 { forbidden_actions.append(&mut action_vec![ACTIONS.basic_synthesis,ACTIONS.careful_synthesis,ACTIONS.prudent_synthesis,ACTIONS.delicate_synthesis]) } + if craft.buffs.waste_not > 0 { forbidden_actions.append(&mut action_vec![ACTIONS.prudent_synthesis]) } + available_actions.append(&mut action_vec![ACTIONS.basic_synthesis,ACTIONS.careful_synthesis,ACTIONS.prudent_synthesis,ACTIONS.delicate_synthesis]); + let mut result_actions = Vec::>::new(); + for action in available_actions { + if !forbidden_actions.contains(&action) && action.unwrap().can_use(craft) && result_actions.iter().any(|x| x.unwrap() == action.unwrap()).not() { + result_actions.push(action); + } + } + result_actions +} + +pub fn generate_routes_phase1(craft: Craft) -> Vec { + let mut queue = Vec::new(); + queue.push(craft); + let mut routes = Vec::new(); + while !queue.is_empty() { + let craft = queue.pop().unwrap(); + for action in next_action_picker_1(&craft) { + let mut craft = craft.clone(); + craft.run_action(action.unwrap()); + let remaining_prog = (craft.recipe.progress as f32 - craft.progression as f32) / craft.get_base_progression() as f32; + if remaining_prog <= 2.0 { + if remaining_prog <= 0.0 { + continue; + } else if 0.0 < remaining_prog && remaining_prog <= 1.2 { + // pass + } else if 1.2 < remaining_prog && remaining_prog <= 1.2 { + craft.cp -= 7; + } else if 1.2 < remaining_prog && remaining_prog <= 2.0 { + craft.cp -= 12; + } + craft.durability -= 10; + routes.push(craft); + continue; + } + + if craft.step_count < 8 { queue.push(craft); } + } + } + routes +} + + +pub fn next_action_phase_2<'a>(craft: &Craft) -> Vec> { + let mut available_actions = vec![&ACTIONS.basic_touch, &ACTIONS.prudent_touch, &ACTIONS.preparatory_touch]; + let mut forbidden_actions = Vec::new(); + if craft.success != Success::Pending { return vec![None]; } + if craft.buffs.innovation > 0 { + forbidden_actions.push(&ACTIONS.innovation); + } else { + if craft.buffs.inner_quiet >= 2 { + forbidden_actions.append(&mut vec![&ACTIONS.basic_touch, + &ACTIONS.standard_touch, + &ACTIONS.advanced_touch, + &ACTIONS.trained_finesse, + &ACTIONS.prudent_touch, + &ACTIONS.preparatory_touch, + &ACTIONS.byregot_blessing]); + } + available_actions.push(&ACTIONS.innovation); + } + if craft.buffs.manipulation == 0 && craft.buffs.basic_touch == 0 && craft.buffs.standard_touch == 0 && craft.buffs.inner_quiet < 8 { + available_actions.push(&ACTIONS.manipulation); + } + if craft.buffs.waste_not > 0 { + available_actions.push(&ACTIONS.preparatory_touch); + forbidden_actions.push(&ACTIONS.prudent_touch); + } else { + available_actions.push(&ACTIONS.prudent_touch); + forbidden_actions.push(&ACTIONS.preparatory_touch); + } + if craft.buffs.basic_touch > 0 { + available_actions.push(&ACTIONS.standard_touch); + forbidden_actions.push(&ACTIONS.basic_touch); + } + if craft.buffs.standard_touch > 0 { + available_actions.push(&ACTIONS.advanced_touch); + forbidden_actions.push(&ACTIONS.basic_touch); + } + if craft.buffs.inner_quiet >= 10 { + available_actions.push(&ACTIONS.trained_finesse); + available_actions.push(&ACTIONS.great_strides); + } + if craft.buffs.great_strides > 0 { + forbidden_actions.push(&ACTIONS.trained_finesse); + forbidden_actions.push(&ACTIONS.great_strides); + if craft.buffs.innovation > 0 { + available_actions.push(&ACTIONS.byregot_blessing); + } + } + let mut final_actions: Vec> = Vec::new(); + //drop duplicates + + for action in available_actions { + if !forbidden_actions.contains(&action) && !final_actions.iter().any(|a| a.unwrap() == action) { + final_actions.push(Some(action)); + } + } + final_actions +} + +pub fn generate_routes_phase2(craft: Craft) -> Option { + let mut queue = VecDeque::new(); + queue.push_back(craft); + let mut top_route: Option = None; + while !queue.is_empty() { + let _craft = queue.pop_front().unwrap(); + for action in next_action_phase_2(&_craft) { + if _craft.success != Success::Pending || action.is_none() || !action.unwrap().can_use(&_craft) { + continue; + } + let mut craft = _craft.clone(); + craft.run_action(action.unwrap()); + if action.unwrap() == &ACTIONS.byregot_blessing { + if let Some(top_route) = &mut top_route { + if top_route.quality < craft.quality { + *top_route = craft; + } + } else { + top_route = Some(craft); + } + } else { + queue.push_back(craft); + } + } + } + top_route +} \ No newline at end of file diff --git a/src/specs.rs b/src/specs.rs new file mode 100644 index 0000000..71a53ad --- /dev/null +++ b/src/specs.rs @@ -0,0 +1,118 @@ +use std::fmt::{Debug}; +use strum_macros::EnumIter; + +#[derive(Debug, Clone, Copy)] +pub struct Recipe { + pub durability: u32, + pub progress: u32, + pub quality: u32, + pub progress_divider: u32, + pub quality_divider: u32, + pub progress_modifier: u32, + pub quality_modifier: u32, +} + + +#[derive(Debug, Clone, Copy)] +pub struct Stats { + pub craftsmanship: u32, + pub control: u32, + pub max_cp: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, EnumIter)] +pub enum Buff { + InnerQuiet, + WasteNot, + GreatStrides, + Innovation, + Veneration, + Manipulation, + MuscleMemory, + // v Hidden v + BasicTouch, + StandardTouch, + // Observe, +} + +#[derive(Debug, Clone, Copy)] +pub struct BuffState { + pub inner_quiet: u8, + pub waste_not: u8, + pub great_strides: u8, + pub innovation: u8, + pub veneration: u8, + pub manipulation: u8, + pub muscle_memory: u8, + pub basic_touch: u8, + pub standard_touch: u8, +} + +impl BuffState { + pub fn default() -> Self { + Self { + inner_quiet: 0, + waste_not: 0, + great_strides: 0, + innovation: 0, + veneration: 0, + manipulation: 0, + muscle_memory: 0, + basic_touch: 0, + standard_touch: 0, + } + } + + pub fn remove(&mut self, buff: Buff) { + match buff { + Buff::InnerQuiet => self.inner_quiet = 0, + Buff::WasteNot => self.waste_not = 0, + Buff::GreatStrides => self.great_strides = 0, + Buff::Innovation => self.innovation = 0, + Buff::Veneration => self.veneration = 0, + Buff::Manipulation => self.manipulation = 0, + Buff::MuscleMemory => self.muscle_memory = 0, + Buff::BasicTouch => self.basic_touch = 0, + Buff::StandardTouch => self.standard_touch = 0, + } + } + + pub fn apply(&mut self, buff: Buff, value: u8) { + match buff { + Buff::InnerQuiet => { + if value == 0 { + self.inner_quiet = 0; + } else { + self.inner_quiet += value; + } + } + Buff::WasteNot => self.waste_not = value, + Buff::GreatStrides => self.great_strides = value, + Buff::Innovation => self.innovation = value, + Buff::Veneration => self.veneration = value, + Buff::Manipulation => self.manipulation = value, + Buff::MuscleMemory => self.muscle_memory = value, + Buff::BasicTouch => self.basic_touch = value, + Buff::StandardTouch => self.standard_touch = value, + } + } + + pub fn tick(&mut self) { + + if self.waste_not > 0 { self.waste_not -= 1; } + if self.great_strides > 0 { self.great_strides -= 1; } + if self.innovation > 0 { self.innovation -= 1; } + if self.veneration > 0 { self.veneration -= 1; } + if self.manipulation > 0 { self.manipulation -= 1; } + if self.muscle_memory > 0 { self.muscle_memory -= 1; } + if self.basic_touch > 0 { self.basic_touch -= 1; } + if self.standard_touch > 0 { self.standard_touch -= 1; } + } +} + +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Success { + Pending, + Success, + Failure, +}