diff --git a/.bumpversion.cfg b/.bumpversion.cfg
new file mode 100644
index 0000000..81a1ac1
--- /dev/null
+++ b/.bumpversion.cfg
@@ -0,0 +1,9 @@
+[bumpversion]
+current_version = 0.1.8
+tag = True
+
+[bumpversion:file:python/pyproject.toml]
+
+[bumpversion:file:Cargo.toml]
+
+[bumpversion:file:pyproject.toml]
diff --git a/.gitignore b/.gitignore
index 04a3981..d19296a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -163,3 +163,4 @@ dmypy.json
# Cython debug symbols
cython_debug/
+Cargo.lock
\ No newline at end of file
diff --git a/.ignore b/.ignore
new file mode 100644
index 0000000..91cdc0f
--- /dev/null
+++ b/.ignore
@@ -0,0 +1,2 @@
+*.ico
+*.png
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index e3e6c0e..35105e8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "xiv_csolver"
-version = "0.1.7"
+version = "0.1.8"
edition = "2021"
authors = ["谭俊健","Dandaedre","Vkyfox"]
description = "Small XIV solver library in rust, with python and rust bindings"
@@ -19,7 +19,7 @@ toml = "0.5.9"
clap = {version = "4.1.6", features = ["derive"]}
threadpool = "1.8.1"
# For python bindings TODO: make it optionnal
-pyo3 = { version = "0.18.0", features = ["extension-module"] }
+pyo3 = { version = "0.18.1", features= ["extension-module"]}
# [target.'cfg(not(no_python))'.dependencies]
# pyo3 = { version = "0.18.0", features = ["extension-module"] }
@@ -36,7 +36,8 @@ opt-level = 3
lto = true
[features]
-default = []
+extension-module = ["pyo3/extension-module"]
+default = ["extension-module"]
verbose = []
no_python = [] # Removes the python bindings
fast = [] # Remove some under optimisations that try to find other routes
@@ -48,4 +49,5 @@ crate-type = ["cdylib","rlib"]
[[bin]]
name = "xiv_csolver_cli"
-path = "src/bin/xiv_csolver.rs"
\ No newline at end of file
+path = "src/bin/xiv_csolver.rs"
+
diff --git a/Makefile.toml b/Makefile.toml
index cf4c53b..0c25cfa 100644
--- a/Makefile.toml
+++ b/Makefile.toml
@@ -18,10 +18,11 @@ script = [
"twine upload releases/xiv_csolver_lib*.whl --repository gitea",
]
-[tasks.format]
-install_crate = "rustfmt"
-command = "cargo"
-args = ["fmt", "--", "--emit=files"]
+[tasks.fmt]
+script_runner = "@shell"
+script = [
+"cargo +nightly fmt -- --config format_code_in_doc_comments=true --config imports_granularity=Module"
+]
[tasks.testcov]
script_runner = "@shell"
@@ -29,8 +30,9 @@ ignore_errors = true
script = [
"mkdir -p coverage",
"mkdir -p coverage/html",
-"CARGO_INCREMENTAL=0 RUSTFLAGS='-Cinstrument-coverage' LLVM_PROFILE_FILE='llvm/cargo-test-%p-%m.profraw' cargo test",
-"grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore '/*' -o coverage/html/"
+"mkdir -p coverage/",
+"CARGO_INCREMENTAL=0 RUSTFLAGS='-Cinstrument-coverage -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off' LLVM_PROFILE_FILE='llvm/cargo-test-%p-%m.profraw' cargo test",
+"grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore '/*' --ignore '*xiv_csolver.rs' --ignore '*python*.rs' -o coverage/html/",
]
[tasks.clean]
diff --git a/README.md b/README.md
index fb2e1c4..0a64ce8 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ Originaly written by [RikaKagurasaka](https://github.com/RikaKagurasaka/xiv_craf
it now is widely improved and provides python bindings for a GUI (or anything else really)
-
+
### Basic RUST CLI Usage
Everything is done through the regular cargo interface
diff --git a/Todo.md b/Todo.md
index 17d54e4..e4431bf 100644
--- a/Todo.md
+++ b/Todo.md
@@ -16,7 +16,15 @@
### Features
🟩 (GUI) Refactor code
🟩 (GUI) Restore GUI state
-
+ 🟩 (GUI) Bugfix the gui and clean it up
+ 🟩 (LIB) Restructure code, cleanup the mess
+ 🟩 (LIB) Have an autoretry
+ 🟩 (LIB) Have the autoretry be smart and/or threaded with interrupts
+ 🟩 (LIB) Cleanup the Toml to have one unique Food/Receipe/Craftsman with the gui
+ 🟩 (LIB) Be more aggressive with the mem optimisations
+ 🟩 (LIB) Have a thread interrupt mode for fast mode
+ 🟩 (LIB) Cleanup features (verbose doesn't really make sense)
+
# Roadmap
## v1.0.0
diff --git a/coverage/html/badges/flat.svg b/coverage/html/badges/flat.svg
index d9147e7..a43354b 100644
--- a/coverage/html/badges/flat.svg
+++ b/coverage/html/badges/flat.svg
@@ -1,6 +1,6 @@
\ No newline at end of file
diff --git a/coverage/html/badges/flat_square.svg b/coverage/html/badges/flat_square.svg
index 76037e6..7816a7a 100644
--- a/coverage/html/badges/flat_square.svg
+++ b/coverage/html/badges/flat_square.svg
@@ -1,13 +1,13 @@
\ 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 53a73bc..a58c41d 100644
--- a/coverage/html/badges/for_the_badge.svg
+++ b/coverage/html/badges/for_the_badge.svg
@@ -1,13 +1,13 @@
\ No newline at end of file
diff --git a/coverage/html/badges/plastic.svg b/coverage/html/badges/plastic.svg
index 1296731..a3720ca 100644
--- a/coverage/html/badges/plastic.svg
+++ b/coverage/html/badges/plastic.svg
@@ -1,6 +1,6 @@
\ No newline at end of file
diff --git a/coverage/html/badges/social.svg b/coverage/html/badges/social.svg
index 5dc8ab7..e26d0fc 100644
--- a/coverage/html/badges/social.svg
+++ b/coverage/html/badges/social.svg
@@ -1,6 +1,6 @@
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 5c2868e..8f57511 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,9 +5,12 @@ build-backend = "maturin"
[project] # The rust bindings
name = "xiv_csolver_lib"
requires-python = ">=3.7"
-version = "0.1.7"
+version = "0.1.8"
classifiers = [
"Programming Language :: Rust",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
-]
\ No newline at end of file
+]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
\ No newline at end of file
diff --git a/python/pyproject.toml b/python/pyproject.toml
index efed611..706bdf4 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -9,7 +9,7 @@ authors = [
{name="Dandaedre"},
]
requires-python = ">=3.7"
-version = "0.1.7"
+version = "0.1.8"
license = {text="Mozilla Public License Version 2.0"}
classifiers = [
"Programming Language :: Rust",
diff --git a/python/src/xiv_csolver/configs/recipes.yaml b/python/src/xiv_csolver/configs/recipes.yaml
index ab50162..3dbdcd4 100644
--- a/python/src/xiv_csolver/configs/recipes.yaml
+++ b/python/src/xiv_csolver/configs/recipes.yaml
@@ -4,5 +4,9 @@
# If this seems super convoluted, and you'd rather it was just the three in-game values, know that me too.
# Unfortunately that is how the craft system works in FFXIV.
-Grade 7 Tincture of Strength: [5060, 12628, 70, 130, 115, 80, 70]
-Grade 5 Strength Alkahest: [1300, 6200, 40, 123, 107, 100, 100]
+Lvl88: [1650, 7000, 40, 128, 112, 100, 100]
+Patch6.3_precrafts: [3696, 8200, 35, 130, 115, 80, 70]
+Patch6.3_gear: [5060, 12628, 70, 130, 115, 80, 70]
+Patch6.3_gatherer: [5720, 12900, 70, 130, 115, 80, 70]
+Patch6.4_precrafts: [4488, 9090, 35, 130, 115, 80, 70]
+Patch6.4_gear: [6600, 14040, 70, 130, 115, 80, 70]
\ No newline at end of file
diff --git a/python/src/xiv_csolver/configs/users.yaml b/python/src/xiv_csolver/configs/users.yaml
index 02c7a0c..9b0c4ce 100644
--- a/python/src/xiv_csolver/configs/users.yaml
+++ b/python/src/xiv_csolver/configs/users.yaml
@@ -4,6 +4,5 @@
# The top line will always be selected by default
-Vicky Crosia: [4021, 3933, 587]
-Dandaedre Zadiel: [0, 0, 0]
-Sekundes Dullahan: [2566, 2443, 522]
+Vicky Crosia: [4021, 3987, 601]
+Ladisla Kociann: [4021, 3951, 580]
\ No newline at end of file
diff --git a/python/src/xiv_csolver/example.py b/python/src/xiv_csolver/example.py
index cda7867..5148822 100644
--- a/python/src/xiv_csolver/example.py
+++ b/python/src/xiv_csolver/example.py
@@ -2,9 +2,9 @@ import xiv_csolver_lib
import rich
rich.inspect(xiv_csolver_lib)
-rich.inspect(xiv_csolver_lib.test_result)
-rich.inspect(xiv_csolver_lib.test_result())
rich.inspect(xiv_csolver_lib.test_result())
+rich.inspect(xiv_csolver_lib.test_info())
+rich.inspect(xiv_csolver_lib.test_final_results())
class FeedMeDaddy:
diff --git a/python/src/xiv_csolver/modules/printer.py b/python/src/xiv_csolver/modules/printer.py
index 0db5795..ee9cfd8 100644
--- a/python/src/xiv_csolver/modules/printer.py
+++ b/python/src/xiv_csolver/modules/printer.py
@@ -33,18 +33,18 @@ class Printer:
}
def save_users(self, user_name: str = None, user_stats: list = None) -> dict:
- output = self.help_text_dict['users'] + '\n\n'
+ output = self.help_text_dict['users'] + '\r\n\r\n'
if user_name.title() == '':
for user, stats in self.full_config.get_users_dict().items():
if user != ' ':
- output += f'{user}: [{stats[0]}, {stats[1]}, {stats[2]}]\n'
+ output += f'{user}: [{stats[0]}, {stats[1]}, {stats[2]}]\r\n'
else:
self.full_config.get_users_dict()[user_name] = user_stats
for user, stats in self.full_config.get_users_dict().items():
if user != ' ':
- output += f'{user}: [{stats[0]}, {stats[1]}, {stats[2]}]\n'
+ output += f'{user}: [{stats[0]}, {stats[1]}, {stats[2]}]\r\n'
self.print_users(output)
return self.full_config.get_users_dict()
@@ -55,18 +55,18 @@ class Printer:
return True
def save_recipe(self, recipe_name: str = None, recipe_basic_stats: list = None, recipe_advanced_stats: list = None) -> dict:
- output = self.help_text_dict['recipe'] + '\n\n'
+ output = self.help_text_dict['recipe'] + '\r\n\r\n'
if recipe_name.title() == '':
for recipe, stats in self.full_config.get_recipes_dict().items():
if recipe != ' ':
- output += f'{recipe}: [{stats[0]}, {stats[1]}, {stats[2]}, {stats[3]}, {stats[4]}, {stats[5]}, {stats[6]}]\n'
+ output += f'{recipe}: [{stats[0]}, {stats[1]}, {stats[2]}, {stats[3]}, {stats[4]}, {stats[5]}, {stats[6]}]\r\n'
else:
self.full_config.get_recipes_dict()[recipe_name] = recipe_basic_stats[:-1] + recipe_advanced_stats
for recipe, stats in self.full_config.get_recipes_dict().items():
if recipe != ' ':
- output += f'{recipe}: [{stats[0]}, {stats[1]}, {stats[2]}, {stats[3]}, {stats[4]}, {stats[5]}, {stats[6]}]\n'
+ output += f'{recipe}: [{stats[0]}, {stats[1]}, {stats[2]}, {stats[3]}, {stats[4]}, {stats[5]}, {stats[6]}]\r\n'
self.print_recipe(output)
return self.full_config.get_recipes_dict()
diff --git a/python/src/xiv_csolver/modules/solver.py b/python/src/xiv_csolver/modules/solver.py
index e10c52c..347bca6 100644
--- a/python/src/xiv_csolver/modules/solver.py
+++ b/python/src/xiv_csolver/modules/solver.py
@@ -50,7 +50,7 @@ Remaining CP: {self.remaining_cp}"""
saved_lines.append(line)
for line in saved_lines:
- justified_text += line + '\n'
+ justified_text += line + '\r\n'
return justified_text[:-1]
@@ -67,8 +67,9 @@ Remaining CP: {self.remaining_cp}"""
if self.steps != 15 and self.steps != 29 and self.steps != 44:
saved_lines.append('/echo Craft complete ! ')
- else:
- self.loggers.log(f'No completion message in macro because rotation is exactly {self.steps} steps.')
+ # else:
+ # TODO: Add a callback to the parent object for logging
+ # self.loggers.add_log(f'No completion message in macro because rotation is exactly {self.steps} steps.')
if self.steps > 15:
saved_lines.insert(14, '/echo Macro 1 complete ')
@@ -81,11 +82,11 @@ Remaining CP: {self.remaining_cp}"""
for line in saved_lines:
count += 1
if count < 16:
- self.macro1 += line + '\n'
+ self.macro1 += line + '\r\n'
elif 15 < count < 31:
- self.macro2 += line + '\n'
+ self.macro2 += line + '\r\n'
elif 30 < count < 46:
- self.macro3 += line + '\n'
+ self.macro3 += line + '\r\n'
self.macro1 = self.macro1[:-1]
self.macro2 = self.macro2[:-1]
@@ -116,6 +117,7 @@ class Solver:
self.loggers = loggers
self.solutions = []
+ self.info = None
self.best_quality = None
self.least_steps = None
self.safe_50 = None
@@ -124,7 +126,7 @@ class Solver:
self.compute_all()
def solve(self) -> str:
- self.solutions = xcs.solve_from_python(self)
+ self.solutions,self.info = xcs.solve_from_python(self)
return self.solutions
def compute_all(self) -> True:
@@ -153,7 +155,7 @@ class Solver:
break
if not done:
- self.loggers.add_log('Could not find a rotation for a 50% Safe Margin.\n'
+ self.loggers.add_log('Could not find a rotation for a 50% Safe Margin.\r\n'
' Defaulting to Best Quality.')
self.safe_50 = self.best_quality
@@ -169,5 +171,3 @@ class Solver:
self.least_steps = Result(output, 'Least steps')
return self.least_steps
-
-
diff --git a/python/src/xiv_csolver/modules/translator.py b/python/src/xiv_csolver/modules/translator.py
index 4897cf9..29c28f9 100644
--- a/python/src/xiv_csolver/modules/translator.py
+++ b/python/src/xiv_csolver/modules/translator.py
@@ -48,7 +48,7 @@ def translate_list(actions: list, lang: str):
output.append(dictionary[action])
except KeyError:
output.append(supported_languages["en"][action])
- loggers.log('Translation not found. Defaulting to English.\n'
+ loggers.log('Translation not found. Defaulting to English.\r\n'
' Macros will probably be broken because of this.')
else:
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 0000000..44148a2
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1 @@
+reorder_imports = true
diff --git a/src/action.rs b/src/action.rs
index 89f16bb..0ae718d 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -2,7 +2,6 @@
//!
//! All actions are defined as Action, containing all methods to actively use it in a craft
//! while ActionBuilder is used only initally as a lazy_static setup
-//!
use crate::craft::Craft;
use crate::specs::{Buff, Success};
@@ -45,10 +44,10 @@ impl ActionBuilder {
/// use xiv_csolver_lib::action::ActionBuilder;
/// use xiv_csolver_lib::specs::Buff;
/// ActionBuilder::new("Muscle Memory")
- /// .cp(6)
- /// .progress(300)
- /// .buff(Some((Buff::MuscleMemory, 5)))
- /// .build();
+ /// .cp(6)
+ /// .progress(300)
+ /// .buff(Some((Buff::MuscleMemory, 5)))
+ /// .build();
/// ```
pub fn new(name: &str) -> Self {
let mut short_name = name.to_string();
@@ -145,9 +144,10 @@ impl Action {
}
/// Get the durability cost this action would have if used at this stage of the craft
/// This method accounts for the effects of **master mend** and **waste not**.
- pub fn get_durability_cost(&self, _craft: &Craft) -> u32 {
+ /// Note that not using i32 for durability from scratch is a desing choice
+ pub fn get_durability_cost(&self, _craft: &Craft) -> i32 {
if self == &ACTIONS.masters_mend {
- return 30;
+ return -30;
}
if self.dur == 0 || self.progress == 0 && self.quality == 0 {
return 0;
@@ -159,7 +159,7 @@ impl Action {
if dur < 5 {
dur = 5;
}
- dur
+ dur as i32
}
/// Get the progress effect this action would have if used at this stage of the craft
/// This method accounts for the effects of **groundwork** under 20 durability,
@@ -419,6 +419,7 @@ impl Default for ActionList {
.build(),
masters_mend: ActionBuilder::new("Master's Mend").cp(88).build(),
+ //masters_mend: ActionBuilder::new("Master's Mend").dur(-30).cp(88).build(),
waste_not: ActionBuilder::new("Waste Not")
.cp(56)
.buff(Some((Buff::WasteNot, 4)))
@@ -454,3 +455,96 @@ lazy_static! {
/// Initialize a static pseudo &Craft: ACTIONS
pub static ref ACTIONS: ActionList = ActionList::default();
}
+
+#[cfg(test)]
+mod test {
+ use crate::action::ACTIONS;
+ use pretty_assertions::assert_eq;
+ use strum::IntoEnumIterator;
+ #[test]
+ pub fn test_structs() {
+ let ac = crate::action::Action {
+ name: "Michel".to_string(),
+ dur: 0,
+ cp: 0,
+ progress: 0,
+ quality: 0,
+ buff: None,
+ short_name: "miguel".to_string(),
+ };
+ let ab = crate::action::ActionBuilder { action: ac };
+ let ba = crate::action::ActionBuilder::new(&"Basic Synthesis");
+ let _ = crate::action::ActionBuilder::new(&"Groundwork");
+ let cs = crate::action::ActionBuilder::new(&"Careful Synthesis");
+ ab.dur(10)
+ .cp(10)
+ .progress(10)
+ .quality(10)
+ .buff(None)
+ .build();
+ let act1 = ba.cp(10).dur(22).progress(33).quality(44).build();
+ let act2 = cs.cp(10).dur(22).progress(33).quality(44).build();
+ assert_eq!(act1, act2);
+ format!("{:?}", act1);
+ let _ = crate::action::ActionList::default();
+ }
+
+ #[test]
+ pub fn test_with_craft() {
+ let mut bbs = crate::specs::BuffState::default();
+ for buff in crate::specs::Buff::iter() {
+ bbs.apply(buff, 2);
+ }
+ let mut act1 = crate::action::ActionBuilder::new(&"Basic Synthesis")
+ .dur(22)
+ .cp(10)
+ .progress(100)
+ .quality(100)
+ .build();
+ let mut craft = crate::craft::Craft::default();
+ craft.buffs = bbs;
+
+ assert_eq!(act1.get_name(), "Basic Synthesis");
+ assert_eq!(act1.get_cp_cost(&craft), 10);
+ assert_eq!(act1.get_durability_cost(&craft), 11);
+ assert_eq!(act1.get_progress(&craft), 250);
+ assert_eq!(act1.get_quality(&craft), 300);
+ assert_eq!(act1.get_buff(), None);
+
+ assert!(act1.can_use(&craft));
+
+ assert_eq!(&ACTIONS.standard_touch.get_cp_cost(&craft), &18);
+ assert_eq!(&ACTIONS.advanced_touch.get_cp_cost(&craft), &18);
+ assert_eq!(&ACTIONS.masters_mend.get_durability_cost(&craft), &-30);
+
+ assert_eq!(&ACTIONS.byregot_blessing.get_quality(&craft), &420);
+ assert_eq!(&ACTIONS.byregot_blessing.can_use(&craft), &true);
+ assert_eq!(&ACTIONS.muscle_memory.can_use(&craft), &true);
+ assert_eq!(&ACTIONS.trained_finesse.can_use(&craft), &false);
+ assert_eq!(&ACTIONS.reflect.can_use(&craft), &true);
+
+ act1.progress = 0;
+ act1.quality = 0;
+ assert_eq!(act1.get_durability_cost(&craft), 0);
+ act1.dur = 0;
+ act1.progress = 100;
+ act1.quality = 100;
+ assert_eq!(act1.get_durability_cost(&craft), 0);
+
+ act1.dur = 20;
+ craft.durability = 10;
+ craft.buffs = crate::specs::BuffState::default();
+ assert_eq!(act1.get_progress(&craft), 50);
+ assert_eq!(act1.get_quality(&craft), 50);
+
+ act1.dur = 2;
+ assert_eq!(act1.get_durability_cost(&craft), 5);
+
+ craft.cp = 0;
+ assert_eq!(&ACTIONS.reflect.can_use(&craft), &false);
+
+ craft.cp = 100;
+ craft.success = crate::specs::Success::Failure;
+ assert_eq!(&ACTIONS.reflect.can_use(&craft), &false);
+ }
+}
diff --git a/src/bin/xiv_csolver.rs b/src/bin/xiv_csolver.rs
index c94c690..fe884ad 100644
--- a/src/bin/xiv_csolver.rs
+++ b/src/bin/xiv_csolver.rs
@@ -30,7 +30,7 @@
//!
//! It is really recommended to set up a venv to handle the python development
//!
-//! All bindings and the explanation of how to use them can be found in the [`io`](crate::io) module.
+//! All bindings and the explanation of how to use them can be found in the [`io`](xiv_csolver_lib::io) module.
//!
//! ### Features
//!
@@ -131,26 +131,26 @@ fn main() {
Some(ref res) => {
// Show best results
if args.verbose > 0 {
- println!("[Final] {} results were found:", res.len());
+ println!("[Final] {} results were found:", res.0.len());
#[cfg(feature = "verbose")]
if args.verbose > 1 {
xiv_csolver_lib::print_routes(&results);
}
}
+ println!("\n > SOLUTION [Least steps] <");
+ xiv_csolver_lib::find_fast_route(&res)
+ .unwrap()
+ .pretty_print();
+ println!("\n > SOLUTION [Most durability] <");
+ xiv_csolver_lib::find_safe_route(&res)
+ .unwrap()
+ .pretty_print();
+ println!("\n > SOLUTION [Most quality] < ");
+ xiv_csolver_lib::find_quality_route(&res)
+ .unwrap()
+ .pretty_print();
}
}
- println!("\n > SOLUTION [Least steps] <");
- xiv_csolver_lib::find_fast_route(&results)
- .unwrap()
- .pretty_print();
- println!("\n > SOLUTION [Most durability] <");
- xiv_csolver_lib::find_safe_route(&results)
- .unwrap()
- .pretty_print();
- println!("\n > SOLUTION [Most quality] < ");
- xiv_csolver_lib::find_quality_route(&results)
- .unwrap()
- .pretty_print();
// #[cfg(feature = "verbose")]
// if params.verbose>2{
diff --git a/src/craft.rs b/src/craft.rs
index 863fa66..f5788f3 100644
--- a/src/craft.rs
+++ b/src/craft.rs
@@ -3,7 +3,6 @@
//! A craft represent the state of the recipe with a vector of actions applied to it.
//! Applying actions to it will make the craft progress, while branching and trying other actions
//! will be done by cloning
-//!
use crate::action::Action;
use crate::specs::{Buff, BuffState, Recipe, Stats, Success};
@@ -42,7 +41,6 @@ pub struct Craft<'a> {
impl<'a> Craft<'a> {
/// Create a new craft with a recipe, stats and parameters
- ///
pub fn new(recipe: Recipe, stats: Stats, params: Parameters) -> Craft<'a> {
Self {
recipe,
@@ -184,9 +182,134 @@ impl<'a> Display for Craft<'a> {
}
}
+#[cfg(test)]
+impl<'a> Craft<'a> {
+ /// Create a "Default" craft, testing only
+ pub fn default() -> Craft<'a> {
+ Self::new(
+ crate::specs::Recipe {
+ durability: 200,
+ progress: 200,
+ progress_divider: 100,
+ progress_modifier: 100,
+ quality: 100,
+ quality_divider: 100,
+ quality_modifier: 100,
+ },
+ crate::specs::Stats {
+ craftsmanship: 200,
+ control: 200,
+ max_cp: 200,
+ },
+ crate::io::Parameters {
+ threads: 10,
+ verbose: 2,
+ depth: 10,
+ desperate: false,
+ byregot_step: 10,
+ },
+ )
+ }
+
+ /// Create a "Two start" craft, testing only
+ pub fn two_star() -> Craft<'a> {
+ Self::new(
+ crate::specs::Recipe {
+ durability: 70,
+ progress: 3900,
+ quality: 10920,
+ progress_divider: 130,
+ quality_divider: 115,
+ progress_modifier: 80,
+ quality_modifier: 70,
+ },
+ crate::specs::Stats {
+ craftsmanship: 4041,
+ control: 3971,
+ max_cp: 595,
+ },
+ crate::io::Parameters {
+ threads: 8,
+ verbose: 2,
+ depth: 8,
+ desperate: false,
+ byregot_step: 10,
+ },
+ )
+ }
+
+ /// 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)]
mod test {
+ use pretty_assertions::assert_eq;
// Struct Test
#[test]
- pub fn struct_tests() {}
+ pub fn struct_tests() {
+ 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);
+ }
+
+ #[test]
+ pub fn test_craft() {
+ let mut craft = crate::craft::Craft::default();
+ craft.cp = 1000;
+ format!("{:?}", craft);
+ let mut craft2 = craft.run_action(&crate::action::ACTIONS.veneration).clone();
+
+ craft.run_action(&crate::action::ACTIONS.masters_mend);
+ craft.run_action(&crate::action::ACTIONS.masters_mend);
+ craft.run_action(&crate::action::ACTIONS.manipulation);
+ craft.run_action(&crate::action::ACTIONS.basic_touch);
+ craft.run_action(&crate::action::ACTIONS.basic_synthesis);
+ assert_eq!(craft.durability, 190);
+ craft.run_action(&crate::action::ACTIONS.masters_mend);
+ assert_eq!(craft.durability, 200);
+ craft.run_action(&crate::action::ACTIONS.masters_mend);
+ for _ in 0..10 {
+ craft.run_action(&crate::action::ACTIONS.basic_touch);
+ }
+
+ for _ in 0..3 {
+ craft.run_action(&crate::action::ACTIONS.masters_mend);
+ craft.run_action(&crate::action::ACTIONS.groundwork);
+ }
+ assert_eq!(craft.success, crate::craft::Success::Success);
+
+ for _ in 0..20 {
+ craft2.run_action(&crate::action::ACTIONS.preparatory_touch);
+ }
+ assert_eq!(craft2.durability, 0);
+ assert_eq!(craft2.success, crate::craft::Success::Failure);
+ }
}
diff --git a/src/io.rs b/src/io.rs
index 4c6e038..4c24a90 100644
--- a/src/io.rs
+++ b/src/io.rs
@@ -1,15 +1,8 @@
//! The main IO module
-//! For now it contains the python bindings, the Args bindings (for clap) and the struct
+//! For now it contains the Args bindings (for clap) and the struct
//! needed to hold all parameters needed at runtime
-//!
-//! Moving the bindings and making them non mandatory is a WIP
-use crate::Craft;
use clap::Parser;
-use core::fmt::Display;
-
-// #[cfg(not(feature = "no_python"))]
-use pyo3::prelude::*;
/// The parameters needed at runtime, used since Args cannot easily be passed to python
#[derive(Debug, Clone, Copy)]
@@ -68,149 +61,6 @@ pub struct Args {
pub long: bool,
}
-/// A final stripped down version of a craft
-/// used for final print and talking with python
-/// TODO: Half of these parameter are unique and SHOULD NOT be replicated on every solution
-#[derive(Debug)]
-#[pyclass]
-pub struct SolverResult {
- /// The number of steps this particular craft takes
- #[pyo3(get)]
- pub steps: u32,
- /// The quality obtained at the end of the craft (absolute value)
- #[pyo3(get)]
- pub quality: u32,
- /// The amount of progression obtained at the end of the craft (absolute value)
- #[pyo3(get)]
- pub progression: u32,
- /// The remaining durability at the end of this craft
- #[pyo3(get)]
- pub durability: i32,
- /// The remaining crafting points at the end of this craft
- #[pyo3(get)]
- pub cp: i32,
- /// The total amount of crafting points the crafter had available (Deprecated)
- #[pyo3(get)]
- pub total_cp: u32,
- /// The total amount of progression needed to finish the craft (Deprecated)
- #[pyo3(get)]
- pub total_progression: u32,
- /// The total quality needed to make this craft 100% HQ (Deprecated)
- #[pyo3(get)]
- pub total_quality: u32,
- /// The total durability for this craft (Deprecated)
- #[pyo3(get)]
- pub total_durability: u32,
- /// The list of actions, as a string
- #[pyo3(get)]
- pub actions: Vec,
- /// The amount of solutions found during the first step of the solving (Used for debug) (Deprecated)
- #[pyo3(get)]
- pub step1_solutions: usize,
- /// The amount of solutions found at the end of the second step of solving (Used for debug) (Deprecated)
- #[pyo3(get)]
- pub step2_solutions: usize,
- #[pyo3(get)]
- /// Wether a 100% HQ solution was found (Deprecated)
- pub found_100_percent: bool,
-}
-
-/// Pretty display for SolverResult
-impl Display for SolverResult {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
- write!(f, "{:?}", self.actions)
- }
-}
-
-impl SolverResult {
- /// Create a SolverResult from a solution
- /// Using this returns a solution, usable by Python
- pub fn from_craft(
- craft: &Craft,
- step1_solutions: usize,
- step2_solutions: usize,
- found_100_percent: bool,
- ) -> SolverResult {
- let mut actions = craft
- .actions
- .iter()
- .map(|action| format!("{}", action.short_name))
- .collect::>();
- // Todo: Stop adding these by hand
- let arg = (craft.recipe.progress as f32 - craft.progression as f32)
- / craft.get_base_progression() as f32;
- if 0.0 < arg && arg < 1.2 {
- actions.push("basicSynth2".to_string());
- }
- if 1.2 <= arg && arg < 1.8 {
- actions.push("carefulSynthesis".to_string());
- }
- if 1.8 <= arg && arg < 2.0 {
- actions.push("observe".to_string());
- actions.push("focusedSynthesis".to_string());
- }
- SolverResult {
- steps: craft.step_count,
- progression: craft.progression,
- quality: craft.quality,
- durability: craft.durability,
- actions: actions,
- step1_solutions,
- step2_solutions,
- found_100_percent,
- total_progression: craft.recipe.progress,
- total_quality: craft.recipe.quality,
- total_durability: craft.recipe.durability,
- cp: craft.cp,
- total_cp: craft.stats.max_cp,
- }
- }
-}
-
-#[pymethods]
-impl SolverResult {
- /// Default method to create an empty solution, only used for debug purposes
- /// to test wether the import worked
- /// ```py
- /// import xiv_csolver_lib
- /// print(xiv_csolver_lib.default())
- /// ```
- #[staticmethod]
- pub fn default() -> Self {
- Self {
- steps: 0,
- progression: 0,
- quality: 0,
- durability: 0,
- total_progression: 0,
- total_quality: 0,
- total_durability: 0,
- actions: vec!["Act1".to_string(), "Act2".to_string()],
- step1_solutions: 0,
- step2_solutions: 0,
- found_100_percent: false,
- cp: 0,
- total_cp: 0,
- }
- }
-
- /// Implement a pretty_print method
- /// Mainly used for debug purposes
- pub fn pretty_print(&self) {
- println!(
- "Quality: [{}/{}] | Durability: [{}/{}] | Cp : [{}/{}] | Steps : {}",
- self.quality,
- self.total_quality,
- self.durability,
- self.total_durability,
- self.cp,
- self.total_cp,
- self.steps
- );
- println!("{:?}", self.actions);
- }
-}
-
impl Parameters {
/// Create parameters from the arguments parsed by clap
pub fn from_args(args: &Args) -> Self {
@@ -224,96 +74,10 @@ impl Parameters {
}
}
-////// Python Bindings //////
-
-/// A Python module implemented in Rust.
-#[cfg(not(feature = "no_python"))]
-#[pymodule]
-fn xiv_csolver_lib(_py: Python, m: &PyModule) -> PyResult<()> {
- m.add_function(wrap_pyfunction!(test_result, m)?)?;
- m.add_function(wrap_pyfunction!(solve_from_python, m)?)?;
- Ok(())
-}
-
-///
-#[cfg(not(feature = "no_python"))]
-#[pyfunction]
-pub fn test_result() -> SolverResult {
- SolverResult::default()
-}
-
-/// Create a stat struct stats with the base values
-#[cfg(not(feature = "no_python"))]
-use crate::{solve_craft, Recipe, Stats};
-
-/// Solve a craft from parameters given by python
-/// The values are all obtained by a `&PyAny`, wich must guaranty that several attributes are
-/// accesible by `__getattr__`
-///
-/// ```python
-/// import xiv_craft_solver, rich
-///
-/// class FeedingClass:
-/// durability = 70
-/// progress = 3900
-/// quality = 10920
-/// progress_divider = 130
-/// quality_divider = 115
-/// progress_modifier = 80
-/// quality_modifier = 70
-/// craftsmanship = 4041
-/// control = 3959
-/// max_cp = 602
-/// # Config
-/// depth = 10
-/// byregot_step = 10
-/// desperate = False
-/// threads = 8
-/// verbose = 0
-/// crafting_feeder = FeedingClass()
-/// rich.inspect(xiv_csolver_lib.solve_from_python(crafting_feeder))
-/// ```
-#[cfg(not(feature = "no_python"))]
-#[pyfunction]
-pub fn solve_from_python(py: Python<'_>, values: &PyAny) -> PyResult