refactor: restructured library

Author: notpoiu

.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
+offset_finder.py
 **/__pycache__/

data/offsets.json

@@ -1,4 +1,5 @@
 {
     "Text": "0xC10",
-    "Character": "0x328"
+    "Character": "0x328",
+    "CFrame": "0x128"
 }

example.py

@@ -11,6 +11,8 @@
     print("Failed to get data model")
     exit()
 
+LocalPlayer = game.Players.LocalPlayer
+
 # Print some info about the game
 print("RobloxMemoryAPI Demo:")
 print("A External Roblox Memory Reader")
@@ -19,7 +21,11 @@
 print("GameID:", game.GameId)
 print("JobId:", game.JobId)
 print("==============================")
-print("Player Name:", game.Players.LocalPlayer.Name)
-print("Player Character Parent:", game.Players.LocalPlayer.Character.Parent.Name)
+print("Player Name:", LocalPlayer.Name)
+print("Player Character Parent:", LocalPlayer.Character.HumanoidRootPart.GetFullName())
 print("Player Count:", len(game.Players.GetPlayers()))
-print("==============================")
+print("==============================")
+
+# 1.0511624813079834, 2.9980251789093018, -1.8010846376419067
+print("Player Position:", LocalPlayer.Character.HumanoidRootPart.Position)
+print("Player HRP Size:", LocalPlayer.Character.HumanoidRootPart.Size)

robloxmemoryapi.py

@@ -1,5 +1,5 @@
 from utils.memory import EvasiveProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ, get_pid_by_name
-from utils.rbxinstance import DataModel
+from utils.rbx.instance import DataModel
 import platform
 
 if platform.system() != "Windows":

utils/memory.py

@@ -226,6 +226,23 @@ def read_float(self, address: int) -> float:
             return struct.unpack('<f', float_bytes)[0] if len(float_bytes) == 4 else 0.0
         except (OSError, struct.error):
             return 0.0
+    
+    def read_floats(self, address: int, amount: int):
+        try:
+            bulk_float_bytes = self.read(address, 4 * amount)
+            floats = []
+            for i in range(amount):
+                start_range = i * 4
+                float_bytes = bulk_float_bytes[start_range:start_range + 4]
+                if len(float_bytes) == 4:
+                    floats.append(struct.unpack('<f', float_bytes)[0])
+                else:
+                    floats.append(0.0)
+
+            return floats
+        except (OSError, struct.error) as e:
+            print(e)
+            return [0.0]
 
     # bool #
     def read_bool(self, address: int) -> bool:

utils/offsets.py

@@ -0,0 +1,17 @@
+import json, requests
+
+OffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
+Offsets = OffsetsRequest.json()
+
+for key in Offsets:
+    try:
+        Offsets[key] = int(Offsets[key], 16)
+    except (ValueError, TypeError):
+        pass
+
+with open("data/offsets.json", "r") as f:
+    LoadedOffsets = json.load(f)
+    f.close()
+
+for key in LoadedOffsets:
+    Offsets[key] = int(LoadedOffsets[key], 16)

utils/rbx/datastructures.py

@@ -0,0 +1,36 @@
+class UDim2:
+    def __init__(self, scaleX, offsetX, scaleY, offsetY):
+        self.X = {
+            ["Offset"]: offsetX,
+            ["Scale"]: scaleX
+        }
+
+        self.Y = {
+            ["Offset"]: offsetY,
+            ["Scale"]: scaleY
+        }
+
+        self.Width = self.X
+        self.Height = self.Y
+    
+    def __str__(self):
+        return f"{{{self.X.Scale}, {self.X.Offset}}}, {{{self.Y.Scale}, {self.Y.Offset}}}"
+
+    def fromScale(scaleX, scaleY):
+        return UDim2(scaleX, 0, scaleY, 0)
+    
+    def fromOffset(offsetX, offsetY):
+        return UDim2(0, offsetX, 0, offsetY)
+
+class Vector3:
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+    
+    def __str__(self):
+        return f"{self.x}, {self.y}, {self.z}"
+    
+    def __eq__(self, vector):
+        if isinstance(vector, Vector3):
+            return vector.x == self.x and vector.y == self.y and vector.z == self.y

utils/rbxinstance.py utils/rbx/instance.pyutils/rbxinstance.py renamed to utils/rbx/instance.py

@@ -1,37 +1,30 @@
-import requests
+from ..offsets import *
 import time
-import json
-
-OffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
-Offsets = OffsetsRequest.json()
-
-for key in Offsets:
-    try:
-        Offsets[key] = int(Offsets[key], 16)
-    except (ValueError, TypeError):
-        pass
-
-with open("data/offsets.json", "r") as f:
-    LoadedOffsets = json.load(f)
-    f.close()
-
-for key in LoadedOffsets:
-    Offsets[key] = int(LoadedOffsets[key], 16)
+from utils.rbx.datastructures import *
 
 class RBXInstance:
     def __init__(self, address, memory_module):
         self.raw_address = address
         self.memory_module = memory_module
 
