robloxmemoryapi 0.0.1__py3-none-any.whl

robloxmemoryapi/__init__.py

@@ -0,0 +1,87 @@
+import platform
+import math
+
+__all__ = ["RobloxRandom", "RobloxGameClient", "__version__"]
+__version__ = "0.1.0"
+
+
+class RobloxRandom:
+    MULT = 6364136223846793005
+    INC = 105
+    MASK64 = (1 << 64) - 1
+
+    def __init__(self, seed):
+        s = math.floor(seed)
+
+        self._state = 0
+        self._inc = RobloxRandom.INC
+        self._next_internal()         # warm-up #1
+        self._state = (self._state + s) & RobloxRandom.MASK64
+        self._next_internal()         # warm-up #2
+
+    def _next_internal(self):
+        old = self._state
+        self._state = (old * RobloxRandom.MULT + self._inc) & RobloxRandom.MASK64
+        x = ((old >> 18) ^ old) >> 27
+        r = old >> 59
+        return ((x >> r) | (x << ((32 - r) & 31))) & 0xFFFFFFFF
+
+    def _next_fraction64(self):
+        lo = self._next_internal()
+        hi = self._next_internal()
+        bits = (hi << 32) | lo
+        return bits / 2**64
+
+    def NextNumber(self, minimum=0.0, maximum=1.0):
+        frac = self._next_fraction64()
+        return minimum + frac * (maximum - minimum)
+
+    def NextInteger(self, a, b=None):
+        if b is None:
+            u = a
+            r = self._next_internal()
+            return ((u * r) >> 32) + 1
+        else:
+            lo, hi = (a, b) if a <= b else (b, a)
+            u = hi - lo + 1
+            r = self._next_internal()
+            return ((u * r) >> 32) + lo
+
+
+class RobloxGameClient:
+    def __init__(self, pid: int = None, process_name: str = "RobloxPlayerBeta.exe"):
+        if platform.system() != "Windows":
+            self.failed = True
+            return
+
+        from .utils.memory import (
+            EvasiveProcess,
+            PROCESS_QUERY_INFORMATION,
+            PROCESS_VM_READ,
+            get_pid_by_name,
+        )
+
+        if pid is None:
+            self.pid = get_pid_by_name(process_name)
+        else:
+            self.pid = pid
+
+        if self.pid is None or self.pid == 0:
+            raise ValueError("Failed to get PID.")
+
+        self.memory_module = EvasiveProcess(self.pid, PROCESS_VM_READ | PROCESS_QUERY_INFORMATION)
+        self.failed = False
+
+    def close(self):
+        self.memory_module.close()
+
+    @property
+    def DataModel(self):
+        if platform.system() != "Windows":
+            raise RuntimeError("This module is only compatible with Windows.")
+        elif self.failed:
+            raise RuntimeError("There was an error while getting access to memory. Please try again later.")
+
+        from .utils.rbx.instance import DataModel
+        return DataModel(self.memory_module)
+

robloxmemoryapi/data/offsets.json

@@ -0,0 +1,6 @@
+{
+    "Text": "0xC10",
+    "Character": "0x328",
+    "PrimaryPart": "0x268"
+}
+

robloxmemoryapi/utils/__init__.py

@@ -0,0 +1,2 @@
+# Utility subpackage for memory access and offsets
+

robloxmemoryapi/utils/memory.py

