Fetch localPlayerPawn

src/config.rs

@@ -1,13 +1,21 @@
 use serde::{Deserialize, Serialize};
 
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum Operation {
+    Add { value: usize },
+    Dereference { times: Option<u16> },
+    Jmp,
+    RipRelative,
+    Subtract { value: usize },
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Signature {
     pub name: String,
     pub module: String,
     pub pattern: String,
-    pub relative: bool,
-    pub levels: i32,
-    pub offset: i32,
+    pub operations: Vec<Operation>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

src/dumpers/interfaces.rs

@@ -15,7 +15,7 @@ pub fn dump_interfaces(builders: &mut Vec<FileBuilderEnum>, process: &Process) -
         log::info!("Dumping interfaces in {}...", module_name);
 
         if let Some(create_interface_export) = module.export("CreateInterface") {
-            let create_interface_address = process.resolve_relative(create_interface_export.va)?;
+            let create_interface_address = process.resolve_rip(create_interface_export.va)?;
 
             let mut interface_registry = process
                 .read_memory::<usize>(create_interface_address)

src/dumpers/offsets.rs

@@ -1,7 +1,7 @@
 use std::fs::File;
 
 use crate::builder::FileBuilderEnum;
-use crate::config::Config;
+use crate::config::{Config, Operation};
 use crate::error::{Error, Result};
 use crate::remote::Process;
 
@@ -21,18 +21,28 @@ pub fn dump_offsets(builders: &mut Vec<FileBuilderEnum>, process: &Process) -> R
 
         let mut address = process.find_pattern(&signature.module, &signature.pattern)?;
 
-        if signature.relative {
-            address = process.resolve_relative(address)?;
-        }
-
-        if signature.levels > 0 {
-            for _ in 0..signature.levels {
-                address = process.read_memory::<usize>(address)?;
+        for operation in signature.operations {
+            match operation {
+                Operation::Add { value } => {
+                    address += value;
+                }
+                Operation::Dereference { times } => {
+                    for _ in 0..times.unwrap_or(1) {
+                        address = process.read_memory::<usize>(address)?;
+                    }
+                }
+                Operation::Jmp => {
+                    address = process.resolve_jmp(address)?;
+                }
+                Operation::RipRelative => {
+                    address = process.resolve_rip(address)?;
+                }
+                Operation::Subtract { value } => {
+                    address -= value;
+                }
             }
         }
 
-        address += signature.offset as usize;
-
         log::info!(
             "  -> Found '{}' @ {:#X} (RVA: {:#X})",
             signature.name,

src/remote/process.rs

@@ -175,7 +175,7 @@ impl Process {
         Ok((address + 0x5) + displacement as usize)
     }
 
-    pub fn resolve_relative(&self, address: usize) -> Result<usize> {
+    pub fn resolve_rip(&self, address: usize) -> Result<usize> {
         let displacement = self.read_memory::<i32>(address + 0x3)?;
 
         Ok((address + 0x7) + displacement as usize)

src/sdk/schema_system.rs

@@ -15,7 +15,7 @@ impl<'a> SchemaSystem<'a> {
             "48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 83 EC 28"
         )?;
 
-        address = process.resolve_relative(address)?;
+        address = process.resolve_rip(address)?;
 
         Ok(Self { process, address })
     }