-    # props #
-    @property
-    def parent_address(self):
-        return self.raw_address + Offsets["Parent"]
+    def __eq__(self, value):
+        return value.raw_address == self.raw_address
+    
+    def __getattr__(self, key):
+        return self.FindFirstChild(key)
 
+    # props #
     @property
     def Parent(self):
         parent_pointer = int.from_bytes(self.memory_module.read(self.raw_address + Offsets["Parent"], 8), 'little')
-        return RBXInstance(parent_pointer, self.memory_module)
+        instance = RBXInstance(parent_pointer, self.memory_module)
+
+        try:
+            thing = instance.ClassName
+        except Exception as e:
+            return None
+
+        return instance
 
     @property
     def Name(self):
@@ -51,39 +44,37 @@ def ClassName(self):
         )
         return self.memory_module.read_string(class_name_address)
 
-    # frame properties #
     @property
     def Position(self):
-        try:
-            x = self.memory_module.read_float(self.raw_address + Offsets["FramePositionX"])
-            x_offset = self.memory_module.read_int(self.raw_address + Offsets["FramePositionOffsetX "])
-
-            y = self.memory_module.read_float(self.raw_address + Offsets["FramePositionY"])
-            y_offset = self.memory_module.read_int(self.raw_address + Offsets["FramePositionOffsetY"])
-
-            return (x, x_offset, y, y_offset)
-        except (KeyError, OSError) as e:
-            print(f"Error reading position: {e}")
-            return (0.0, 0, 0.0, 0)
+        if "part" in self.ClassName.lower():
+            position_vector3 = self.memory_module.read_floats(self.raw_address + Offsets["Position"], 3)
+            return Vector3(*position_vector3)
+        else:
+            try:
+                x = self.memory_module.read_float(self.raw_address + Offsets["FramePositionX"])
+                x_offset = self.memory_module.read_int(self.raw_address + Offsets["FramePositionOffsetX "])
+
+                y = self.memory_module.read_float(self.raw_address + Offsets["FramePositionY"])
+                y_offset = self.memory_module.read_int(self.raw_address + Offsets["FramePositionOffsetY"])
+
+                return UDim2(x, x_offset, y, y_offset)
+            except (KeyError, OSError) as e:
+                print(f"Error reading position: {e}")
+                return (0.0, 0, 0.0, 0)
 
     @property
     def Size(self):
-        try:
-            x = self.memory_module.read_float(self.raw_address + Offsets["FrameSizeX"])
-            y = self.memory_module.read_float(self.raw_address + Offsets["FrameSizeY"])
-            return (x, y)
-        except (KeyError, OSError) as e:
-            print(f"Error reading position: {e}")
-            return (0.0, 0.0)
-
-    """@property
-    def ScreenPosition(self):
-        udim2_x_scale, udim2_y_scale, udim2_x_offset, udim2_y_offset = self.Position
-        
-        real_x = (udim2_x_scale * SCREEN_WIDTH) + udim2_x_offset
-        real_y = (udim2_y_scale * SCREEN_HEIGHT) + udim2_y_offset
-
-        return (real_x, real_y)"""
+        if "part" in self.ClassName.lower():
+            size_vector3 = self.memory_module.read_floats(self.raw_address + Offsets["PartSize"], 3)
+            return Vector3(*size_vector3)
+        else:
+            try:
+                x = self.memory_module.read_float(self.raw_address + Offsets["FrameSizeX"])
+                y = self.memory_module.read_float(self.raw_address + Offsets["FrameSizeY"])
+                return (x, y)
+            except (KeyError, OSError) as e:
+                print(f"Error reading position: {e}")
+                return (0.0, 0.0)
 
     # XXXXValue props #
     @property
@@ -103,8 +94,7 @@ def Value(self):
     # text props #
     @property
     def Text(self):
-        classname = self.ClassName 
-        if classname == "TextLabel":
+        if "text" in self.ClassName.lower():
             return self.memory_module.read_string(self.raw_address + Offsets["Text"])
 
         return None
@@ -129,6 +119,30 @@ def GetChildren(self):
 
         return children
 
+    def GetFullName(self):
+        if self.ClassName == "DataModel":
+            return self.Name
+
+        ObjectPointer = self
+        ObjectPath = self.Name
+
+        while True:
+            if ObjectPointer.Parent.ClassName == "DataModel":
+                break
+            
+            ObjectPointer = ObjectPointer.Parent
+            ObjectPath = f"{ObjectPointer.Name}." + ObjectPath
+        
+        return ObjectPath
+
+    def GetDescendants(self):
+        descendants = []
+        for child in self.GetChildren():
+            descendants.append(child)
+            descendants.extend(child.GetDescendants())
+        return descendants
+
+
     def FindFirstChild(self, name, recursive=False):
         try:
             children = self.GetChildren()