Merge pull request #67 from AlexKnauth/log-setup

Print setup logs before game is open
AlexKnauth · Apr 19, 2024 · 440c6d6 · 440c6d6
2 parents 142c90b + 9ffcf15
commit 440c6d6
Show file tree

Hide file tree

Showing 3 changed files with 45 additions and 30 deletions.
diff --git a/src/hollow_knight_memory.rs b/src/hollow_knight_memory.rs
@@ -5,12 +5,11 @@ use std::cmp::min;
 use std::mem;
 use std::collections::BTreeMap;
 use asr::file_format::{elf, pe};
-use asr::future::{next_tick, retry};
+use asr::future::next_tick;
 use asr::watcher::Pair;
 use asr::{Address, PointerSize, Process};
 use asr::game_engine::unity::mono::{self, Image, Module, UnityPointer};
 use asr::string::ArrayWString;
-use ugly_widget::store::StoreGui;
 
 #[cfg(debug_assertions)]
 use std::string::String;
@@ -3458,11 +3457,8 @@ impl SceneDataStore {
 
 // --------------------------------------------------------
 
-pub async fn wait_attach_hollow_knight<G: StoreGui>(gui: &mut G) -> Process {
-    retry(|| {
-        gui.loop_load_update_store();
-        HOLLOW_KNIGHT_NAMES.into_iter().find_map(Process::attach)
-    }).await
+pub fn attach_hollow_knight() -> Option<Process> {
+    HOLLOW_KNIGHT_NAMES.into_iter().find_map(Process::attach)
 }
 
 fn process_pointer_size(process: &Process) -> Option<PointerSize> {

diff --git a/src/lib.rs b/src/lib.rs
@@ -9,12 +9,13 @@ mod legacy_xml;
 mod settings_gui;
 mod splits;
 
-use asr::{future::next_tick, Process};
+use asr::future::{next_tick, retry};
+use asr::Process;
 use asr::time::Duration;
 use asr::timer::TimerState;
 use settings_gui::{SettingsGui, TimingMethod};
 use hollow_knight_memory::*;
-use splits::SplitterAction;
+use splits::{Split, SplitterAction};
 use ugly_widget::store::StoreGui;
 
 asr::async_main!(stable);
@@ -34,19 +35,19 @@ async fn main() {
     let mut gui = Box::new(SettingsGui::wait_load_merge_register().await);
 
     let mut ticks_since_gui = 0;
+    let mut timing_method = gui.get_timing_method();
     let mut splits = gui.get_splits();
+    asr::print_message(&format!("timing_method: {:?}", timing_method));
     asr::print_message(&format!("splits: {:?}", splits));
 
-    let mut auto_reset: &'static [TimerState] = splits::auto_reset_safe(&splits);
-
     loop {
-        let process = wait_attach_hollow_knight(&mut *gui).await;
+        let process = wait_attach_hollow_knight(&mut *gui, &mut timing_method, &mut splits).await;
         process
             .until_closes(async {
                 // TODO: Load some initial information from the process.
                 let mut scene_store = Box::new(SceneStore::new());
-                let mut timing_method = gui.get_timing_method();
                 let mut load_remover = Box::new(TimingMethodLoadRemover::new(timing_method));
+                let mut auto_reset: &'static [TimerState] = splits::auto_reset_safe(&splits);
 
                 next_tick().await;
                 let game_manager_finder = Box::new(GameManagerFinder::wait_attach(&process).await);
@@ -56,13 +57,6 @@ async fn main() {
                 #[cfg(debug_assertions)]
                 asr::print_message(&format!("geo: {:?}", game_manager_finder.get_geo(&process)));
 
-                let gui_splits = gui.get_splits();
-                if gui_splits != splits {
-                    splits = gui_splits;
-                    asr::print_message(&format!("splits: {:?}", splits));
-                    auto_reset = splits::auto_reset_safe(&splits);
-                }
-
                 #[cfg(debug_assertions)]
                 let mut scenes_grub_rescued = game_manager_finder.scenes_grub_rescued(&process);
                 #[cfg(debug_assertions)]
@@ -86,18 +80,12 @@ async fn main() {
                     ticks_since_gui += 1;
                     if TICKS_PER_GUI <= ticks_since_gui && gui.load_update_store_if_unchanged() {
                         if i == 0 && [TimerState::NotRunning, TimerState::Ended].contains(&asr::timer::state()) {
-                            let new_timing_method = gui.get_timing_method();
-                            if new_timing_method != timing_method {
-                                timing_method = new_timing_method;
-                                *load_remover = TimingMethodLoadRemover::new(timing_method);
-                                asr::print_message(&format!("timing_method: {:?}", timing_method));
+                            if let Some(new_timing_method) = gui.check_timing_method(&mut timing_method) {
+                                *load_remover = TimingMethodLoadRemover::new(new_timing_method);
                             }
                         }
-                        let gui_splits = gui.get_splits();
-                        if gui_splits != splits {
-                            splits = gui_splits;
-                            asr::print_message(&format!("splits: {:?}", splits));
-                            auto_reset = splits::auto_reset_safe(&splits);
+                        if let Some(new_splits) = gui.check_splits(&mut splits) {
+                            auto_reset = splits::auto_reset_safe(new_splits);
                         }
                         ticks_since_gui = 0;
                     }
@@ -109,6 +97,15 @@ async fn main() {
     }
 }
 
+async fn wait_attach_hollow_knight(gui: &mut SettingsGui, timing_method: &mut TimingMethod, splits: &mut Vec<Split>) -> Process {
+    retry(|| {
+        gui.loop_load_update_store();
+        gui.check_timing_method(timing_method);
+        gui.check_splits(splits);
+        attach_hollow_knight()
+    }).await
+}
+
 async fn tick_action(
     process: &Process,
     splits: &[splits::Split],

diff --git a/src/settings_gui.rs b/src/settings_gui.rs
@@ -65,6 +65,28 @@ impl SettingsGui {
         gui.loop_load_update_store();
         gui
     }
+
+    pub fn check_timing_method(&self, timing_method: &mut TimingMethod) -> Option<TimingMethod> {
+        let new_timing_method = self.get_timing_method();
+        if new_timing_method != *timing_method {
+            *timing_method = new_timing_method;
+            asr::print_message(&format!("timing_method: {:?}", timing_method));
+            Some(new_timing_method)
+        } else {
+            None
+        }
+    }
+
+    pub fn check_splits<'a>(&self, splits: &'a mut Vec<Split>) -> Option<&'a [Split]> {
+        let new_splits = self.get_splits();
+        if new_splits != *splits {
+            *splits = new_splits;
+            asr::print_message(&format!("splits: {:?}", splits));
+            Some(splits)
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, Eq, Gui, Ord, PartialEq, PartialOrd, RadioButtonOptions, Serialize)]