@@ -0,0 +1,275 @@
+import ctypes
+import struct
+from ctypes import wintypes
+
+ntdll = ctypes.WinDLL('ntdll.dll')
+psapi = ctypes.WinDLL('psapi.dll')
+kernel32 = ctypes.WinDLL('kernel32.dll')
+
+kernel32.VirtualAlloc.restype = wintypes.LPVOID
+kernel32.VirtualAlloc.argtypes = [wintypes.LPVOID, ctypes.c_size_t, wintypes.DWORD, wintypes.DWORD]
+kernel32.GetProcAddress.restype = wintypes.LPVOID
+kernel32.GetProcAddress.argtypes = [wintypes.HMODULE, wintypes.LPCSTR]
+
+NTSTATUS = wintypes.LONG
+HANDLE = wintypes.HANDLE
+DWORD = wintypes.DWORD
+LPVOID = wintypes.LPVOID
+HMODULE = wintypes.HMODULE
+BOOL = wintypes.BOOL
+
+PROCESS_QUERY_INFORMATION = 0x0400
+PROCESS_VM_READ = 0x0010
+LIST_MODULES_ALL = 0x03
+STATUS_SUCCESS = 0
+MEM_COMMIT = 0x1000
+MEM_RESERVE = 0x2000
+PAGE_EXECUTE_READWRITE = 0x40
+NTDLL_HANDLE = ntdll._handle
+
+class CLIENT_ID(ctypes.Structure):
+    _fields_ = [
+        ("UniqueProcess", HANDLE),
+        ("UniqueThread", HANDLE),
+    ]
+
+class OBJECT_ATTRIBUTES(ctypes.Structure):
+    _fields_ = [
+        ("Length", wintypes.ULONG),
+        ("RootDirectory", HANDLE),
+        ("ObjectName", LPVOID),
+        ("Attributes", wintypes.ULONG),
+        ("SecurityDescriptor", LPVOID),
+        ("SecurityQualityOfService", LPVOID),
+    ]
+
+def get_syscall_number(function_name: str) -> int | None:
+    func_address = kernel32.GetProcAddress(NTDLL_HANDLE, function_name.encode('ascii'))
+    if not func_address:
+        return None
+    buffer = (ctypes.c_ubyte * 8).from_address(func_address)
+    if tuple(buffer[0:4]) == (0x4c, 0x8b, 0xd1, 0xb8):
+        return int.from_bytes(bytes(buffer[4:8]), 'little')
+    return None
+
+def create_syscall_function(syscall_number, func_prototype):
+    assembly_stub = b'\x4C\x8B\xD1' + \
+                    b'\xB8' + syscall_number.to_bytes(4, 'little') + \
+                    b'\x0F\x05' + \
+                    b'\xC3'
+
+    exec_mem = kernel32.VirtualAlloc(None, len(assembly_stub), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE)
+    if not exec_mem:
+        raise ctypes.WinError(ctypes.get_last_error())
+    ctypes.memmove(exec_mem, assembly_stub, len(assembly_stub))
+    return func_prototype(exec_mem)
+
+NtOpenProcessProto = ctypes.WINFUNCTYPE(
+    NTSTATUS,
+    ctypes.POINTER(HANDLE),
+    DWORD,
+    ctypes.POINTER(OBJECT_ATTRIBUTES),
+    ctypes.POINTER(CLIENT_ID)
+)
+NtReadVirtualMemoryProto = ctypes.WINFUNCTYPE(
+    NTSTATUS,
+    HANDLE,
+    LPVOID,
+    LPVOID,
+    ctypes.c_ulong,
+    ctypes.POINTER(ctypes.c_ulong)
+)
+NtCloseProto = ctypes.WINFUNCTYPE(NTSTATUS, HANDLE)
+
+syscall_id_open = get_syscall_number("NtOpenProcess")
+syscall_id_read = get_syscall_number("NtReadVirtualMemory")
+syscall_id_close = get_syscall_number("NtClose")
+
+if not all([syscall_id_open, syscall_id_read, syscall_id_close]):
+    raise RuntimeError("Could not find required syscall numbers.")
+
+nt_open_process_syscall = create_syscall_function(syscall_id_open, NtOpenProcessProto)
+nt_read_virtual_memory_syscall = create_syscall_function(syscall_id_read, NtReadVirtualMemoryProto)
+nt_close_syscall = create_syscall_function(syscall_id_close, NtCloseProto)
+
+psapi.EnumProcessModulesEx.argtypes = [
+    HANDLE,
+    ctypes.POINTER(HMODULE),
+    DWORD,
+    ctypes.POINTER(DWORD),
+    DWORD
+]
+psapi.EnumProcessModulesEx.restype = BOOL
+
+def _get_module_base(process_handle: HANDLE) -> int:
+    try:
+        modules_arr_size = 256
+        modules_arr = (HMODULE * modules_arr_size)()
+        needed = DWORD(0)
+        psapi.EnumProcessModulesEx(
+            process_handle,
+            modules_arr,
+            ctypes.sizeof(modules_arr),
+            ctypes.byref(needed),
+            LIST_MODULES_ALL
+        )
+        if needed.value > ctypes.sizeof(modules_arr):
+            new_size = needed.value // ctypes.sizeof(HMODULE)
+            modules_arr = (HMODULE * new_size)()
+            success = psapi.EnumProcessModulesEx(
+                process_handle,
+                modules_arr,
+                ctypes.sizeof(modules_arr),
+                ctypes.byref(needed),
+                LIST_MODULES_ALL
+            )
+            if not success:
+                return 0
+        if needed.value > 0:
+            return modules_arr[0] if modules_arr[0] else 0
+        return 0
+    except Exception as e:
+        print(f"An exception occurred in _get_module_base: {e}")
+        return 0
+   
+def get_pid_by_name(process_name: str) -> int:
+    class PROCESSENTRY32(ctypes.Structure):
+        _fields_ = [
+            ("dwSize", DWORD),
+            ("cntUsage", DWORD),
+            ("th32ProcessID", DWORD),
+            ("th32DefaultHeapID", ctypes.POINTER(wintypes.ULONG)),
+            ("th32ModuleID", DWORD),
+            ("cntThreads", DWORD),
+            ("th32ParentProcessID", DWORD),
+            ("pcPriClassBase", wintypes.LONG),
+            ("dwFlags", DWORD),
+            ("szExeFile", wintypes.CHAR * 260)
+        ]
+    snapshot = kernel32.CreateToolhelp32Snapshot(2, 0)
+    if not snapshot or snapshot == wintypes.HANDLE(-1).value:
+        raise ctypes.WinError()
+    entry = PROCESSENTRY32()
+    entry.dwSize = ctypes.sizeof(PROCESSENTRY32)
+    try:
+        if not kernel32.Process32First(snapshot, ctypes.byref(entry)):
+            return 0
+        while True:
+            if entry.szExeFile.decode('utf-8', errors='ignore') == process_name:
+                return entry.th32ProcessID
+            if not kernel32.Process32Next(snapshot, ctypes.byref(entry)):
+                break
+    finally:
+        kernel32.CloseHandle(snapshot)
+    return 0
+
+class EvasiveProcess:
+    def __init__(self, pid: int, access: DWORD):
+        self.pid = pid
+        self.access = access
+        self.handle = HANDLE(0)
+        self.base = 0
+
+        object_attributes = OBJECT_ATTRIBUTES()
+        client_id = CLIENT_ID()
+        client_id.UniqueProcess = HANDLE(pid)
+        object_attributes.Length = ctypes.sizeof(OBJECT_ATTRIBUTES)
+
+        status = nt_open_process_syscall(
+            ctypes.byref(self.handle),
+            access,
+            ctypes.byref(object_attributes),
+            ctypes.byref(client_id)
+        )
+        if status != STATUS_SUCCESS:
+            raise ctypes.WinError(f"NtOpenProcess failed with NTSTATUS: 0x{status:X}")
+        self.base = _get_module_base(self.handle)
+        if self.base == 0:
+            self.close()
+            raise ConnectionError("Failed to get module base address.")
+
+    def read(self, address: int, size: int) -> bytes:
+        if not self.handle or self.handle.value == 0:
+            raise ValueError("Process handle is not valid.")
+        buffer = ctypes.create_string_buffer(size)
+        bytes_read = ctypes.c_ulong(0)
+        status = nt_read_virtual_memory_syscall(
+            self.handle,
+            LPVOID(address),
+            buffer,
+            size,
+            ctypes.byref(bytes_read)
+        )
+        if status != STATUS_SUCCESS:
+            raise OSError(f"NtReadVirtualMemory failed with NTSTATUS: 0x{status:X}")
+        return buffer.raw[:bytes_read.value]
+
+    # numbers #
+    def read_int(self, address: int) -> int:
+        buffer = self.read(address, 4)
+        return int.from_bytes(buffer, 'little') if len(buffer) == 4 else 0
+        
+    def read_long(self, address: int) -> int:
+        buffer = self.read(address, 8)
+        return int.from_bytes(buffer, 'little') if len(buffer) == 8 else 0
+    
+    def read_double(self, address: int) -> float:
+        try:
+            double_bytes = self.read(address, 8)
+            return struct.unpack('<d', double_bytes)[0] if len(double_bytes) == 8 else 0.0
+        except (OSError, struct.error):
+            return 0.0
+
+    def read_float(self, address: int) -> float:
+        try:
+            float_bytes = self.read(address, 4)
+            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:
+            return [0.0]
+
+    # bool #
+    def read_bool(self, address: int) -> bool:
+        try:
+            bool_byte = self.read(address, 1)
+            if not bool_byte: return False
+            return bool(int.from_bytes(bool_byte, 'little'))
+        except OSError:
+            return False
+
+    # string #
+    def read_raw_string(self, address: int, max_length: int = 256) -> str:
+        buffer = self.read(address, max_length)
+        null_pos = buffer.find(b'\x00')
+        valid_bytes = buffer[:null_pos] if null_pos != -1 else buffer
+        return valid_bytes.decode('utf-8', errors='ignore')
+        
+    def read_string(self, address: int) -> str:
+        string_length = self.read_int(address + 0x10)
+        if string_length <= 15:
+            return self.read_raw_string(address, string_length)
+        else:
+            string_data_pointer = self.read_long(address)
+            return self.read_raw_string(string_data_pointer, string_length) if string_data_pointer else ""
+    
+    #########
+    def close(self):
+        if self.handle and self.handle.value != 0:
+            nt_close_syscall(self.handle)
+            self.handle = HANDLE(0)

