Add Cancel button

assets/locales/app.yaml

@@ -34,6 +34,8 @@ stats_window:
 label:
   none:
     en: None
+  cancel:
+    en: Cancel
   clear:
     en: Clear
   select:

raphael-cli/src/commands/solve.rs

@@ -1,7 +1,7 @@
 use clap::Args;
 use game_data::{get_game_settings, CrafterStats, MEALS, POTIONS, RECIPES};
 use simulator::SimulationState;
-use solvers::MacroSolver;
+use solvers::{AtomicFlag, MacroSolver};
 
 #[derive(Args, Debug)]
 pub struct SolveArgs {
@@ -258,6 +258,7 @@ pub fn execute(args: &SolveArgs) {
         args.unsound,
         Box::new(|_| {}),
         Box::new(|_| {}),
+        AtomicFlag::new(),
     );
     let actions = solver.solve(state).expect("Failed to solve");
 

solvers/examples/macro_solver_example.rs

@@ -1,5 +1,5 @@
 use simulator::{Action, ActionMask, Settings, SimulationState};
-use solvers::MacroSolver;
+use solvers::{AtomicFlag, MacroSolver};
 
 fn main() {
     #[cfg(feature = "env_logger")]
@@ -32,9 +32,16 @@ fn main() {
     };
 
     let state = SimulationState::new(&settings);
-    let actions = MacroSolver::new(settings, false, false, Box::new(|_| {}), Box::new(|_| {}))
-        .solve(state)
-        .unwrap();
+    let actions = MacroSolver::new(
+        settings,
+        false,
+        false,
+        Box::new(|_| {}),
+        Box::new(|_| {}),
+        AtomicFlag::new(),
+    )
+    .solve(state)
+    .unwrap();
 
     let quality = SimulationState::from_macro(&settings, &actions)
         .unwrap()

solvers/src/lib.rs

@@ -1,6 +1,5 @@
 mod actions;
 mod branch_pruning;
-mod utils;
 
 mod finish_solver;
 use finish_solver::FinishSolver;
@@ -14,8 +13,11 @@ use step_lower_bound_solver::StepLowerBoundSolver;
 mod macro_solver;
 pub use macro_solver::MacroSolver;
 
+mod utils;
+pub use utils::AtomicFlag;
+
 pub mod test_utils {
-    use crate::MacroSolver;
+    use crate::{utils::AtomicFlag, MacroSolver};
     use simulator::*;
 
     pub fn solve(
@@ -29,6 +31,7 @@ pub mod test_utils {
             unsound_branch_pruning,
             Box::new(|_| {}),
             Box::new(|_| {}),
+            AtomicFlag::new(),
         )
         .solve(SimulationState::new(settings))
     }

solvers/src/macro_solver/fast_lower_bound.rs

@@ -20,7 +20,7 @@ pub fn fast_lower_bound(
     settings: &Settings,
     finish_solver: &mut FinishSolver,
     upper_bound_solver: &mut QualityUpperBoundSolver,
-) -> u16 {
+) -> Option<u16> {
     let _timer = NamedTimer::new("Fast lower bound");
     let allowed_actions = settings.allowed_actions.intersection(SEARCH_ACTIONS);
 
@@ -29,7 +29,7 @@ pub fn fast_lower_bound(
 
     let mut quality_lower_bound = 0;
 
-    search_queue.push(upper_bound_solver.quality_upper_bound(state), state);
+    search_queue.push(upper_bound_solver.quality_upper_bound(state)?, state);
 
     while let Some((score, state)) = search_queue.pop() {
         if score <= quality_lower_bound {
@@ -48,7 +48,7 @@ pub fn fast_lower_bound(
                     if action == Action::ByregotsBlessing {
                         continue;
                     }
-                    let quality_upper_bound = upper_bound_solver.quality_upper_bound(state);
+                    let quality_upper_bound = upper_bound_solver.quality_upper_bound(state)?;
                     if quality_upper_bound <= quality_lower_bound {
                         continue;
                     }
@@ -62,7 +62,7 @@ pub fn fast_lower_bound(
     }
 
     log::debug!("Fast quality lower bound: {}", quality_lower_bound);
-    std::cmp::min(settings.max_quality, quality_lower_bound)
+    Some(std::cmp::min(settings.max_quality, quality_lower_bound))
 }
 
 fn should_use_action(action: Action, state: &SimulationState, allowed_actions: ActionMask) -> bool {

solvers/src/macro_solver/solver.rs

@@ -1,11 +1,14 @@
 use simulator::{Action, ActionMask, Condition, Settings, SimulationState};
 
 use super::search_queue::SearchScore;
-use crate::actions::{DURABILITY_ACTIONS, PROGRESS_ACTIONS, QUALITY_ACTIONS};
 use crate::branch_pruning::{is_progress_only_state, strip_quality_effects};
 use crate::macro_solver::fast_lower_bound::fast_lower_bound;
 use crate::macro_solver::search_queue::SearchQueue;
 use crate::utils::NamedTimer;
+use crate::{
+    actions::{DURABILITY_ACTIONS, PROGRESS_ACTIONS, QUALITY_ACTIONS},
+    utils::AtomicFlag,
+};
 use crate::{FinishSolver, QualityUpperBoundSolver, StepLowerBoundSolver};
 
 use std::vec::Vec;
@@ -36,6 +39,7 @@ pub struct MacroSolver<'a> {
     step_lower_bound_solver: StepLowerBoundSolver,
     solution_callback: Box<SolutionCallback<'a>>,
     progress_callback: Box<ProgressCallback<'a>>,
+    flag: AtomicFlag,
 }
 
 impl<'a> MacroSolver<'a> {
@@ -45,6 +49,7 @@ impl<'a> MacroSolver<'a> {
         unsound_branch_pruning: bool,
         solution_callback: Box<SolutionCallback<'a>>,
         progress_callback: Box<ProgressCallback<'a>>,
+        flag: AtomicFlag,
     ) -> MacroSolver<'a> {
         MacroSolver {
             settings,
@@ -55,14 +60,17 @@ impl<'a> MacroSolver<'a> {
                 settings,
                 backload_progress,
                 unsound_branch_pruning,
+                flag.clone(),
             ),
             step_lower_bound_solver: StepLowerBoundSolver::new(
                 settings,
                 backload_progress,
                 unsound_branch_pruning,
+                flag.clone(),
             ),
             solution_callback,
             progress_callback,
+            flag,
         }
     }
 
@@ -80,11 +88,15 @@ impl<'a> MacroSolver<'a> {
     }
 
     fn do_solve(&mut self, state: SimulationState) -> Option<Vec<Action>> {
+        if self.flag.is_set() {
+            return None;
+        }
+
         let mut search_queue = {
             let _timer = NamedTimer::new("Initial upper bound");
-            let quality_upper_bound = self.quality_upper_bound_solver.quality_upper_bound(state);
+            let quality_upper_bound = self.quality_upper_bound_solver.quality_upper_bound(state)?;
             let step_lower_bound = if quality_upper_bound >= self.settings.max_quality {
-                self.step_lower_bound_solver.step_lower_bound(state)
+                self.step_lower_bound_solver.step_lower_bound(state)?
             } else {
                 1 // quality dominates the search score, so no need to query the step solver
             };
@@ -94,7 +106,7 @@ impl<'a> MacroSolver<'a> {
                 &self.settings,
                 &mut self.finish_solver,
                 &mut self.quality_upper_bound_solver,
-            );
+            )?;
             let minimum_score = SearchScore::new(quality_lower_bound, u8::MAX, u8::MAX);
             SearchQueue::new(state, initial_score, minimum_score)
         };
@@ -103,6 +115,10 @@ impl<'a> MacroSolver<'a> {
 
         let mut popped = 0;
         while let Some((state, score, backtrack_id)) = search_queue.pop() {
+            if self.flag.is_set() {
+                return None;
+            }
+
             popped += 1;
             if popped % (1 << 14) == 0 {
                 (self.progress_callback)(popped);
@@ -136,14 +152,14 @@ impl<'a> MacroSolver<'a> {
                         } else {
                             std::cmp::min(
                                 score.quality,
-                                self.quality_upper_bound_solver.quality_upper_bound(state),
+                                self.quality_upper_bound_solver.quality_upper_bound(state)?,
                             )
                         };
 
                         let step_lb_hint = score.steps.saturating_sub(current_steps + 1);
                         let step_lower_bound = if quality_upper_bound >= self.settings.max_quality {
                             self.step_lower_bound_solver
-                                .step_lower_bound_with_hint(state, step_lb_hint)
+                                .step_lower_bound_with_hint(state, step_lb_hint)?
                                 .saturating_add(current_steps + 1)
                         } else {
                             current_steps + 1

solvers/src/quality_upper_bound_solver/solver.rs

@@ -2,7 +2,7 @@ use std::i16;
 
 use crate::{
     actions::{PROGRESS_ACTIONS, QUALITY_ACTIONS},
-    utils::{ParetoFrontBuilder, ParetoFrontId, ParetoValue},
+    utils::{AtomicFlag, ParetoFrontBuilder, ParetoFrontId, ParetoValue},
 };
 use simulator::*;
 
@@ -31,13 +31,19 @@ pub struct QualityUpperBoundSolver {
     solver_settings: SolverSettings,
     solved_states: HashMap<ReducedState, ParetoFrontId>,
     pareto_front_builder: ParetoFrontBuilder<u16, u16>,
+    flag: AtomicFlag,
     // pre-computed branch pruning values
     waste_not_1_min_cp: i16,
     waste_not_2_min_cp: i16,
 }
 
 impl QualityUpperBoundSolver {
-    pub fn new(settings: Settings, backload_progress: bool, unsound_branch_pruning: bool) -> Self {
+    pub fn new(
+        settings: Settings,
+        backload_progress: bool,
+        unsound_branch_pruning: bool,
+        flag: AtomicFlag,
+    ) -> Self {
         log::trace!(
             "ReducedState (QualityUpperBoundSolver) - size: {}, align: {}",
             std::mem::size_of::<ReducedState>(),
@@ -77,14 +83,19 @@ impl QualityUpperBoundSolver {
                 settings.max_progress,
                 settings.max_quality,
             ),
+            flag,
             waste_not_1_min_cp: waste_not_min_cp(56, 4, durability_cost),
             waste_not_2_min_cp: waste_not_min_cp(98, 8, durability_cost),
         }
     }
 
     /// Returns an upper-bound on the maximum Quality achievable from this state while also maxing out Progress.
     /// There is no guarantee on the tightness of the upper-bound.
-    pub fn quality_upper_bound(&mut self, state: SimulationState) -> u16 {
+    pub fn quality_upper_bound(&mut self, state: SimulationState) -> Option<u16> {
+        if self.flag.is_set() {
+            return None;
+        }
+
         let current_quality = state.quality;
         let missing_progress = self
             .simulator_settings
@@ -108,10 +119,10 @@ impl QualityUpperBoundSolver {
         match pareto_front.last() {
             Some(element) => {
                 if element.first < missing_progress {
-                    return 0;
+                    return Some(0);
                 }
             }
-            None => return 0,
+            None => return Some(0),
         }
 
         let index = match pareto_front.binary_search_by_key(&missing_progress, |value| value.first)
@@ -120,13 +131,17 @@ impl QualityUpperBoundSolver {
             Err(i) => i,
         };
 
-        std::cmp::min(
+        Some(std::cmp::min(
             self.simulator_settings.max_quality,
             pareto_front[index].second.saturating_add(current_quality),
-        )
+        ))
     }
 
     fn solve_state(&mut self, state: ReducedState) {
+        if self.flag.is_set() {
+            return;
+        }
+
         if state.data.combo() == Combo::None {
             self.solve_normal_state(state);
         } else {
@@ -180,6 +195,10 @@ impl QualityUpperBoundSolver {
     }
 
     fn build_child_front(&mut self, state: ReducedState, action: Action) {
+        if self.flag.is_set() {
+            return;
+        }
+
         if let Ok((new_state, action_progress, action_quality)) =
             state.use_action(action, &self.simulator_settings, &self.solver_settings)
         {
@@ -245,7 +264,9 @@ mod tests {
 
     fn solve(settings: Settings, actions: &[Action]) -> u16 {
         let state = SimulationState::from_macro(&settings, actions).unwrap();
-        QualityUpperBoundSolver::new(settings, false, false).quality_upper_bound(state)
+        QualityUpperBoundSolver::new(settings, false, false, AtomicFlag::new())
+            .quality_upper_bound(state)
+            .unwrap()
     }
 
     #[test]
@@ -721,15 +742,15 @@ mod tests {
     /// Test that the upper-bound solver is monotonic,
     /// i.e. the quality UB of a state is never less than the quality UB of any of its children.
     fn monotonic_fuzz_check(settings: Settings) {
-        let mut solver = QualityUpperBoundSolver::new(settings, false, false);
+        let mut solver = QualityUpperBoundSolver::new(settings, false, false, AtomicFlag::new());
         for _ in 0..10000 {
             let state = random_state(&settings);
-            let state_upper_bound = solver.quality_upper_bound(state);
+            let state_upper_bound = solver.quality_upper_bound(state).unwrap();
             for action in settings.allowed_actions.actions_iter() {
                 let child_upper_bound = match state.use_action(action, Condition::Normal, &settings)
                 {
                     Ok(child) => match child.is_final(&settings) {
-                        false => solver.quality_upper_bound(child),
+                        false => solver.quality_upper_bound(child).unwrap(),
                         true if child.progress >= settings.max_progress => {
                             std::cmp::min(settings.max_quality, child.quality)
                         }