feat: update memory reader

src-tauri/Cargo.lock

@@ -10,12 +10,23 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aead"
-version = "0.6.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1973cfbc1a2daf9cf550e74e1f088c28e7f7d8c1e1418fb6c9dc5184b7e84c99"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
- "crypto-common 0.2.2",
+ "crypto-common 0.1.7",
- "inout",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
 ]
 
 [[package]]
@@ -24,20 +35,20 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66bd29a732b644c0431c6140f370d097879203d79b80c94a6747ba0872adaef8"
 dependencies = [
- "cipher",
+ "cipher 0.5.2",
  "cpubits",
  "cpufeatures 0.3.0",
 ]
 
 [[package]]
 name = "aes-gcm"
-version = "0.11.0"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdf011db2e21ce0d575593d749db5554b47fed37aff429e4dc50bc91ac93a028"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
 dependencies = [
  "aead",
- "aes",
+ "aes 0.8.4",
- "cipher",
+ "cipher 0.4.4",
  "ctr",
  "ghash",
  "subtle",
@@ -549,15 +560,24 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout 0.1.4",
+]
+
 [[package]]
 name = "cipher"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c"
 dependencies = [
- "block-buffer 0.12.0",
  "crypto-common 0.2.2",
- "inout",
+ "inout 0.2.2",
 ]
 
 [[package]]
