commit e97c4ee400cf941a51c565540a995ce05c8b3c3c Author: Rika Date: Sat Sep 17 19:18:52 2022 +0800 readme 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 0000000..51412a6 Binary files /dev/null and b/img.png differ diff --git a/img_1.png b/img_1.png new file mode 100644 index 0000000..5a38930 Binary files /dev/null and b/img_1.png differ 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, +}