robloxmemoryapi/utils/offsets.py

@@ -0,0 +1,46 @@
+import json
+import requests
+from importlib import resources
+
+Offsets = {}
+def ParseOffsets(*DataSources):
+    for _, Data in enumerate(DataSources, start=1):
+        for OffsetName in Data:
+            try:
+                FormattedOffsetName = OffsetName.replace(" ", "")
+                OffsetHexadecimalValue = Data[OffsetName]
+
+                Offsets[FormattedOffsetName] = int(OffsetHexadecimalValue, 16)
+            except (ValueError, TypeError):
+                pass
+
+
+OffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
+
+try:
+    LoadedOffsetsRequest = requests.get(
+        "https://raw.githubusercontent.com/notpoiu/RobloxMemoryAPI/refs/heads/main/src/robloxmemoryapi/data/offsets.json"
+    )
+    LoadedOffsetsRequest.raise_for_status()
+
+    LoadedOffsets = LoadedOffsetsRequest.json()
+except Exception:
+    try:
+        with resources.files("robloxmemoryapi.data").joinpath("offsets.json").open("r", encoding="utf-8") as f:
+            LoadedOffsets = json.load(f)
+    except Exception:
+        # Fallback defaults
+        LoadedOffsets = {
+            "Text": "0xC10",
+            "Character": "0x328",
+            "PrimaryPart": "0x268",
+        }
+
+ParseOffsets(LoadedOffsets, OffsetsRequest.json())
+
+# CFrame Offsets
+RotationMatriciesLengthBytes = 3 * 3 * 4
+
+Offsets["CameraCFrame"] = Offsets["CameraPos"] - RotationMatriciesLengthBytes
+Offsets["CFrame"] = Offsets["Position"] - RotationMatriciesLengthBytes
+

robloxmemoryapi/utils/rbx/datastructures.py

