refactor: refactor some code

src/main.rs

@@ -122,7 +122,10 @@ fn main() {
 
     app.add_systems(
         OnEnter(AppState::AutoSolve),
-        (spawn_lowerbound_marks, clear_action_state),
+        (
+            (setup_solver, spawn_lowerbound_marks).chain(),
+            clear_action_state,
+        ),
     )
     .add_systems(Update, update_solver.run_if(in_state(AppState::AutoSolve)))
     .add_systems(OnExit(AppState::AutoSolve), despawn_lowerbound_marks)

src/resources.rs

@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use bevy::time::Stopwatch;
 use nalgebra::Vector2;
 use serde::{Deserialize, Serialize};
 
@@ -72,14 +73,14 @@ impl Default for AutoCratePushState {
 #[derive(Resource)]
 pub struct SolverState {
     pub solver: Mutex<Solver>,
-    pub timer: std::time::Instant,
+    pub stopwatch: Stopwatch,
 }
 
 impl Default for SolverState {
     fn default() -> Self {
         Self {
             solver: Mutex::new(Solver::new(Level::empty())),
-            timer: std::time::Instant::now(),
+            stopwatch: Stopwatch::new(),
         }
     }
 }

src/systems/input.rs

@@ -310,25 +310,12 @@ pub fn handle_viewport_zoom_action(
 
 pub fn handle_automatic_solution_action(
     action_state: Res<ActionState<Action>>,
-    mut solver_state: ResMut<SolverState>,
-    board: Query<&Board>,
-    settings: Res<Settings>,
-
     state: Res<State<AppState>>,
     mut next_state: ResMut<NextState<AppState>>,
 ) {
     if action_state.just_pressed(Action::AutomaticSolution) {
-        let board = &board.single().board;
-
-        let SolverState { solver, timer } = &mut *solver_state;
-
         if *state == AppState::Main {
-            let mut solver = solver.lock().unwrap();
-            *solver = Solver::new(board.level.clone());
-            solver.initial(settings.solver.strategy, settings.solver.lower_bound_method);
-
             next_state.set(AppState::AutoSolve);
-            *timer = std::time::Instant::now();
         } else {
             next_state.set(AppState::Main);
         }

src/systems/render.rs

@@ -1,6 +1,5 @@
 use bevy::prelude::*;
 use bevy::winit::WinitWindows;
-use itertools::Itertools;
 
 use crate::components::*;
 use crate::events::*;

src/systems/solver.rs

@@ -48,6 +48,19 @@ pub fn despawn_lowerbound_marks(
     marks.for_each(|entity| commands.entity(entity).despawn());
 }
 
+pub fn setup_solver(
+    mut solver_state: ResMut<SolverState>,
+    board: Query<&Board>,
+    settings: Res<Settings>,
+) {
+    let board = &board.single().board;
+    let SolverState { solver, stopwatch } = &mut *solver_state;
+    let mut solver = solver.lock().unwrap();
+    *solver = Solver::new(board.level.clone());
+    solver.initial(settings.solver.strategy, settings.solver.lower_bound_method);
+    stopwatch.reset();
+}
+
 pub fn update_solver(
     mut solver_state: ResMut<SolverState>,
     mut board: Query<&mut Board>,
@@ -56,10 +69,11 @@ pub fn update_solver(
     mut next_state: ResMut<NextState<AppState>>,
 ) {
     let board = &mut board.single_mut().board;
-    let SolverState { solver, timer } = &mut *solver_state;
+    let SolverState { solver, stopwatch } = &mut *solver_state;
 
     let mut solver = solver.lock().unwrap();
-    let timeout = std::time::Duration::from_millis(100);
+    let timeout = std::time::Duration::from_millis(50);
+    let timer = std::time::Instant::now();
     match solver.solve(timeout) {
         Ok(solution) => {
             let mut verify_board = board.clone();
@@ -68,9 +82,10 @@ pub fn update_solver(
             }
             assert!(verify_board.is_solved());
 
+            stopwatch.tick(timer.elapsed());
             info!(
                 "Solver: Solved ({} sec)",
-                timer.elapsed().as_millis() as f32 / 1000.0
+                stopwatch.elapsed().as_millis() as f32 / 1000.0
             );
             info!(
                 "    Moves: {}, pushes: {}",
@@ -85,12 +100,15 @@ pub fn update_solver(
             next_state.set(AppState::Main);
         }
         Err(SolveError::NoSolution) => {
+            stopwatch.tick(timer.elapsed());
             info!(
                 "Solver: No solution ({} sec)",
-                timer.elapsed().as_millis() as f32 / 1000.0
+                stopwatch.elapsed().as_millis() as f32 / 1000.0
             );
             next_state.set(AppState::Main);
         }
-        Err(SolveError::Timeout) => (),
+        Err(SolveError::Timeout) => {
+            let _ = stopwatch.tick(timer.elapsed());
+        }
     }
 }