better process finder

Author: Paloys

.github/workflows/rust.yml

@@ -15,6 +15,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: taiki-e/create-gh-release-action@v1
         with:
+          changelog: CHANGELOG.md
           # (required) GitHub token for creating GitHub Releases.
           token: ${{ secrets.GITHUB_TOKEN }}
 

CHANGELOG.md

@@ -0,0 +1,3 @@
+## v1.1.0
+
+More robust way of finding either Everest or Vanilla Celeste. Whether or not you started linsplit while in the menu, it should now work when opening a save file.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "linsplit"
-version = "1.0.2"
+version = "1.1.0"
 edition = "2024"
 authors = ["Paloys"]
 description = "An autosplitter for the game Celeste, working on Linux!"

Cargo.toml

@@ -16,8 +16,7 @@ If/when the projet gets big enough, I might try to upload it to various package
 
 To use it, just run it using `linsplit` if it's in your path, or with `./linsplit` wherever you put the executable if not.
 LinSplit will then start listening on a port for a LiveSplit One connection. Once it has connected to LiveSplit One, it'll start searching for either Celeste or Everest (the modded version of Celeste) in the memory.\
-The way LinSplit detects Vanilla Celeste in by finding a specific object in the memory of the program by parsing your save files for your file timers (if you're not using the game from Steam, you might want to change the location with the `-f` argument).\
-It is recommended you start LinSplit inside an already started game file, while inside the menu (the 3D map where you choose your chapter). If it fails to detect on the first time, interrupt linsplit with Ctrl-C and try again.
+The way LinSplit detects Vanilla Celeste in by finding a specific object in the memory of the program by parsing your save files for your file timers (if you're not using the game from Steam, you might want to change the location with the `-f` argument).
 
 ### Arguments
 

README.md

@@ -23,15 +23,15 @@ pub struct LinSplitData {
 }
 
 impl LinSplitData {
-    pub async fn new(file_path: &str, addr: &str, save_location: &str) -> Arc<Self> {
+    pub async fn new(file_path: &str, addr: &str, save_location: String) -> Arc<Self> {
         let events = Arc::new(Mutex::new(VecDeque::new()));
         let event_notifications = Arc::new(Notify::new());
         let splits = SplitData::read_splits(file_path).unwrap();
         let socket =
             SplitterSocket::new(addr, Arc::clone(&events), Arc::clone(&event_notifications))
                 .await
                 .unwrap();
-        let game_data = RwLock::new(GameData::new(save_location));
+        let game_data = RwLock::new(GameData::new(save_location).await);
         // tokio::time::sleep(Duration::from_secs(3)).await;
         let data = Arc::new(LinSplitData {
             splits,

src/linsplit_data.rs

@@ -50,7 +50,7 @@ async fn main() {
     let data = LinSplitData::new(
         &args.splits,
         &format!("{}:{}", args.address, args.port),
-        &args.save_location,
+        args.save_location,
     )
     .await;
     data.main_loop().await;

src/main.rs

@@ -6,7 +6,6 @@ use procfs::process::{MMPermissions, Process};
 use std::{
     fs::File,
     io::{Read, Seek, SeekFrom},
-    thread::sleep,
     time::Duration,
 };
 
@@ -16,7 +15,7 @@ pub(super) struct EverestMemReader {
 }
 
 impl EverestMemReader {
-    pub fn new() -> Result<Option<Box<Self>>> {
+    pub async fn new() -> Result<Option<Box<Self>>> {
         const CORE_AUTOSPLITTER_MAGIC: &[u8] = b"EVERESTAUTOSPLIT\xF0\xF1\xF2\xF3";
         const CORE_AUTOSPLITTER_INFO_MIN_VERSION: u8 = 3;
         loop {
@@ -57,7 +56,7 @@ impl EverestMemReader {
                     }
                 }
             }
-            sleep(Duration::from_millis(200));
+            tokio::time::sleep(Duration::from_millis(200)).await;
         }
     }
 

src/memory_reader/everest_reader.rs

@@ -1,4 +1,7 @@
 use std::fmt::{self, Display};
+use std::time::Duration;
+
+use tokio::select;
 
 use crate::split_reader::split_reader::{Area, AreaMode};
 
@@ -24,18 +27,32 @@ pub struct GameData {
 }
 
 impl GameData {
-    pub fn new(save_location: &str) -> Self {
+    pub async fn new(save_location: String) -> Self {
         println!("Waiting for Celeste...");
         let mem_reader: Box<dyn MemReader>;
         loop {
-            if let Ok(Some(reader)) = VanillaMemReader::new(save_location) {
-                println!("Found Vanilla Celeste.");
-                mem_reader = reader;
-                break;
-            } else if let Ok(Some(reader)) = EverestMemReader::new() {
-                println!("Found Everest.");
-                mem_reader = reader;
-                break;
+            select! {
+                res = VanillaMemReader::new(save_location.clone()) => {
+                    match res {
+                        Ok(Some(reader)) => {
+                            println!("Found Vanilla Celeste.");
+                            mem_reader = reader;
+                            break
+                        },
+                        _ => {},
+                    }
+                }
+                res = EverestMemReader::new() => {
+                    match res {
+                        Ok(Some(reader)) => {
+                            println!("Found Everest.");
+                            mem_reader = reader;
+                            break;
+                        },
+                        _ => {},
+                    }
+                }
+                _ = tokio::time::sleep(Duration::from_secs(5)) => {}
             }
         }
         Self {

src/memory_reader/game_data.rs

@@ -17,83 +17,82 @@ pub(super) struct VanillaMemReader {
 }
 
 impl VanillaMemReader {
-    pub fn new(save_location: &str) -> Result<Option<Box<Self>>> {
-        let mut times: Vec<[u8; 8]> = Vec::with_capacity(3);
-        for i in 0..3 {
-            let file_path = expand_tilde(save_location)?.join(format!("{}.celeste", i));
-            if file_path.exists() {
-                let t = fs::read_to_string(file_path)?;
-                let u = Document::parse(t.as_str());
-                if let Ok(doc) = u {
-                    for child in doc.get_node(NodeId::new(1)).unwrap().children() {
-                        if child.tag_name().name() == "Time"
-                            && let Some(time_str) = child.text()
-                            && let Ok(time) = time_str.parse::<u64>()
-                        {
-                            times.push(time.to_le_bytes());
-                            break;
+    pub async fn new(save_location: String) -> Result<Option<Box<Self>>> {
+        tokio::task::spawn_blocking(move || {
+            let mut times: Vec<[u8; 8]> = Vec::with_capacity(3);
+            for i in 0..3 {
+                let file_path = expand_tilde(&save_location)?.join(format!("{}.celeste", i));
+                if file_path.exists() {
+                    let t = fs::read_to_string(file_path)?;
+                    let u = Document::parse(t.as_str());
+                    if let Ok(doc) = u {
+                        for child in doc.get_node(NodeId::new(1)).unwrap().children() {
+                            if child.tag_name().name() == "Time"
+                                && let Some(time_str) = child.text()
+                                && let Ok(time) = time_str.parse::<u64>()
+                            {
+                                times.push(time.to_le_bytes());
+                                break;
+                            }
                         }
                     }
                 }
             }
-        }
-        if times.is_empty() {
-            println!(
-                "Couldn't find any save files! Make sure the right path is provided with the -f argument"
-            );
-            return Ok(None);
-        }
-        let all_processes: Vec<Process> = procfs::process::all_processes()
-            .expect("Can't read /proc")
-            .filter_map(|p| match p {
-                Ok(p) => {
-                    if p.stat().ok()?.comm.contains("Celeste.bin.x86") {
-                        return Some(p);
-                    }
-                    None
-                } //  happy path
-                Err(_) => None,
-            })
-            .collect();
-        for process in all_processes {
-            if let Ok(mut memory) = process.mem()
-                && let Ok(maps) = process.maps()
-            {
-                for map in maps {
-                    if map.perms.contains(
-                        MMPermissions::READ | MMPermissions::WRITE | MMPermissions::PRIVATE,
-                    ) && map.address.1 - map.address.0 >= 24
-                    {
-                        if map.pathname != MMapPath::Anonymous {
-                            continue;
+            if times.is_empty() {
+                return Ok(None);
+            }
+            let all_processes: Vec<Process> = procfs::process::all_processes()
+                .expect("Can't read /proc")
+                .filter_map(|p| match p {
+                    Ok(p) => {
+                        if p.stat().ok()?.comm.contains("Celeste.bin.x86") {
+                            return Some(p);
                         }
-                        let size = (map.address.1 - map.address.0) as usize;
-                        let mut buf = vec![0u8; size];
-
-                        memory.seek(SeekFrom::Start(map.address.0))?;
-                        if let Err(_) = memory.read_exact(&mut buf) {
-                            continue;
-                        };
-                        for time in &times {
-                            let needle: [u8; 8] = *time;
-                            for i in (0..=buf.len() - 24).step_by(8) {
-                                if &buf[i..i + 8] == needle
-                                    && buf[i - 16..i].iter().all(|&b| b == 0)
-                                {
-                                    let position = map.address.0 + i as u64;
-                                    return Ok(Some(Box::new(VanillaMemReader {
-                                        memory,
-                                        offset: position - 0x28,
-                                        last_file_time: f64::INFINITY,
-                                    })));
+                        None
+                    } //  happy path
+                    Err(_) => None,
+                })
+                .collect();
+            for process in all_processes {
+                if let Ok(mut memory) = process.mem()
+                    && let Ok(maps) = process.maps()
+                {
+                    for map in maps {
+                        if map.perms.contains(
+                            MMPermissions::READ | MMPermissions::WRITE | MMPermissions::PRIVATE,
+                        ) && map.address.1 - map.address.0 >= 24
+                        {
+                            if map.pathname != MMapPath::Anonymous {
+                                continue;
+                            }
+                            let size = (map.address.1 - map.address.0) as usize;
+                            let mut buf = vec![0u8; size];
+
+                            memory.seek(SeekFrom::Start(map.address.0))?;
+                            if let Err(_) = memory.read_exact(&mut buf) {
+                                continue;
+                            };
+                            for time in &times {
+                                let needle: [u8; 8] = *time;
+                                for i in (0..=buf.len() - 24).step_by(8) {
+                                    if &buf[i..i + 8] == needle
+                                        && buf[i - 16..i].iter().all(|&b| b == 0)
+                                    {
+                                        let position = map.address.0 + i as u64;
+                                        return Ok(Some(Box::new(VanillaMemReader {
+                                            memory,
+                                            offset: position - 0x28,
+                                            last_file_time: f64::INFINITY,
+                                        })));
+                                    }
                                 }
                             }
                         }
                     }
                 }
             }
-        }
-        Ok(None)
+            Ok(None)
+        }).await?
     }
 
     fn read_bits<const COUNT: usize>(&mut self, offset: u64) -> Result<[u8; COUNT]> {