@@ -0,0 +1,266 @@
+import math
+
+def get_flat_matrix_column(matrix, column, invert_values=False):
+    stride = 3
+
+    if invert_values:
+        return [matrix[column + i * stride] * -1 for i in range(3)]
+    
+    return [matrix[column + i * stride] for i in range(3)]
+
+class UDim:
+    def __init__(self, scale=0, offset=0):
+        self.Scale = float(scale)
+        self.Offset = int(offset)
+
+    def __repr__(self):
+        return f"{{{self.Scale}, {self.Offset}}}"
+
+class UDim2:
+    def __init__(self, scaleX=0, offsetX=0, scaleY=0, offsetY=0):
+        self.X = UDim(scaleX, offsetX)
+        self.Y = UDim(scaleY, offsetY)
+
+    def __repr__(self):
+        return f"{{{self.X}, {self.Y}}}"
+
+    @classmethod
+    def fromScale(cls, scaleX, scaleY):
+        return cls(scaleX, 0, scaleY, 0)
+
+    @classmethod
+    def fromOffset(cls, offsetX, offsetY):
+        return cls(0, offsetX, 0, offsetY)
+
+class Vector2:
+    def __init__(self, x=0, y=0):
+        self.X = float(x)
+        self.Y = float(y)
+
+    def __repr__(self):
+        return f"{self.X}, {self.Y}"
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Vector2)
+            and self.X == other.X
+            and self.Y == other.Y
+        )
+
+class Vector3:
+    def __init__(self, x=0, y=0, z=0):
+        self.X = float(x)
+        self.Y = float(y)
+        self.Z = float(z)
+
+    def __repr__(self):
+        return f"{self.X}, {self.Y}, {self.Z}"
+
+    def __eq__(self, other):
+        eps = 1e-9
+
+        return (
+            isinstance(other, Vector3)
+            and abs(self.X - other.X) < eps
+            and abs(self.Y - other.Y) < eps
+            and abs(self.Z - other.Z) < eps
+        )
+    
+    # --- Arithmetic ---
+    def __add__(self, other):
+        if isinstance(other, Vector3):
+            return Vector3(self.X + other.X, self.Y + other.Y, self.Z + other.Z)
+        raise TypeError("Vector3 can only be added to Vector3")
+
+    def __sub__(self, other):
+        if isinstance(other, Vector3):
+            return Vector3(self.X - other.X, self.Y - other.Y, self.Z - other.Z)
+        raise TypeError("Vector3 can only be subtracted by Vector3")
+
+    def __mul__(self, other):
+        if isinstance(other, (int, float)):
+            return Vector3(self.X * other, self.Y * other, self.Z * other)
+        if isinstance(other, Vector3):
+            return Vector3(self.X * other.X, self.Y * other.Y, self.Z * other.Z)
+        raise TypeError("Vector3 can only be multiplied by Vector3 or a number")
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other):
+        if isinstance(other, (int, float)):
+            return Vector3(self.X / other, self.Y / other, self.Z / other)
+        if isinstance(other, Vector3):
+            return Vector3(self.X / other.X, self.Y / other.Y, self.Z / other.Z)
+        raise TypeError("Vector3 can only be divided by Vector3 or a number")
+
+    def __neg__(self):
+        return Vector3(-self.X, -self.Y, -self.Z)
+
+    # --- Vector math ---
+    def Dot(self, other):
+        return self.X * other.X + self.Y * other.Y + self.Z * other.Z
+
+    def Cross(self, other):
+        return Vector3(
+            self.Y * other.Z - self.Z * other.Y,
+            self.Z * other.X - self.X * other.Z,
+            self.X * other.Y - self.Y * other.X,
+        )
+
+    def Magnitude(self):
+        return math.sqrt(self.X**2 + self.Y**2 + self.Z**2)
+
+    def Unit(self):
+        m = self.Magnitude()
+        return Vector3(self.X / m, self.Y / m, self.Z / m) if m != 0 else Vector3()
+
+    def Lerp(self, other, alpha: float):
+        return self + (other - self) * alpha
+
+class CFrame:
+    def __init__(self, position=None, right=None, up=None, look=None):
+        self.Position = position or Vector3(0, 0, 0)
+
+        if right is None and up is None and look is None:
+            self.RightVector = Vector3(1, 0, 0)
+            self.UpVector = Vector3(0, 1, 0)
+            self.LookVector = Vector3(0, 0, -1)
+        else:
+            r, u, l = self._orthonormal_basis(right, up, look)
+            self.RightVector, self.UpVector, self.LookVector = r, u, l
+
+    def __repr__(self):
+        return (
+            f"{self.Position}, {self.RightVector}, {self.UpVector}, {self.LookVector}"
+        )
+
+    @classmethod
+    def new(cls, x=0, y=0, z=0):
+        return cls(position=Vector3(x, y, z))
+
+    # --- Rotation helpers ---
+    def _rotate_vector(self, v: Vector3) -> Vector3:
+        return (
+            self.RightVector * v.X +
+            self.UpVector * v.Y +
+            self.LookVector * v.Z
+        )
+
+    def _inverse_rotate_vector(self, v: Vector3) -> Vector3:
+        # Multiply by transpose of rotation matrix
+        return Vector3(
+            v.Dot(self.RightVector),
+            v.Dot(self.UpVector),
+            v.Dot(self.LookVector)
+        )
+
+    @staticmethod
+    def _orthonormal_basis(right=None, up=None, look=None):
+        def unit(v: Vector3 | None):
+            return v.Unit() if isinstance(v, Vector3) else None
+
+        def nearly_parallel(a: Vector3, b: Vector3) -> bool:
+            ma, mb = a.Magnitude(), b.Magnitude()
+            if ma == 0 or mb == 0:
+                return True
+            return abs(a.Dot(b) / (ma * mb)) > 0.9999
+
+        def orthogonal_to(v: Vector3) -> Vector3:
+            fallback = Vector3(0, 1, 0)
+            if nearly_parallel(v, fallback):
+                fallback = Vector3(1, 0, 0)
+            return (fallback - v * fallback.Dot(v)).Unit()
+
+        r = unit(right)
+        u = unit(up)
+        l = unit(look)
+
+        if r is not None and u is not None:
+            u = (u - r * u.Dot(r)).Unit()
+            l = -r.Cross(u).Unit()
+            return r, u, l
+        
+        if r is not None and l is not None:
+            l = (l - r * l.Dot(r)).Unit()
+            u = l.Cross(r).Unit()
+            return r, u, l
+        
+        if u is not None and l is not None:
+            l = (l - u * l.Dot(l)).Unit()
+            r = l.Cross(u).Unit()
+            return r, u, l
+        
+        if r is not None:
+            u = orthogonal_to(r)
+            l = -r.Cross(u).Unit()
+            return r, u, l
+        
+        if u is not None:
+            r = orthogonal_to(u)
+            l = -r.Cross(u).Unit()
+            return r, u, l
+        
+        if l is not None:
+            u = orthogonal_to(l)
+            r = l.Cross(u).Unit()
+            return r, u, l
+
+        return Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, -1)
+
+    # --- Operators ---
+    def __mul__(self, other):
+        if isinstance(other, CFrame):
+            rotated_pos = self._rotate_vector(other.Position)
+            new_pos = self.Position + rotated_pos
+
+            r = self._rotate_vector(other.RightVector)
+            u = self._rotate_vector(other.UpVector)
+            l = self._rotate_vector(other.LookVector)
+
+            return CFrame(new_pos, r, u, l)
+
+        if isinstance(other, Vector3):
+            return self.Position + self._rotate_vector(other)
+
+        raise TypeError("CFrame can only be multiplied by CFrame or Vector3")
+
+    def __add__(self, other):
+        if isinstance(other, Vector3):
+            return CFrame(self.Position + other,
+                          self.RightVector, self.UpVector, self.LookVector)
+        raise TypeError("CFrame can only be added to Vector3")
+
+    def __sub__(self, other):
+        if isinstance(other, Vector3):
+            return CFrame(self.Position - other,
+                          self.RightVector, self.UpVector, self.LookVector)
+        raise TypeError("CFrame can only be subtracted by Vector3")
+
+    # --- API Methods ---
+    def Inverse(self):
+        # Rotation inverse is transpose
+        r = Vector3(self.RightVector.X, self.UpVector.X, self.LookVector.X)
+        u = Vector3(self.RightVector.Y, self.UpVector.Y, self.LookVector.Y)
+        l = Vector3(self.RightVector.Z, self.UpVector.Z, self.LookVector.Z)
+
+        inv_pos = Vector3(
+            -self.Position.Dot(r),
+            -self.Position.Dot(u),
+            -self.Position.Dot(l),
+        )
+
+        return CFrame(inv_pos, r, u, l)
+
+    def ToWorldSpace(self, cf):
+        return self * cf
+
+    def ToObjectSpace(self, cf):
+        return self.Inverse() * cf
+
+    def GetComponents(self):
+        return tuple([
+            self.RightVector.X, self.UpVector.X, self.LookVector.X,
+            self.RightVector.Y, self.UpVector.Y, self.LookVector.Y,
+            self.RightVector.Z, self.UpVector.Z, self.LookVector.Z,
+            self.Position.X, self.Position.Y, self.Position.Z
+        ])