@@ -759,6 +779,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -768,9 +789,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
 dependencies = [
- "getrandom 0.4.2",
  "hybrid-array",
- "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -831,11 +850,11 @@ checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
 
 [[package]]
 name = "ctr"
-version = "0.10.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baaca1c4b237092596f64d571e9db6ce4109c4ef9742e27590f1709594461f21"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
 dependencies = [
- "cipher",
+ "cipher 0.4.4",
 ]
 
 [[package]]
@@ -1230,6 +1249,7 @@ dependencies = [
  "hardware-id",
  "hex",
  "md5",
+ "memchr",
  "once_cell",
  "open",
  "presenceforge",
@@ -1650,7 +1670,6 @@ dependencies = [
  "js-sys",
  "libc",
  "r-efi 6.0.0",
- "rand_core 0.10.1",
  "wasip2",
  "wasip3",
  "wasm-bindgen",
@@ -1658,10 +1677,11 @@ dependencies = [
 
 [[package]]
 name = "ghash"
-version = "0.6.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
 dependencies = [
+ "opaque-debug",
  "polyval",
 ]
 
@@ -2237,6 +2257,15 @@ dependencies = [
  "cfb",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "inout"
 version = "0.2.2"
@@ -2592,9 +2621,9 @@ checksum = "ae960838283323069879657ca3de837e9f7bbb4c7bf6ea7f1b290d5e9476d2e0"
 
 [[package]]
 name = "memchr"
-version = "2.7.6"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "memoffset"
@@ -3011,6 +3040,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
 [[package]]
 name = "open"
 version = "5.3.6"
@@ -3381,12 +3416,13 @@ dependencies = [
 
 [[package]]
 name = "polyval"
-version = "0.7.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dfc63250416fea14f5749b90725916a6c903f599d51cb635aa7a52bfd03eede"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
 dependencies = [
- "cpubits",
+ "cfg-if",
- "cpufeatures 0.3.0",
+ "cpufeatures 0.2.17",
+ "opaque-debug",
  "universal-hash",
 ]
 
@@ -3716,12 +3752,6 @@ dependencies = [
  "getrandom 0.3.4",
 ]
 
-[[package]]
-name = "rand_core"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
-
 [[package]]
 name = "rand_hc"
 version = "0.2.0"
@@ -5603,12 +5633,12 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "universal-hash"
-version = "0.6.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
 dependencies = [
- "crypto-common 0.2.2",
+ "crypto-common 0.1.7",
- "ctutils",
+ "subtle",
 ]
 
 [[package]]
@@ -6870,7 +6900,7 @@ version = "8.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d04a6b5381502aa6087c94c669499eb1602eb9c5e8198e534de571f7154809b"
 dependencies = [
- "aes",
+ "aes 0.9.0",
  "bzip2",
  "constant_time_eq",
  "crc32fast",

src-tauri/Cargo.toml

@@ -52,10 +52,11 @@ zip = "8.6.0"
 sha1 = "0.11.0"
 hex = "0.4.3"
 rusqlite = { version = "0.40.1", features = ["bundled"] }
-aes-gcm = "0.11.0"
+aes-gcm = "0.10.3"
 base64 = "0.22.1"
 sha2 = "0.11.0"
 thiserror = "2.0.18"
+memchr = "2.8.2"
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.56.0"

src-tauri/src/commands.rs

@@ -1,4 +1,5 @@
 use crate::config::ConfigError;
+use crate::memory_reader::OsuMemoryClient;
 use hardware_id::get_id;
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
@@ -500,6 +501,26 @@ pub async fn run_osu(folder: String, patch: bool) -> Result<(), String> {
         }
     }
 
+    let game_process_id = game_process.id().ok_or(-1);
+    if let Ok(pid) = game_process_id {
+        // OsuMemoryClient contains non-Send raw pointers; run its loop in a blocking task
+        let handle = tokio::task::spawn_blocking(move || {
+            let mut mem_client = OsuMemoryClient::new_with_debug(pid, true).unwrap();
+            loop {
+                if !mem_client.is_running() {
+                    println!("Game process has exited or is not running.");
+                    break;
+                }
+                let state = mem_client.read_state();
+                println!("Game state: {:?}", state);
+                // wait 5 seconds between iterations to avoid busy-looping
+                std::thread::sleep(std::time::Duration::from_secs(5));
+            }
+        });
+
+        handle.await.map_err(|e| e.to_string())?;
+    }
+
     game_process.wait().await.map_err(|e| e.to_string())?;
     Ok(())
 }

src-tauri/src/memory_reader.rs

@@ -1,52 +1,16 @@
-//! osu_memory_reader.rs
+use memchr::memchr;
-//!
-//! External, read-only memory reader for the osu! stable client, structured
-//! the same way community tools like tosu / gosumemory work:
-//!
-//!   1. Open the osu process with PROCESS_VM_READ.
-//!   2. Enumerate its committed memory regions.
-//!   3. Scan those regions for known byte-pattern "signatures".
-//!   4. Walk a short pointer chain from each signature to the real struct.
-//!   5. Parse out the fields you care about (username, mods, combo, etc).
-//!
-//! IMPORTANT: The actual signature bytes below are PLACEHOLDERS. osu!
-//! updates its binary regularly, which shifts/breaks raw byte signatures.
-//! Community tools maintain live, current signatures — pull up-to-date
-//! ones from tosu's open-source repo (github.com/KotRikD/tosu, see its
-//! `packages/tosu/src/memory/` signature definitions) and drop them into
-//! the `SIGNATURES` table below. This file gives you the engine; you keep
-//! the signature table current.
-//!
-//! This is entirely read-only (ReadProcessMemory only, never Write) and
-//! only targets your own launched osu! process — no injection involved.
-//!
-//! ---------------------------------------------------------------------
-//! Cargo.toml additions (on top of the ones from osu_scanner.rs):
-//!
-//! [dependencies]
-//! windows = { version = "0.58", features = [
-//!     "Win32_System_Diagnostics_ToolHelp",
-//!     "Win32_System_Memory",
-//!     "Win32_System_Threading",
-//!     "Win32_System_Diagnostics_Debug",
-//!     "Win32_Foundation"
-//! ] }
-//! ---------------------------------------------------------------------
-
 use serde::Serialize;
 use std::collections::HashMap;
-use windows::Win32::Foundation::{CloseHandle, HANDLE};
+use windows::Win32::Foundation::{CloseHandle, HANDLE, STILL_ACTIVE};
 use windows::Win32::System::Diagnostics::Debug::ReadProcessMemory;
 use windows::Win32::System::Memory::{
-    MEM_COMMIT, MEMORY_BASIC_INFORMATION, PAGE_GUARD, PAGE_NOACCESS, VirtualQueryEx,
+    MEM_COMMIT, MEMORY_BASIC_INFORMATION, PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE,
+    PAGE_EXECUTE_WRITECOPY, PAGE_GUARD, PAGE_NOACCESS, VirtualQueryEx,
+};
+use windows::Win32::System::Threading::{
+    GetExitCodeProcess, OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ,
 };
-use windows::Win32::System::Threading::{OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ};
 
-// =========================================================================
-// Signature table — REPLACE with current values, see module doc comment.
-// =========================================================================
-
-/// A byte pattern to search for in process memory. `None` = wildcard byte.
 #[derive(Clone)]
 pub struct Signature {
     pub name: &'static str,
@@ -74,71 +38,59 @@ fn parse_aob(s: &str) -> Vec<Option<u8>> {
         .collect()
 }
 
-/// NOTE: These are PLACEHOLDER patterns illustrating the *shape* tosu-style
-/// signatures take (short, somewhat unique byte runs with wildcards around
-/// the volatile parts). Do not expect these exact bytes to match a real
-/// osu! binary — swap them for current ones before using this for real.
 pub fn build_signature_table() -> HashMap<&'static str, Signature> {
     let mut map = HashMap::new();
 
     map.insert(
-        "username_ptr",
+        "user_profile_ptr",
         Signature {
-            name: "username_ptr",
+            name: "user_profile_ptr",
-            pattern: Box::leak(sig!("75 04 33 C0 EB 0A A1 ?? ?? ?? ??").into_boxed_slice()),
-            offset: 7, // offset to the 4-byte address embedded in the instruction
-        },
-    );
-
-    map.insert(
-        "game_mode_ptr",
-        Signature {
-            name: "game_mode_ptr",
-            pattern: Box::leak(sig!("83 F8 08 7D 05 ?? ?? ?? ?? ??").into_boxed_slice()),
-            offset: 5,
-        },
-    );
-
-    map.insert(
-        "current_beatmap_ptr",
-        Signature {
-            name: "current_beatmap_ptr",
-            pattern: Box::leak(sig!("6A 01 6A 00 A1 ?? ?? ?? ?? 8B 00").into_boxed_slice()),
-            offset: 4,
-        },
-    );
-
-    map.insert(
-        "combo_ptr",
-        Signature {
-            name: "combo_ptr",
             pattern: Box::leak(
-                sig!("83 3D ?? ?? ?? ?? 00 7E 34 A1 ?? ?? ?? ??").into_boxed_slice(),
+                sig!("FF 15 ?? ?? ?? ?? A1 ?? ?? ?? ?? 8B 48 54 33 D2").into_boxed_slice(),
             ),
-            offset: 9,
+            offset: 0x7,
         },
     );
 
-    // userId typically lives on the same "player info" object as username,
-    // just at a different field offset — but tosu-style tools usually give
-    // it its own independent signature since it's read even when the
-    // username string hasn't been touched yet (e.g. right after login).
     map.insert(
-        "user_id_ptr",
+        "base_addr",
         Signature {
-            name: "user_id_ptr",
+            name: "base_addr",
-            pattern: Box::leak(sig!("A1 ?? ?? ?? ?? 89 45 ?? 8B 45 ?? 8B 0D").into_boxed_slice()),
+            pattern: Box::leak(sig!("F8 01 74 04 83 65").into_boxed_slice()),
-            offset: 1,
+            offset: 0,
+        },
+    );
+
+    map.insert(
+        "rulesets_addr",
+        Signature {
+            name: "rulesets_addr",
+            pattern: Box::leak(sig!("7D 15 A1 ?? ?? ?? ?? 85 C0").into_boxed_slice()),
+            offset: 0,
+        },
+    );
+
+    map.insert(
+        "status_ptr",
+        Signature {
+            name: "status_ptr",
+            pattern: Box::leak(sig!("48 83 F8 04 73 1E").into_boxed_slice()),
+            offset: -0x4,
+        },
+    );
+
+    map.insert(
+        "play_time_addr",
+        Signature {
+            name: "play_time_addr",
+            pattern: Box::leak(sig!("5E 5F 5D C3 A1 ?? ?? ?? ?? 89 ?? 04").into_boxed_slice()),
+            offset: 0,
         },
     );
 
     map
 }
 
-// =========================================================================
-// Process handle + raw memory access
-// =========================================================================
-
 pub struct MemoryReader {
     handle: HANDLE,
     pid: u32,
@@ -162,10 +114,27 @@ impl MemoryReader {
     /// Re-enumerates committed, readable memory regions. Call once after
     /// open() and periodically after (e.g. once per scan cycle), since the
     /// process's memory layout can change.
+    ///
+    /// By default only keeps EXECUTABLE regions. This matters a lot for
+    /// speed: our signatures target JIT-compiled machine code, which only
+    /// ever lives in executable pages — the managed heap, GC data, and
+    /// other non-executable regions can be gigabytes in size and contain
+    /// nothing worth scanning. Skipping them is the single biggest speedup
+    /// available here. Pass `executable_only = false` only if you add a
+    /// signature that targets plain data instead of code.
     pub fn refresh_regions(&mut self) {
+        self.refresh_regions_filtered(true);
+    }
+
+    pub fn refresh_regions_filtered(&mut self, executable_only: bool) {
         self.regions.clear();
         let mut address: usize = 0;
 
+        const EXECUTABLE_FLAGS: u32 = PAGE_EXECUTE.0
+            | PAGE_EXECUTE_READ.0
+            | PAGE_EXECUTE_READWRITE.0
+            | PAGE_EXECUTE_WRITECOPY.0;
+
         loop {
             let mut mbi = MEMORY_BASIC_INFORMATION::default();
             let result = unsafe {
@@ -185,8 +154,15 @@ impl MemoryReader {
             let is_committed = mbi.State == MEM_COMMIT;
             let is_guarded = (mbi.Protect & PAGE_GUARD).0 != 0;
             let is_no_access = mbi.Protect == PAGE_NOACCESS;
+            let is_executable = (mbi.Protect.0 & EXECUTABLE_FLAGS) != 0;
 
-            if is_committed && !is_guarded && !is_no_access && region_size > 0 {
+            let keep = is_committed
+                && !is_guarded
+                && !is_no_access
+                && region_size > 0
+                && (!executable_only || is_executable);
+
+            if keep {
                 self.regions.push((mbi.BaseAddress as usize, region_size));
             }
 
@@ -222,6 +198,11 @@ impl MemoryReader {
         }
     }
 
+    pub fn read_u8(&self, address: usize) -> Option<u8> {
+        let bytes = self.read_bytes(address, 1)?;
+        Some(bytes[0])
+    }
+
     pub fn read_i32(&self, address: usize) -> Option<i32> {
         let bytes = self.read_bytes(address, 4)?;
         Some(i32::from_le_bytes(bytes.try_into().ok()?))
@@ -237,6 +218,16 @@ impl MemoryReader {
         Some(u16::from_le_bytes(bytes.try_into().ok()?))
     }
 
+    pub fn read_i64(&self, address: usize) -> Option<i64> {
+        let bytes = self.read_bytes(address, 8)?;
+        Some(i64::from_le_bytes(bytes.try_into().ok()?))
+    }
+
+    pub fn read_f32(&self, address: usize) -> Option<f32> {
+        let bytes = self.read_bytes(address, 4)?;
+        Some(f32::from_le_bytes(bytes.try_into().ok()?))
+    }
+
     pub fn read_f64(&self, address: usize) -> Option<f64> {
         let bytes = self.read_bytes(address, 8)?;
         Some(f64::from_le_bytes(bytes.try_into().ok()?))
@@ -299,6 +290,18 @@ impl MemoryReader {
     pub fn pid(&self) -> u32 {
         self.pid
     }
+
+    /// Returns true if the target process is still running.
+    pub fn is_running(&self) -> bool {
+        let mut code: u32 = 0;
+        unsafe {
+            if GetExitCodeProcess(self.handle, &mut code).is_ok() {
+                // STILL_ACTIVE is an NTSTATUS; compare against its inner value as u32
+                return code == (STILL_ACTIVE.0 as u32);
+            }
+        }
+        false
+    }
 }
 
 impl Drop for MemoryReader {
@@ -309,33 +312,109 @@ impl Drop for MemoryReader {
     }
 }
 
-/// Naive substring search over a byte pattern with wildcards. Fine for
+/// Pattern search accelerated with `memchr`: instead of checking every
-/// per-scan-cycle use; swap for a Boyer-Moore-style skip table if you need
+/// single byte offset, we jump straight to candidate positions for the
-/// to scan very large regions many times per second.
+/// pattern's first non-wildcard byte, and only run the full (still naive,
+/// but now rarely-invoked) comparison at those candidates. If the pattern
+/// is all-wildcards up front (rare/pathological), falls back to a plain
+/// per-offset scan.
 fn find_pattern(haystack: &[u8], pattern: &[Option<u8>]) -> Option<usize> {
     if pattern.is_empty() || haystack.len() < pattern.len() {
         return None;
     }
 
-    haystack.windows(pattern.len()).position(|window| {
+    let Some((anchor_idx, anchor_byte)) = pattern
-        window
         .iter()
-            .zip(pattern.iter())
+        .enumerate()
-            .all(|(b, p)| p.map_or(true, |expected| *b == expected))
+        .find_map(|(i, b)| b.map(|byte| (i, byte)))
-    })
+    else {
+        // Fully wildcarded pattern — nothing to anchor on, first position works.
+        return Some(0);
+    };
+
+    let max_start = haystack.len() - pattern.len();
+    // Absolute position in `haystack` from which we search for the anchor
+    // byte. Starts at anchor_idx since candidate_start can't go negative
+    // (candidate_start = anchor_pos - anchor_idx).
+    let mut anchor_pos = anchor_idx;
+
+    loop {
+        if anchor_pos >= haystack.len() {
+            return None;
         }
 
-// =========================================================================
+        let Some(rel) = memchr(anchor_byte, &haystack[anchor_pos..]) else {
-// High-level "osu state" reader
+            return None; // anchor byte doesn't occur again — no match possible
-// =========================================================================
+        };
+
+        let abs_anchor = anchor_pos + rel;
+        let candidate_start = abs_anchor - anchor_idx; // safe: abs_anchor >= anchor_pos >= anchor_idx
+
+        if candidate_start > max_start {
+            return None;
+        }
+
+        let window = &haystack[candidate_start..candidate_start + pattern.len()];
+        let matches = window
+            .iter()
+            .zip(pattern.iter())
+            .all(|(b, p)| p.map_or(true, |expected| *b == expected));
+
+        if matches {
+            return Some(candidate_start);
+        }
+
+        anchor_pos = abs_anchor + 1;
+    }
+}
+
+#[derive(Serialize, Debug, Default, Clone)]
+pub struct OsuProfile {
+    pub name: Option<String>,
+    pub id: Option<i32>,
+    pub accuracy: Option<f64>,
+    pub ranked_score: Option<i64>,
+    pub level: Option<f32>,
+    pub play_count: Option<i32>,
+    pub play_mode: Option<i32>,
+    pub rank: Option<i32>,
+    pub country_code: Option<i32>,
+    pub performance_points: Option<i32>,
+    /// ARGB packed color; convert with format!("{:08X}", background_colour)
+    pub background_colour: Option<u32>,
+    pub raw_bancho_status: Option<u8>,
+}
+
+#[derive(Serialize, Debug, Default, Clone)]
+pub struct BeatmapInfo {
+    pub checksum: Option<String>,
+    pub filename: Option<String>,
+    pub artist: Option<String>,
+    pub artist_original: Option<String>,
+    pub title: Option<String>,
+    pub title_original: Option<String>,
+    pub creator: Option<String>,
+    pub difficulty_name: Option<String>,
+    pub folder: Option<String>,
+    pub audio_filename: Option<String>,
+    pub background_filename: Option<String>,
+    pub ar: Option<f32>,
+    pub cs: Option<f32>,
+    pub hp: Option<f32>,
+    pub od: Option<f32>,
+    pub map_id: Option<i32>,
+    pub set_id: Option<i32>,
+    pub ranked_status: Option<i32>,
+    pub object_count: Option<i32>,
+}
 
 #[derive(Serialize, Debug, Default, Clone)]
 pub struct OsuState {
-    pub username: Option<String>,
+    pub profile: OsuProfile,
-    pub user_id: Option<i32>,
+    pub status: Option<i32>,
+    pub play_time: Option<i32>,
     pub game_mode: Option<i32>,
-    pub combo: Option<i32>,
+    pub beatmap: BeatmapInfo,
-    pub beatmap_id: Option<i32>,
 }
 
 pub struct OsuMemoryClient {
@@ -345,6 +424,10 @@ pub struct OsuMemoryClient {
     /// every single read — only re-resolve if a read at the cached address
     /// stops making sense (e.g. after an osu update / restart).
     resolved: HashMap<&'static str, usize>,
+    /// Signatures that failed to resolve on the last attempt. Prevents
+    /// re-running a full (expensive) memory scan every single call when a
+    /// signature is missing/wrong — cleared only by `refresh()`.
+    failed: std::collections::HashSet<&'static str>,
     /// When true, prints signature resolution + read results to stderr.
     /// Toggle via `new_with_debug`, or flip at runtime with `set_debug`.
     debug: bool,
@@ -374,6 +457,7 @@ impl OsuMemoryClient {
             reader,
             signatures: build_signature_table(),
             resolved: HashMap::new(),
+            failed: std::collections::HashSet::new(),
             debug,
         })
     }
@@ -393,6 +477,7 @@ impl OsuMemoryClient {
         }
         self.reader.refresh_regions();
         self.resolved.clear();
+        self.failed.clear();
         if self.debug {
             eprintln!(
                 "[osu_memory] {} readable regions after refresh",
@@ -409,11 +494,21 @@ impl OsuMemoryClient {
             return Some(*addr);
         }
 
+        if self.failed.contains(key) {
+            if self.debug {
+                eprintln!(
+                    "[osu_memory] {key}: skipping, previously failed this cycle (call refresh() to retry)"
+                );
+            }
+            return None;
+        }
+
         let sig = self.signatures.get(key)?.clone();
         let Some(found) = self.reader.find_signature(&sig) else {
             if self.debug {
                 eprintln!("[osu_memory] {key}: signature NOT FOUND in any scanned region");
             }
+            self.failed.insert(key);
             return None;
         };
         let target = (found as isize + sig.offset) as usize;
@@ -429,62 +524,136 @@ impl OsuMemoryClient {
         Some(target)
     }
 
-    pub fn read_username(&mut self) -> Option<String> {
+    /// Resolves the profile object pointer (one signature lookup + one
-        let addr = self.resolve("username_ptr")?;
+    /// pointer dereference), shared by every field below so we don't
-        let ptr = self.reader.read_ptr(addr)?;
+    /// re-resolve the signature per-field.
-        let value = self.reader.read_dotnet_string(ptr, 64);
+    fn resolve_profile_base(&mut self) -> Option<usize> {
+        let addr = self.resolve("user_profile_ptr")?;
+        let base = self.reader.read_ptr(addr)?;
         if self.debug {
-            eprintln!("[osu_memory] username -> {value:?}");
+            eprintln!("[osu_memory] profileBase -> 0x{base:X}");
+        }
+        Some(base)
+    }
+
+    /// Reads the full player profile in one shot, mirroring tosu's `user()`
+    /// getter: one profileBase pointer, then every field at a fixed byte
+    /// offset from it.
+    pub fn read_profile(&mut self) -> OsuProfile {
+        let Some(base) = self.resolve_profile_base() else {
+            return OsuProfile::default();
+        };
+
+        let name_str_ptr = self.reader.read_i32(base + 0x30).map(|v| v as usize);
+        let name = name_str_ptr.and_then(|p| self.reader.read_dotnet_string(p, 64));
+
+        let profile = OsuProfile {
+            name,
+            id: self.reader.read_i32(base + 0x70),
+            accuracy: self.reader.read_f64(base + 0x4),
+            ranked_score: self.reader.read_i64(base + 0xc),
+            level: self.reader.read_f32(base + 0x74),
+            play_count: self.reader.read_i32(base + 0x7c),
+            play_mode: self.reader.read_i32(base + 0x80),
+            rank: self.reader.read_i32(base + 0x84),
+            country_code: self.reader.read_i32(base + 0x9c),
+            performance_points: self.reader.read_i32(base + 0x88),
+            background_colour: self.reader.read_u32(base + 0xac),
+            raw_bancho_status: self.reader.read_u8(base + 0x8c),
+        };
+
+        if self.debug {
+            eprintln!("[osu_memory] profile -> {profile:?}");
+        }
+
+        profile
+    }
+
+    pub fn read_status(&mut self) -> Option<i32> {
+        let addr = self.resolve("status_ptr")?;
+        let value = self.reader.read_i32(addr);
+        if self.debug {
+            eprintln!("[osu_memory] status -> {value:?}");
         }
         value
     }
 
-    pub fn read_user_id(&mut self) -> Option<i32> {
+    pub fn read_play_time(&mut self) -> Option<i32> {
-        let addr = self.resolve("user_id_ptr")?;
+        let addr = self.resolve("play_time_addr")?;
-        // Unlike username/combo/beatmap, this signature usually points
+        let ptr = self.reader.read_i32(addr + 0x5)? as usize;
-        // straight at a static int slot rather than through an extra
+        let value = self.reader.read_i32(ptr);
-        // object pointer — verify against whatever real signature you use,
-        // some variants do need an extra self.reader.read_ptr() hop first.
-        let value = self.reader.read_i32(addr);
         if self.debug {
-            eprintln!("[osu_memory] user_id -> {value:?}");
+            eprintln!("[osu_memory] play_time -> {value:?}");
         }
         value
     }
 
     pub fn read_game_mode(&mut self) -> Option<i32> {
-        let addr = self.resolve("game_mode_ptr")?;
+        let base = self.resolve("base_addr")?;
-        let ptr = self.reader.read_ptr(addr)?;
+        let value = self.reader.read_i32(base.wrapping_sub(0x33));
-        let value = self.reader.read_i32(ptr);
         if self.debug {
             eprintln!("[osu_memory] game_mode -> {value:?}");
         }
         value
     }
 
-    pub fn read_combo(&mut self) -> Option<i32> {
+    #[allow(dead_code)]
-        let addr = self.resolve("combo_ptr")?;
+    fn resolve_ruleset_addr(&mut self) -> Option<usize> {
-        let ptr = self.reader.read_ptr(addr)?;
+        let sig_addr = self.resolve("rulesets_addr")?;
-        let value = self.reader.read_i32(ptr);
+        let step1 = self.reader.read_i32(sig_addr.wrapping_sub(0xb))? as usize;
+        let ruleset_addr = self.reader.read_i32(step1 + 0x4)? as usize;
         if self.debug {
-            eprintln!("[osu_memory] combo -> {value:?}");
+            eprintln!("[osu_memory] ruleset_addr -> 0x{ruleset_addr:X}");
         }
-        value
+        Some(ruleset_addr)
     }
 
-    pub fn read_beatmap_id(&mut self) -> Option<i32> {
+    pub fn read_current_beatmap(&mut self) -> BeatmapInfo {
-        let addr = self.resolve("current_beatmap_ptr")?;
+        let Some(base) = self.resolve("base_addr") else {
-        let ptr = self.reader.read_ptr(addr)?;
+            return BeatmapInfo::default();
-        let value = self.reader.read_i32(ptr + 0xC); // example nested offset into the beatmap struct
+        };
+        let Some(beatmap_addr) = self
+            .reader
+            .read_i32(base.wrapping_sub(0xc))
+            .map(|v| v as usize)
+        else {
+            return BeatmapInfo::default();
+        };
+
+        let read_str_field = |reader: &MemoryReader, off: usize| -> Option<String> {
+            let ptr = reader.read_i32(beatmap_addr + off)? as usize;
+            reader.read_dotnet_string(ptr, 512)
+        };
+
+        let info = BeatmapInfo {
+            checksum: read_str_field(&self.reader, 0x6c),
+            filename: read_str_field(&self.reader, 0x90),
+            artist: read_str_field(&self.reader, 0x18),
+            artist_original: read_str_field(&self.reader, 0x1c),
+            title: read_str_field(&self.reader, 0x24),
+            title_original: read_str_field(&self.reader, 0x28),
+            creator: read_str_field(&self.reader, 0x7c),
+            difficulty_name: read_str_field(&self.reader, 0xac),
+            folder: read_str_field(&self.reader, 0x78),
+            audio_filename: read_str_field(&self.reader, 0x64),
+            background_filename: read_str_field(&self.reader, 0x68),
+            ar: self.reader.read_f32(beatmap_addr + 0x2c),
+            cs: self.reader.read_f32(beatmap_addr + 0x30),
+            hp: self.reader.read_f32(beatmap_addr + 0x34),
+            od: self.reader.read_f32(beatmap_addr + 0x38),
+            map_id: self.reader.read_i32(beatmap_addr + 0xc8),
+            set_id: self.reader.read_i32(beatmap_addr + 0xcc),
+            ranked_status: self.reader.read_i32(beatmap_addr + 0x12c),
+            object_count: self.reader.read_i32(beatmap_addr + 0xf8),
+        };
+
         if self.debug {
-            eprintln!("[osu_memory] beatmap_id -> {value:?}");
+            eprintln!("[osu_memory] beatmap -> {info:?}");
-        }
+        }
-        value
+
+        info
     }
 
-    /// Convenience: read everything at once into a single struct, suitable
-    /// for bundling into your existing scan payload / emitting to the
-    /// frontend.
     pub fn read_state(&mut self) -> OsuState {
         if self.debug {
             eprintln!(
@@ -493,27 +662,20 @@ impl OsuMemoryClient {
             );
         }
         let state = OsuState {
-            username: self.read_username(),
+            profile: self.read_profile(),
-            user_id: self.read_user_id(),
+            status: self.read_status(),
+            play_time: self.read_play_time(),
             game_mode: self.read_game_mode(),
-            combo: self.read_combo(),
+            beatmap: self.read_current_beatmap(),
-            beatmap_id: self.read_beatmap_id(),
         };
         if self.debug {
             eprintln!("[osu_memory] state = {state:?}");
         }
         state
     }
-}
 
-// =========================================================================
+    /// Returns true if the target osu! process is still running.
-// Example wiring into your existing watcher loop
+    pub fn is_running(&self) -> bool {
-// =========================================================================
+        self.reader.is_running()
-//
+    }
-// let mut mem_client = OsuMemoryClient::new(osu_pid)?;
+}
-// loop {
-//     let state = mem_client.read_state();
-//     // attach `state` to your ScanPayload before POSTing to the server
-//     // if a read silently comes back all-None a few cycles in a row,
-//     // call mem_client.refresh() in case osu updated/restarted.
-// }