Some improvements

src/sdk/schema_class_field_data.rs

@@ -14,15 +14,15 @@ impl<'a> SchemaClassFieldData<'a> {
     }
 
     pub fn name(&self) -> Result<String> {
-        self.process
-            .read_string(self.process.read_memory::<usize>(self.address)?)
+        let name_ptr = self.process.read_memory::<usize>(self.address)?;
+
+        self.process.read_string(name_ptr)
     }
 
     pub fn r#type(&self) -> Result<SchemaType> {
-        Ok(SchemaType::new(
-            self.process,
-            self.process.read_memory::<usize>(self.address + 0x8)?,
-        ))
+        let type_ptr = self.process.read_memory::<usize>(self.address + 0x8)?;
+
+        Ok(SchemaType::new(self.process, type_ptr))
     }
 
     pub fn offset(&self) -> Result<u16> {

src/sdk/schema_class_info.rs

@@ -14,7 +14,7 @@ impl<'a> SchemaClassInfo<'a> {
         Self {
             process,
             address,
-            class_name: class_name.into(),
+            class_name: class_name.to_string(),
         }
     }
 
@@ -26,15 +26,16 @@ impl<'a> SchemaClassInfo<'a> {
     pub fn fields(&self) -> Result<Vec<SchemaClassFieldData>> {
         let count = self.fields_count()?;
 
-        let fields: Vec<SchemaClassFieldData> = (0..count as usize)
-            .filter_map(|i| {
-                let address = self
-                    .process
-                    .read_memory::<usize>(self.address + 0x28)
-                    .ok()?
-                    + (i * 0x20);
+        let base_address = self.process.read_memory::<usize>(self.address + 0x28)?;
 
-                (address != 0).then(|| SchemaClassFieldData::new(self.process, address))
+        let fields: Vec<SchemaClassFieldData> = (0..count as usize)
+            .map(|i| base_address + (i * 0x20))
+            .filter_map(|address| {
+                if address != 0 {
+                    Some(SchemaClassFieldData::new(self.process, address))
+                } else {
+                    None
+                }
             })
             .collect();
 

src/sdk/schema_system.rs

@@ -1,3 +1,5 @@
+use std::mem;
+
 use crate::error::Result;
 use crate::remote::Process;
 
@@ -15,7 +17,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_rip(address)?;
+        address = process.resolve_rip(address, None, None)?;
 
         Ok(Self { process, address })
     }
@@ -29,7 +31,7 @@ impl<'a> SchemaSystem<'a> {
         self.process.read_memory_raw(
             data,
             addresses.as_mut_ptr() as *mut _,
-            addresses.len() * std::mem::size_of::<usize>(),
+            addresses.len() * mem::size_of::<usize>(),
         )?;
 
         let type_scopes: Vec<SchemaSystemTypeScope> = addresses

src/sdk/schema_system_type_scope.rs

@@ -22,12 +22,14 @@ impl<'a> SchemaSystemTypeScope<'a> {
             .elements(self.process)?
             .iter()
             .filter_map(|&address| {
-                let declared_class = SchemaTypeDeclaredClass::new(self.process, address as usize);
+                let address = address as usize;
+
+                let declared_class = SchemaTypeDeclaredClass::new(self.process, address);
 
                 declared_class
                     .name()
                     .ok()
-                    .map(|name| SchemaClassInfo::new(self.process, address as usize, &name))
+                    .map(|name| SchemaClassInfo::new(self.process, address, &name))
             })
             .collect();
 

src/sdk/schema_type.rs

@@ -1,6 +1,37 @@
+use std::collections::HashMap;
+
+use lazy_static::lazy_static;
+
+use regex::Regex;
+
 use crate::error::Result;
 use crate::remote::Process;
 
+const TYPE_MAP: &[(&'static str, &'static str)] = &[
+    ("uint8", "uint8_t"),
+    ("uint16", "uint16_t"),
+    ("uint32", "uint32_t"),
+    ("uint64", "uint64_t"),
+    ("int8", "int8_t"),
+    ("int16", "int16_t"),
+    ("int32", "int32_t"),
+    ("int64", "int64_t"),
+    ("float32", "float"),
+    ("float64", "double"),
+];
+
+lazy_static! {
+    static ref REGEX_MAP: HashMap<&'static str, Regex> = {
+        let mut map = HashMap::with_capacity(TYPE_MAP.len());
+
+        for (k, _v) in TYPE_MAP.iter() {
+            map.insert(*k, Regex::new(&format!(r"\b{}\b", k)).unwrap());
+        }
+
+        map
+    };
+}
+
 pub struct SchemaType<'a> {
     process: &'a Process,
     address: usize,
@@ -12,7 +43,26 @@ impl<'a> SchemaType<'a> {
     }
 
     pub fn name(&self) -> Result<String> {
-        self.process
-            .read_string(self.process.read_memory::<usize>(self.address + 0x8)?)
+        let name_ptr = self.process.read_memory::<usize>(self.address + 0x8)?;
+
+        let name = self
+            .process
+            .read_string(name_ptr)?
+            .replace(" ", "")
+            .to_string();
+
+        Ok(Self::convert_type_name(&name))
+    }
+
+    fn convert_type_name(type_name: &str) -> String {
+        let mut result = type_name.to_string();
+
+        for (k, v) in TYPE_MAP.iter() {
+            let re = REGEX_MAP.get(*k).unwrap();
+
+            result = re.replace_all(&result, &v.to_string()).to_string();
+        }
+
+        result
     }
 }

src/sdk/schema_type_declared_class.rs

@@ -12,7 +12,8 @@ impl<'a> SchemaTypeDeclaredClass<'a> {
     }
 
     pub fn name(&self) -> Result<String> {
-        self.process
-            .read_string(self.process.read_memory::<usize>(self.address + 0x8)?)
+        let name_ptr = self.process.read_memory::<usize>(self.address + 0x8)?;
+
+        self.process.read_string(name_ptr)
     }
 }