robloxmemoryapi/utils/rbx/instance.py

@@ -0,0 +1,457 @@
+from ..offsets import *
+import time, math
+from .datastructures import *
+
+# Normal Classes #
+class RBXInstance:
+    def __init__(self, address, memory_module):
+        self.raw_address = address
+        self.memory_module = memory_module
+
+    def __eq__(self, value):
+        return value.raw_address == self.raw_address
+    
+    def __getattr__(self, key):
+        return self.FindFirstChild(key)
+
+    # utilities #
+    @property
+    def primitive_address(self):
+        part_primitive_pointer = self.raw_address + Offsets["Primitive"]
+        part_primitive = int.from_bytes(self.memory_module.read(part_primitive_pointer, 8), 'little')
+        return part_primitive
+
+    # props #
+    @property
+    def Parent(self):
+        parent_pointer = int.from_bytes(self.memory_module.read(self.raw_address + Offsets["Parent"], 8), 'little')
+        if parent_pointer == 0:
+            return None
+        
+        return RBXInstance(parent_pointer, self.memory_module)
+    
+    @property
+    def Name(self):
+        name_address_pointer = self.raw_address + Offsets["Name"]
+        name_address = int.from_bytes(self.memory_module.read(name_address_pointer, 8), 'little')
+        return self.memory_module.read_string(name_address)
+    
+    @property
+    def ClassName(self):
+        class_descriptor_address = int.from_bytes(
+            self.memory_module.read(self.raw_address + Offsets["ClassDescriptor"], 8),
+            'little'
+        )
+        class_name_address = int.from_bytes(
+            self.memory_module.read(class_descriptor_address + Offsets["ClassDescriptorToClassName"], 8),
+            'little'
+        )
+        return self.memory_module.read_string(class_name_address)
+    
+    @property
+    def CFrame(self):
+        className = self.ClassName
+
+        CFrameDataMatriciesLength = 12 # 3x4 matrix
+
+        if "part" in className.lower():
+            CFrameData = self.memory_module.read_floats(self.primitive_address + Offsets["CFrame"], CFrameDataMatriciesLength)
+        elif className == "Camera":
+            CFrameData = self.memory_module.read_floats(self.raw_address + Offsets["CameraCFrame"], CFrameDataMatriciesLength)
+        else:
+            return None
+        
+        RightVectorData = get_flat_matrix_column(CFrameData, 0)
+        UpVectorData = get_flat_matrix_column(CFrameData, 1)
+        LookVectorData = get_flat_matrix_column(CFrameData, 2, invert_values=True)
+        PositionData = CFrameData[9:12]
+
+        return CFrame(
+            Vector3(*PositionData),
+            Vector3(*RightVectorData),
+            Vector3(*UpVectorData),
+            Vector3(*LookVectorData)
+        )
+
+    @property
+    def Position(self):
+        className = self.ClassName
+        if "part" in className.lower():
+            position_vector3 = self.memory_module.read_floats(self.primitive_address + Offsets["Position"], 3)
+            return Vector3(*position_vector3)
+        elif className == "Camera":
+            position_vector3 = self.memory_module.read_floats(self.raw_address + Offsets["CameraPos"], 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):
+        if "part" in self.ClassName.lower():
+            size_vector3 = self.memory_module.read_floats(self.primitive_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
+    def Value(self):
+        classname = self.ClassName 
+        if classname == "StringValue":
+            return self.memory_module.read_string(self.raw_address + Offsets["Value"])
+        
+        elif classname == "IntValue":
+            return self.memory_module.read_int(self.raw_address + Offsets["Value"])
+        
+        elif classname == "NumberValue":
+            return self.memory_module.read_double(self.raw_address + Offsets["Value"])
+        
+        elif classname == "BoolValue":
+            return self.memory_module.read_bool(self.raw_address + Offsets["Value"])
+        
+        elif classname == "ObjectValue":
+            object_pointer = self.raw_address + Offsets["Value"]
+            object_address = int.from_bytes(self.memory_module.read(object_pointer, 8), 'little')
+
+            return RBXInstance(object_address, self.memory_module)
+        
+        return None
+    
+    # text props #
+    @property
+    def Text(self):
+        if "text" in self.ClassName.lower():
+            return self.memory_module.read_string(self.raw_address + Offsets["Text"])
+        
+        return None
+
+    # humanoid props #
+    @property
+    def WalkSpeed(self):
+        if self.ClassName != "Humanoid":
+            return None
+        
+        return self.memory_module.read_float(self.raw_address + Offsets["WalkSpeed"])
+
+    @property
+    def JumpPower(self):
+        if self.ClassName != "Humanoid":
+            return None
+        
+        return self.memory_module.read_float(self.raw_address + Offsets["JumpPower"])
+        
+    @property
+    def Health(self):
+        if self.ClassName != "Humanoid":
+            return None
+        
+        return self.memory_module.read_float(self.raw_address + Offsets["Health"])
+
+    @property
+    def MaxHealth(self):
+        if self.ClassName != "Humanoid":
+            return None
+        
+        return self.memory_module.read_float(self.raw_address + Offsets["MaxHealth"])
+
+    # model props #
+    @property
+    def PrimaryPart(self):
+        if self.ClassName != "Model":
+            return None
+        
+        parent_pointer = int.from_bytes(self.memory_module.read(self.raw_address + Offsets["PrimaryPart"], 8), 'little')
+        if parent_pointer == 0:
+            return None
+
+        return RBXInstance(parent_pointer, self.memory_module)
+    
+    # functions #
+    def GetChildren(self):
+        children = []
+        children_pointer = int.from_bytes(self.memory_module.read(self.raw_address + Offsets["Children"], 8), 'little')
+        
+        if children_pointer == 0:
+            return children
+        
+        children_start = int.from_bytes(self.memory_module.read(children_pointer, 8), 'little')
+        children_end = int.from_bytes(self.memory_module.read(children_pointer + Offsets["ChildrenEnd"], 8), 'little')
+
+        for child_address in range(children_start, children_end, 0x10):
+            child_pointer_bytes = self.memory_module.read(child_address, 8)
+            child_pointer = int.from_bytes(child_pointer_bytes, 'little')
+            
+            if child_pointer != 0:
+                children.append(RBXInstance(child_pointer, self.memory_module))
+        
+        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 FindFirstChildOfClass(self, classname):
+        for child in self.GetChildren():
+            if child.ClassName == classname:
+                return child
+        return None
+
+    def FindFirstChild(self, name, recursive=False):
+        try:
+            children = self.GetChildren()
+            for child in children:
+                if child.Name == name:
+                    return child
+            
+            if recursive:
+                for child in children:
+                    found_descendant = child.FindFirstChild(name, recursive=True)
+                    if found_descendant:
+                        return found_descendant
+        except: pass
+
+        return None
+    
+    def WaitForChild(self, name, memoryhandler, timeout=5):
+        start = time.time()
+        child = None
+
+        while time.time() - start < timeout:
+            child = self.FindFirstChild(name)
+            if child is not None: break
+            if not (memoryhandler.game and not memoryhandler.game.failed): break
+            time.sleep(0.1)
+
+        return child
+
+class PlayerClass(RBXInstance):
+    def __init__(self, memory_module, player: RBXInstance):
+        super().__init__(player.raw_address, memory_module)
+        self.memory_module = memory_module
+
+        try:
+            if player.ClassName != "Player":
+                self.failed = True
+            else:
+                self.instance = player
+        except (KeyError, OSError):
+            self.failed = True
+
+    # props #
+    @property
+    def Character(self) -> RBXInstance | None:
+        addr = int.from_bytes(self.memory_module.read(self.instance.raw_address + Offsets["Character"], 8), 'little')
+        if addr == 0:
+            return None
+        
+        return RBXInstance(addr, self.memory_module)
+    
+    @property
+    def DisplayName(self):
+        return self.memory_module.read_string(self.raw_address + Offsets["DisplayName"])
+
+    @property
+    def UserId(self):
+        return self.memory_module.read_long(self.raw_address + Offsets["UserId"])
+
+    @property
+    def Team(self):
+        addr = int.from_bytes(self.memory_module.read(self.instance.raw_address + Offsets["Team"], 8), 'little')
+        if addr == 0:
+            return None
+        
+        return RBXInstance(addr, self.memory_module)
+
+class CameraClass(RBXInstance):
+    def __init__(self, memory_module, camera: RBXInstance):
+        super().__init__(camera.raw_address, memory_module)
+        self.memory_module = memory_module
+
+        try:
+            if camera.ClassName != "Camera":
+                self.failed = True
+            else:
+                self.instance = camera
+        except (KeyError, OSError):
+            self.failed = True
+
+    # props #
+    @property
+    def FieldOfView(self):
+        return self.FieldOfViewRadians * (180/math.pi)
+    
+    @property
+    def FieldOfViewRadians(self):
+        return self.memory_module.read_float(self.raw_address + Offsets["FOV"])
+    
+    @property
+    def ViewportSize(self):
+        SizeData = self.memory_module.read_floats(self.raw_address + Offsets["ViewportSize"], 2)
+        return Vector2(*SizeData)
+
+# Service #
+class ServiceBase:
+    def __init__(self):
+        self.instance = None
+        self.failed = False
+
+    # expose instance functions #
+    def __getattr__(self, name):
+        # instance #
+        if self.instance is not None:
+            return getattr(self.instance, name)
+        
+        return self.instance.FindFirstChild(name)
+
+class DataModel(ServiceBase):
+    def __init__(self, memory_module):
+        super().__init__()
+        self.memory_module = memory_module
+
+        self.error = None
+        try:
+            if Offsets.get("DataModelPointer") is not None:
+                datamodel_addr = Offsets["DataModelPointer"]
+            else:
+                fake_dm_pointer_offset = Offsets["FakeDataModelPointer"]
+                fake_dm_pointer_addr = memory_module.base + fake_dm_pointer_offset
+                fake_dm_pointer_val = int.from_bytes(memory_module.read(fake_dm_pointer_addr, 8), 'little')
+
+                dm_to_datamodel_offset = Offsets["FakeDataModelToDataModel"]
+                datamodel_addr_ptr = fake_dm_pointer_val + dm_to_datamodel_offset
+                datamodel_addr = int.from_bytes(memory_module.read(datamodel_addr_ptr, 8), 'little')
+
+            datamodel_instance = RBXInstance(datamodel_addr, memory_module)
+
+            if datamodel_instance.Name != "Ugc":
+                self.failed = True
+            else:
+                self.instance = datamodel_instance
+        except (KeyError, OSError) as e:
+            self.error = e
+            self.failed = True
+
+    @property
+    def PlaceId(self):
+        return self.memory_module.read_long(self.raw_address + Offsets["PlaceId"])
+
+    @property
+    def GameId(self):
+        return self.memory_module.read_long(self.raw_address + Offsets["GameId"])
+
+    @property
+    def JobId(self):
+        return self.memory_module.read_string(self.raw_address + Offsets["JobId"])
+
+    @property
+    def Players(self):
+        return PlayersService(self.memory_module, self)
+
+    @property
+    def Workspace(self):
+        return WorkspaceService(self.memory_module, self)
+
+    # class functions #
+    def GetService(self, name):
+        if self.failed: return
+
+        for instance in self.instance.GetChildren():
+            if instance.ClassName == name:
+                return instance
+
+        return None
+
+    # Stuff
+    def IsLoaded(self):
+        return self.memory_module.read_bool(self.raw_address + Offsets["GameLoaded"])
+
+class PlayersService(ServiceBase):
+    def __init__(self, memory_module, game: DataModel):
+        super().__init__()
+        self.memory_module = memory_module
+
+        try:
+            players_instance: RBXInstance = game.GetService("Players")
+            if players_instance.ClassName != "Players":
+                self.failed = True
+            else:
+                self.instance = players_instance
+        except (KeyError, OSError):
+            self.failed = True
+
+    # props #
+    @property
+    def LocalPlayer(self) -> RBXInstance | None:
+        if self.failed: return
+
+        addr = int.from_bytes(self.memory_module.read(self.instance.raw_address + Offsets["LocalPlayer"], 8), 'little')
+        return PlayerClass(self.memory_module, RBXInstance(addr, self.memory_module))
+
+    def GetPlayers(self):
+        players = []
+
+        for instance in self.instance.GetChildren():
+            if instance.ClassName == "Player":
+                players.append(PlayerClass(self.memory_module, instance))
+        
+        return players
+
+class WorkspaceService(ServiceBase):
+    def __init__(self, memory_module, game: DataModel):
+        super().__init__()
+        self.memory_module = memory_module
+
+        try:
+            workspace_instance: RBXInstance = game.GetService("Workspace")
+            if workspace_instance.ClassName != "Workspace":
+                self.failed = True
+            else:
+                self.instance = workspace_instance
+        except (KeyError, OSError):
+            self.failed = True
+
+    # props #
+    @property
+    def CurrentCamera(self) -> CameraClass | None:
+        if self.failed: return
+
+        addr = int.from_bytes(self.memory_module.read(self.instance.raw_address + Offsets["Camera"], 8), 'little')
+        if addr == 0:
+            return None
+        
+        return CameraClass(self.memory_module, RBXInstance(addr, self.memory_module))

robloxmemoryapi-0.0.1.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: robloxmemoryapi
+Version: 0.0.1
+Summary: Python Library that abstracts reading data from the Roblox DataModel
+Author-email: upio <notpoiu@users.noreply.github.com>, mstudio45 <mstudio45@users.noreply.github.com>, ActualMasterOogway <ActualMasterOogway@users.noreply.github.com>
+License: Copyright 2025 upio, mstudio45, master oogway
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/notpoiu/RobloxMemoryAPI
+Project-URL: Issues, https://github.com/notpoiu/RobloxMemoryAPI/issues
+Keywords: roblox,memory,windows
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: requests>=2.0
+Dynamic: license-file
+
+# RobloxMemoryAPI
+
+A Python library that is _hopefully stealthy_ and abstracts externally reading memory to get datamodel information from the roblox game client.
+
+This was made by [upio](https://github.com/notpoiu), [mstudio45](https://github.com/mstudio45), and [Master Oogway](https://github.com/ActualMasterOogway) and created for the [Dig Macro](https://github.com/mstudio45/digmacro) project (external mode and not the computer vision mode).
+
+## Installation
+
+PyPI:
+
+```bash
+pip install robloxmemoryapi
+```
+
+Development (editable install from source):
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+An example script can be found in [example.py](example.py). If running from the repo, use the editable install above so `import robloxmemoryapi` resolves the `src` package.
+
+Import the library and create a client instance:
+
+```python
+from robloxmemoryapi import RobloxGameClient
+
+client = RobloxGameClient()
+```
+
+Access the data model:
+
+```python
+game = client.DataModel
+```
+
+Get the local player's name:
+
+```python
+print("Player Name:", game.Players.LocalPlayer.Name)
+```
+
+## License
+
+This project is licensed under the MIT License.

robloxmemoryapi-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+robloxmemoryapi/__init__.py,sha256=HdrWxS_cjqt7V7P5sL2N8_vGGLKV6xOxAZGSQL4nzIM,2560
+robloxmemoryapi/data/offsets.json,sha256=VfVvOpFA11CxJgDgqqpjeRm-mwehSDqZM-e3TXCkS0s,79
+robloxmemoryapi/utils/__init__.py,sha256=PtpwEbCo79OW68ycpVRjLg1DN-lW_3Z6bdMTIDMF4ek,52
+robloxmemoryapi/utils/memory.py,sha256=yjLvvmhxcpQe8u_TULKDSmMiGM4gmYtj214JyGKDEcc,9534
+robloxmemoryapi/utils/offsets.py,sha256=jWfl0ERDxO4-vGXN7FRkv4-Nz1x257pigqhMM06fWI4,1463
+robloxmemoryapi/utils/rbx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+robloxmemoryapi/utils/rbx/datastructures.py,sha256=U_tBET2RqoCllqFIb1Ry_ct0jx7YOTWjaTJLvH4htcA,8462
+robloxmemoryapi/utils/rbx/instance.py,sha256=cRghPNhsRys9g8Xi1fe1dq1wkpefmDJmIWnqndQ-Szc,15644
+robloxmemoryapi-0.0.1.dist-info/licenses/LICENSE.md,sha256=zngVZqcrtwUO0Un82JVGU24AS0_ly3IjE0ussEvqktM,1078
+robloxmemoryapi-0.0.1.dist-info/METADATA,sha256=TBSMJ3O4tC0tmWNYadY1QyZcztB0umU_1hH8gkB8TV8,3186
+robloxmemoryapi-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+robloxmemoryapi-0.0.1.dist-info/top_level.txt,sha256=j28W-HyH5eTKJLbNUc5EGb3KYgNG4MJ6jcOgEKrO_Uc,16
+robloxmemoryapi-0.0.1.dist-info/RECORD,,

robloxmemoryapi-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

robloxmemoryapi-0.0.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2025 upio, mstudio45, master oogway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

robloxmemoryapi-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+robloxmemoryapi