This commit is contained in:
Rika 2022-09-17 19:18:52 +08:00
commit e97c4ee400
12 changed files with 795 additions and 0 deletions

3
.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
/target
/.idea
*.iml

103
Cargo.lock generated Normal file
View File

@ -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",
]

12
Cargo.toml Normal file
View File

@ -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"

45
README.md Normal file
View File

@ -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)

13
craft.toml Normal file
View File

@ -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

BIN
img.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 9.7 KiB

BIN
img_1.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.1 KiB

214
src/action.rs Normal file
View File

@ -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();
}

81
src/craft.rs Normal file
View File

@ -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()
}
}

59
src/main.rs Normal file
View File

@ -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::<Vec<String>>();
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();
()
}

147
src/solver.rs Normal file
View File

@ -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<Option<&'a Action>> {
if craft.success != Success::Pending { return vec![None]; }
let mut available_actions = Vec::<Option<&'a Action>>::new();
let mut forbidden_actions = Vec::<Option<&'a Action>>::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::<Option<&'a Action>>::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<Craft> {
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<Option<&'a Action>> {
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<Option<&Action>> = 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<Craft> {
let mut queue = VecDeque::new();
queue.push_back(craft);
let mut top_route: Option<Craft> = 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
}

118
src/specs.rs Normal file
View File

@ -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,
}