125 lines
4.0 KiB
Rust
125 lines
4.0 KiB
Rust
use anyhow::{Context, Result};
|
|
use sysinfo::{PidExt, ProcessExt, ProcessRefreshKind, RefreshKind, System, SystemExt};
|
|
use vmemory::ProcessMemory;
|
|
|
|
pub struct GameState {
|
|
pub location: u16,
|
|
pub gil: u32,
|
|
pub steps: u32,
|
|
pub stage: u16,
|
|
|
|
pid: u32,
|
|
base: usize,
|
|
base_size: usize,
|
|
mem: Vec<u8>,
|
|
proc_mem: ProcessMemory,
|
|
|
|
data_pattern: Vec<u8>,
|
|
data_addr: usize,
|
|
}
|
|
|
|
impl GameState {
|
|
const LOCATION_OFFSET: isize = -0x90;
|
|
const GIL_OFFSET: isize = 0x8;
|
|
const STEPS_OFFSET: isize = 0xC;
|
|
const STAGE_OFFSET: isize = 0x200;
|
|
|
|
pub fn new() -> Result<Self> {
|
|
let sys = System::new_with_specifics(RefreshKind::new().with_processes(ProcessRefreshKind::new()));
|
|
let proc = sys.processes()
|
|
.iter()
|
|
.find(|(_, proc)| proc.name() == "FFXII_TZA.exe");
|
|
let (pid, _) = match proc {
|
|
Some(p) => p,
|
|
None => anyhow::bail!("could not find TZA process")
|
|
};
|
|
|
|
let mem = ProcessMemory::attach_process(pid.as_u32()).unwrap();
|
|
let mut base = 0;
|
|
let mut base_size = 0;
|
|
process_list::for_each_module(pid.as_u32(), |(address, size), name| {
|
|
let stem = name.file_stem().unwrap_or_default();
|
|
if stem == "FFXII_TZA" {
|
|
base = address;
|
|
base_size = size;
|
|
}
|
|
}).context("could not loop TZA modules")?;
|
|
if base == 0 || base_size == 0 {
|
|
anyhow::bail!("could not find TZA base address");
|
|
}
|
|
|
|
let tza_mem = mem.read_memory(base, base_size, false);
|
|
let data_pattern = crate::util::parse_pattern("48 8D 0D ?? ?? ?? ?? 41 B8 ?? ?? ?? ?? E8 ?? ?? ?? ?? 33 C9 E8").unwrap();
|
|
|
|
let mut state = Self {
|
|
location: 0,
|
|
gil: 0,
|
|
steps: 0,
|
|
stage: 0,
|
|
|
|
pid: pid.as_u32(),
|
|
base,
|
|
base_size,
|
|
mem: tza_mem,
|
|
proc_mem: mem,
|
|
|
|
data_pattern,
|
|
data_addr: 0,
|
|
};
|
|
|
|
state.set_addresses()?;
|
|
|
|
Ok(state)
|
|
}
|
|
|
|
fn find_address_indirect(&self, pattern: &[u8]) -> Result<usize> {
|
|
let ptr_ptr = match crate::util::find_pattern(&self.mem, pattern) {
|
|
Some(ptr) => ptr,
|
|
None => anyhow::bail!("could not find pointer"),
|
|
};
|
|
let ptr_offset = match crate::util::get_static_address(&self.mem, ptr_ptr, self.base) {
|
|
Some(addr) => addr,
|
|
None => anyhow::bail!("could not find pointer offset"),
|
|
};
|
|
let ptr_vec = self.proc_mem.read_memory(ptr_offset, 8, true);
|
|
let ptr_array: [u8; 8] = ptr_vec.try_into().unwrap();
|
|
Ok(u64::from_le_bytes(ptr_array) as usize - self.base)
|
|
}
|
|
|
|
fn find_address(&self, pattern: &[u8]) -> Result<usize> {
|
|
let ptr = match crate::util::find_pattern(&self.mem, pattern) {
|
|
Some(ptr) => ptr,
|
|
None => anyhow::bail!("could not find location pointer"),
|
|
};
|
|
let ptr_offset = match crate::util::get_static_address(&self.mem, ptr, self.base) {
|
|
Some(addr) => addr,
|
|
None => anyhow::bail!("could not find location pointer offset"),
|
|
};
|
|
Ok(ptr_offset)
|
|
}
|
|
|
|
fn set_addresses(&mut self) -> Result<()> {
|
|
self.data_addr = self.find_address(&self.data_pattern)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn read_data<const SIZE: usize>(&self, offset: isize) -> [u8; SIZE] {
|
|
let addr = self.data_addr as isize + offset;
|
|
let vec = self.proc_mem.read_memory(addr as usize, SIZE, true);
|
|
vec.try_into().unwrap()
|
|
}
|
|
|
|
pub fn refresh(&mut self) -> Result<()> {
|
|
self.location = u16::from_le_bytes(self.read_data(Self::LOCATION_OFFSET));
|
|
self.gil = u32::from_le_bytes(self.read_data(Self::GIL_OFFSET));
|
|
self.steps = u32::from_le_bytes(self.read_data(Self::STEPS_OFFSET));
|
|
self.stage = u16::from_le_bytes(self.read_data(Self::STAGE_OFFSET));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn location_name(&self) -> Option<&'static str> {
|
|
crate::util::LOCATIONS.get(&self.location).map(std::ops::Deref::deref)
|
|
}
|
|
}
|