robloxmemoryapi 0.0.2__tar.gz → 0.0.4__tar.gz

{robloxmemoryapi-0.0.2/src/robloxmemoryapi.egg-info → robloxmemoryapi-0.0.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.0.2
-Summary: Python Library that abstracts reading data from the Roblox DataModel
+Version: 0.0.4
+Summary: Python Library that abstracts reading and writing 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
         
@@ -58,12 +58,26 @@ from robloxmemoryapi import RobloxGameClient
 client = RobloxGameClient()
 ```
 
+To request write access (e.g. to patch values), pass `allow_write=True` when creating the client.
+
+```python
+client = RobloxGameClient(allow_write=True)
+```
+
 Access the data model:
 
 ```python
 game = client.DataModel
 ```
 
+Kill the local player:
+
+```python
+# (requires allow_write=True when creating the client)
+# allow_write may be detected by roblox. It is disabled by default.
+game.Players.LocalPlayer.Character.Humanoid.Health = 0
+```
+
 Get the local player's name:
 
 ```python

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4}/README.md

@@ -30,12 +30,26 @@ from robloxmemoryapi import RobloxGameClient
 client = RobloxGameClient()
 ```
 
+To request write access (e.g. to patch values), pass `allow_write=True` when creating the client.
+
+```python
+client = RobloxGameClient(allow_write=True)
+```
+
 Access the data model:
 
 ```python
 game = client.DataModel
 ```
 
+Kill the local player:
+
+```python
+# (requires allow_write=True when creating the client)
+# allow_write may be detected by roblox. It is disabled by default.
+game.Players.LocalPlayer.Character.Humanoid.Health = 0
+```
+
 Get the local player's name:
 
 ```python

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robloxmemoryapi"
-version = "0.0.2"
-description = "Python Library that abstracts reading data from the Roblox DataModel"
+version = "0.0.4"
+description = "Python Library that abstracts reading and writing data from the Roblox DataModel"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.9"
 license = { file = "LICENSE.md" }

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4}/src/robloxmemoryapi/__init__.py

@@ -47,7 +47,12 @@ class RobloxRandom:
             return ((u * r) >> 32) + lo
 
 class RobloxGameClient:
-    def __init__(self, pid: int = None, process_name: str = "RobloxPlayerBeta.exe"):
+    def __init__(
+        self,
+        pid: int = None,
+        process_name: str = "RobloxPlayerBeta.exe",
+        allow_write: bool = False,
+    ):
         if platform.system() != "Windows":
             self.failed = True
             return
@@ -56,6 +61,8 @@ class RobloxGameClient:
             EvasiveProcess,
             PROCESS_QUERY_INFORMATION,
             PROCESS_VM_READ,
+            PROCESS_VM_WRITE,
+            PROCESS_VM_OPERATION,
             get_pid_by_name,
         )
 
@@ -67,7 +74,11 @@ class RobloxGameClient:
         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)
+        desired_access = PROCESS_VM_READ | PROCESS_QUERY_INFORMATION
+        if allow_write:
+            desired_access |= PROCESS_VM_WRITE | PROCESS_VM_OPERATION
+
+        self.memory_module = EvasiveProcess(self.pid, desired_access)
         self.failed = False
 
     def close(self):

robloxmemoryapi-0.0.4/src/robloxmemoryapi/data/offsets.json

@@ -0,0 +1,6 @@
+{
+    "Text": "0xC10",
+    "Character": "0x360",
+    "PrimaryPart": "0x248"
+}
+

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4}/src/robloxmemoryapi/utils/memory.py

@@ -20,6 +20,8 @@ BOOL = wintypes.BOOL
 
 PROCESS_QUERY_INFORMATION = 0x0400
 PROCESS_VM_READ = 0x0010
+PROCESS_VM_WRITE = 0x0020
+PROCESS_VM_OPERATION = 0x0008
 LIST_MODULES_ALL = 0x03
 STATUS_SUCCESS = 0
 MEM_COMMIT = 0x1000
@@ -79,17 +81,27 @@ NtReadVirtualMemoryProto = ctypes.WINFUNCTYPE(
     ctypes.c_ulong,
     ctypes.POINTER(ctypes.c_ulong)
 )
+NtWriteVirtualMemoryProto = 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_write = get_syscall_number("NtWriteVirtualMemory")
 syscall_id_close = get_syscall_number("NtClose")
 
-if not all([syscall_id_open, syscall_id_read, syscall_id_close]):
+if not all([syscall_id_open, syscall_id_read, syscall_id_write, 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_write_virtual_memory_syscall = create_syscall_function(syscall_id_write, NtWriteVirtualMemoryProto)
 nt_close_syscall = create_syscall_function(syscall_id_close, NtCloseProto)
 
 psapi.EnumProcessModulesEx.argtypes = [
@@ -204,6 +216,27 @@ class EvasiveProcess:
             raise OSError(f"NtReadVirtualMemory failed with NTSTATUS: 0x{status:X}")
         return buffer.raw[:bytes_read.value]
 
+    def write(self, address: int, data: bytes | bytearray) -> int:
+        if not self.handle or self.handle.value == 0:
+            raise ValueError("Process handle is not valid.")
+        if not isinstance(data, (bytes, bytearray)):
+            raise TypeError("data must be bytes-like.")
+        raw = bytes(data)
+        if len(raw) == 0:
+            return 0
+        buffer = (ctypes.c_ubyte * len(raw)).from_buffer_copy(raw)
+        bytes_written = ctypes.c_ulong(0)
+        status = nt_write_virtual_memory_syscall(
+            self.handle,
+            LPVOID(address),
+            buffer,
+            len(raw),
+            ctypes.byref(bytes_written)
+        )
+        if status != STATUS_SUCCESS:
+            raise OSError(f"NtWriteVirtualMemory failed with NTSTATUS: 0x{status:X}")
+        return bytes_written.value
+
     # numbers #
     def read_int(self, address: int) -> int:
         buffer = self.read(address, 4)
@@ -243,6 +276,23 @@ class EvasiveProcess:
             return floats
         except (OSError, struct.error) as e:
             return [0.0]
+    
+    def write_int(self, address: int, value: int) -> None:
+        self.write(address, struct.pack('<I', value & 0xFFFFFFFF))
+
+    def write_long(self, address: int, value: int) -> None:
+        self.write(address, struct.pack('<Q', value & 0xFFFFFFFFFFFFFFFF))
+
+    def write_double(self, address: int, value: float) -> None:
+        self.write(address, struct.pack('<d', value))
+
+    def write_float(self, address: int, value: float) -> None:
+        self.write(address, struct.pack('<f', value))
+
+    def write_floats(self, address: int, values) -> None:
+        packed = b''.join(struct.pack('<f', float(v)) for v in values)
+        if packed:
+            self.write(address, packed)
 
     # bool #
     def read_bool(self, address: int) -> bool:
@@ -252,6 +302,9 @@ class EvasiveProcess:
             return bool(int.from_bytes(bool_byte, 'little'))
         except OSError:
             return False
+    
+    def write_bool(self, address: int, value: bool) -> None:
+        self.write(address, (1 if value else 0).to_bytes(1, 'little'))
 
     # string #
     def read_raw_string(self, address: int, max_length: int = 256) -> str:
@@ -259,6 +312,12 @@ class EvasiveProcess:
         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 write_raw_string(self, address: int, value: str, null_terminate: bool = True) -> None:
+        data = value.encode('utf-8')
+        if null_terminate:
+            data += b'\x00'
+        self.write(address, data)
         
     def read_string(self, address: int) -> str:
         string_length = self.read_int(address + 0x10)
@@ -272,4 +331,4 @@ class EvasiveProcess:
     def close(self):
         if self.handle and self.handle.value != 0:
             nt_close_syscall(self.handle)
-            self.handle = HANDLE(0)
+            self.handle = HANDLE(0)

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4}/src/robloxmemoryapi/utils/offsets.py

@@ -32,8 +32,8 @@ except Exception:
         # Fallback defaults
         LoadedOffsets = {
             "Text": "0xC10",
-            "Character": "0x328",
-            "PrimaryPart": "0x268",
+            "Character": "0x340",
+            "PrimaryPart": "0x260",
         }
 
 ParseOffsets(LoadedOffsets, OffsetsRequest.json())

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4}/src/robloxmemoryapi/utils/rbx/instance.py

@@ -15,17 +15,105 @@ class RBXInstance:
         return self.FindFirstChild(key)
 
     # utilities #
+    def _ensure_writable(self):
+        if not hasattr(self.memory_module, "write"):
+            raise RuntimeError("Write operations require a memory module with write support (allow_write=True).")
+
+    @staticmethod
+    def _as_vector3(value, context="value"):
+        if isinstance(value, Vector3):
+            return value
+        
+        if isinstance(value, (tuple, list)) and len(value) == 3:
+            return Vector3(*value)
+        
+        raise TypeError(f"{context} must be a Vector3 or an iterable of three numbers.")
+
+    @staticmethod
+    def _as_vector2(value, context="value"):
+        if isinstance(value, Vector2):
+            return value
+        
+        if isinstance(value, (tuple, list)) and len(value) == 2:
+            return Vector2(*value)
+        
+        raise TypeError(f"{context} must be a Vector2 or an iterable of two numbers.")
+
+    @staticmethod
+    def _as_udim2(value, context="value"):
+        if isinstance(value, UDim2):
+            return value
+        if isinstance(value, (tuple, list)):
+            if len(value) == 4:
+                return UDim2(value[0], value[1], value[2], value[3])
+            if len(value) == 2:
+                x, y = value
+                if isinstance(x, UDim) and isinstance(y, UDim):
+                    return UDim2(x.Scale, x.Offset, y.Scale, y.Offset)
+                if isinstance(x, (tuple, list)) and isinstance(y, (tuple, list)) and len(x) == 2 and len(y) == 2:
+                    return UDim2(x[0], x[1], y[0], y[1])
+        raise TypeError(f"{context} must be a UDim2 or a compatible iterable.")
+
+    # memory helpers #
+    def _write_rbx_string(self, address: int, value: str):
+        self._ensure_writable()
+
+        if not isinstance(value, str):
+            raise TypeError("value must be a string.")
+        
+        if address == 0:
+            raise ValueError("String address is null; cannot write.")
+        
+        encoded = value.encode('utf-8')
+        if len(encoded) > 15:
+            raise ValueError("String too long (max 15 UTF-8 bytes supported for inline Roblox strings).")
+        
+        current_length = self.memory_module.read_int(address + 0x10)
+        if current_length > 15:
+            raise ValueError("Existing string is heap allocated; inline overwrite is not supported.")
+        
+        padded = encoded + b'\x00'
+        if len(padded) < 16:
+            padded += b'\x00' * (16 - len(padded))
+        
+        self.memory_module.write(address, padded[:16])
+        self.memory_module.write_int(address + 0x10, len(encoded))
+
+
+    def _read_udim2(self, address: int) -> UDim2:
+        if not isinstance(address, int):
+            raise TypeError("address must be an int.")
+
+        scale_x = self.memory_module.read_float(address)
+        offset_x = self.memory_module.read_int(address + 0x4)
+        scale_y = self.memory_module.read_float(address + 0x8)
+        offset_y = self.memory_module.read_int(address + 0xC)
+
+        return UDim2(scale_x, offset_x, scale_y, offset_y)
+        
+
+    def _write_udim2(self, address: int, value: UDim2):
+        value = self._as_udim2(value, "UDim2")
+
+        if not isinstance(value, UDim2):
+            raise TypeError("value must be a UDim2.")
+
+        self._ensure_writable()
+
+        self.memory_module.write_float(address, value.X.Scale)
+        self.memory_module.write_int(address + 0x4, value.X.Offset)
+        
+        self.memory_module.write_float(address + 0x8, value.Y.Scale)
+        self.memory_module.write_int(address + 0xC, value.Y.Offset)
+
+
+    # useful pointer stuff #
     @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
     
-    @property
-    def on_demand_instance_address(self):
-        part_primitive_pointer = self.raw_address + Offsets["OnDemandInstance"]
-        part_primitive = int.from_bytes(self.memory_module.read(part_primitive_pointer, 8), 'little')
-        return part_primitive
 
     # props #
     @property
@@ -36,12 +124,32 @@ class RBXInstance:
         
         return RBXInstance(parent_pointer, self.memory_module)
     
+    @Parent.setter
+    def Parent(self, value):
+        if value is None:
+            target = 0
+        elif isinstance(value, RBXInstance):
+            target = value.raw_address
+        elif isinstance(value, int):
+            target = value
+        else:
+            raise TypeError("Parent must be set to an RBXInstance, int address, or None.")
+        self._ensure_writable()
+        self.memory_module.write_long(self.raw_address + Offsets["Parent"], target)
+
     @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)
     
+    @Name.setter
+    def Name(self, value: str):
+        self._ensure_writable()
+        name_address_pointer = self.raw_address + Offsets["Name"]
+        name_address = int.from_bytes(self.memory_module.read(name_address_pointer, 8), 'little')
+        self._write_rbx_string(name_address, value)
+    
     @property
     def ClassName(self):
         class_descriptor_address = int.from_bytes(
@@ -79,6 +187,29 @@ class RBXInstance:
             Vector3(*LookVectorData)
         )
 
+    @CFrame.setter
+    def CFrame(self, value: "CFrame"):
+        if not isinstance(value, CFrame):
+            raise TypeError("CFrame setter expects a CFrame value.")
+        self._ensure_writable()
+
+        matrix_data = [
+            value.RightVector.X, value.UpVector.X, -value.LookVector.X,
+            value.RightVector.Y, value.UpVector.Y, -value.LookVector.Y,
+            value.RightVector.Z, value.UpVector.Z, -value.LookVector.Z,
+            value.Position.X, value.Position.Y, value.Position.Z
+        ]
+
+        className = self.ClassName
+        if "part" in className.lower():
+            base_address = self.primitive_address + Offsets["CFrame"]
+        elif className == "Camera":
+            base_address = self.raw_address + Offsets["CameraCFrame"]
+        else:
+            raise AttributeError("CFrame cannot be written for this instance type.")
+
+        self.memory_module.write_floats(base_address, matrix_data)
+
     @property
     def Position(self):
         className = self.ClassName
@@ -89,17 +220,30 @@ class RBXInstance:
             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"])
+            return self._read_udim2(self.raw_address + Offsets["FramePositionX"])
+
+    @Position.setter
+    def Position(self, value):
+        className = self.ClassName
+        
+        self._ensure_writable()
+        if "part" in className.lower():
+            vec = self._as_vector3(value, "Position")
+            self.memory_module.write_floats(
+                self.primitive_address + Offsets["Position"],
+                (vec.X, vec.Y, vec.Z)
+            )
 
-                y = self.memory_module.read_float(self.raw_address + Offsets["FramePositionY"])
-                y_offset = self.memory_module.read_int(self.raw_address + Offsets["FramePositionOffsetY"])
+        elif className == "Camera":
+            vec = self._as_vector3(value, "Position")
+            self.memory_module.write_floats(
+                self.raw_address + Offsets["CameraPos"],
+                (vec.X, vec.Y, vec.Z)
+            )
 
-                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)
+        else:
+            udim2_value = self._as_udim2(value, "Position")
+            self._write_udim2(self.raw_address + Offsets["FramePositionX"], udim2_value)
 
     @property
     def Velocity(self):
@@ -111,19 +255,40 @@ class RBXInstance:
         
         return None
 
+    @Velocity.setter
+    def Velocity(self, value):
+        className = self.ClassName
+        if "part" not in className.lower():
+            raise AttributeError("Velocity can only be written for BasePart-derived instances.")
+        
+        vec = self._as_vector3(value, "Velocity")
+        
+        self._ensure_writable()
+        self.memory_module.write_floats(
+            self.primitive_address + Offsets["Velocity"],
+            (vec.X, vec.Y, vec.Z)
+        )
+
     @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)
+            return self._read_udim2(self.raw_address + Offsets["FrameSizeX"])
+
+    @Size.setter
+    def Size(self, value):
+        self._ensure_writable()
+        if "part" in self.ClassName.lower():
+            vec = self._as_vector3(value, "Size")
+            self.memory_module.write_floats(
+                self.primitive_address + Offsets["PartSize"],
+                (vec.X, vec.Y, vec.Z)
+            )
+        else:
+            gui_size = self._as_udim2(value, "Size")
+            self._write_udim2(self.raw_address + Offsets["FrameSizeX"], gui_size)
 
     # XXXXValue props #
     @property
@@ -148,6 +313,33 @@ class RBXInstance:
             return RBXInstance(object_address, self.memory_module)
         
         return None
+
+    @Value.setter
+    def Value(self, new_value):
+        self._ensure_writable()
+        classname = self.ClassName
+        value_address = self.raw_address + Offsets["Value"]
+
+        if classname == "StringValue":
+            self._write_rbx_string(value_address, str(new_value))
+        elif classname == "IntValue":
+            self.memory_module.write_int(value_address, int(new_value))
+        elif classname == "NumberValue":
+            self.memory_module.write_double(value_address, float(new_value))
+        elif classname == "BoolValue":
+            self.memory_module.write_bool(value_address, bool(new_value))
+        elif classname == "ObjectValue":
+            if new_value is None:
+                target = 0
+            elif isinstance(new_value, RBXInstance):
+                target = new_value.raw_address
+            elif isinstance(new_value, int):
+                target = new_value
+            else:
+                raise TypeError("ObjectValue.Value must be set to an RBXInstance, int address, or None.")
+            self.memory_module.write_long(value_address, target)
+        else:
+            raise AttributeError(f"Writing Value is not supported for class {classname}.")
     
     # text props #
     @property
@@ -157,6 +349,12 @@ class RBXInstance:
         
         return None
 
+    @Text.setter
+    def Text(self, value: str):
+        if "text" not in self.ClassName.lower():
+            raise AttributeError("Text is not available on this instance.")
+        self._write_rbx_string(self.raw_address + Offsets["Text"], str(value))
+
     # humanoid props #
     @property
     def WalkSpeed(self):
@@ -165,12 +363,28 @@ class RBXInstance:
         
         return self.memory_module.read_float(self.raw_address + Offsets["WalkSpeed"])
 
+    @WalkSpeed.setter
+    def WalkSpeed(self, value: float):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("WalkSpeed is only available on Humanoid instances.")
+        self._ensure_writable()
+
+        self.memory_module.write_float(self.raw_address + Offsets["WalkSpeed"], float(value))
+
     @property
     def JumpPower(self):
         if self.ClassName != "Humanoid":
             return None
         
         return self.memory_module.read_float(self.raw_address + Offsets["JumpPower"])
+
+    @JumpPower.setter
+    def JumpPower(self, value: float):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("JumpPower is only available on Humanoid instances.")
+        self._ensure_writable()
+
+        self.memory_module.write_float(self.raw_address + Offsets["JumpPower"], float(value))
         
     @property
     def Health(self):
@@ -179,6 +393,14 @@ class RBXInstance:
         
         return self.memory_module.read_float(self.raw_address + Offsets["Health"])
 
+    @Health.setter
+    def Health(self, value: float):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("Health is only available on Humanoid instances.")
+        self._ensure_writable()
+
+        self.memory_module.write_float(self.raw_address + Offsets["Health"], float(value))
+
     @property
     def MaxHealth(self):
         if self.ClassName != "Humanoid":
@@ -186,6 +408,14 @@ class RBXInstance:
         
         return self.memory_module.read_float(self.raw_address + Offsets["MaxHealth"])
 
+    @MaxHealth.setter
+    def MaxHealth(self, value: float):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("MaxHealth is only available on Humanoid instances.")
+        self._ensure_writable()
+
+        self.memory_module.write_float(self.raw_address + Offsets["MaxHealth"], float(value))
+
     # model props #
     @property
     def PrimaryPart(self):
@@ -197,6 +427,22 @@ class RBXInstance:
             return None
 
         return RBXInstance(parent_pointer, self.memory_module)
+
+    @PrimaryPart.setter
+    def PrimaryPart(self, value):
+        if self.ClassName != "Model":
+            raise AttributeError("PrimaryPart is only available on Model instances.")
+        self._ensure_writable()
+
+        if value is None:
+            target = 0
+        elif isinstance(value, RBXInstance):
+            target = value.raw_address
+        elif isinstance(value, int):
+            target = value
+        else:
+            raise TypeError("PrimaryPart must be set to an RBXInstance, int address, or None.")
+        self.memory_module.write_long(self.raw_address + Offsets["PrimaryPart"], target)
     
     # functions #
     def GetChildren(self):
@@ -301,6 +547,10 @@ class PlayerClass(RBXInstance):
     def DisplayName(self):
         return self.memory_module.read_string(self.raw_address + Offsets["DisplayName"])
 
+    @DisplayName.setter
+    def DisplayName(self, value: str):
+        self._write_rbx_string(self.raw_address + Offsets["DisplayName"], str(value))
+
     @property
     def UserId(self):
         return self.memory_module.read_long(self.raw_address + Offsets["UserId"])
@@ -330,16 +580,34 @@ class CameraClass(RBXInstance):
     @property
     def FieldOfView(self):
         return self.FieldOfViewRadians * (180/math.pi)
+
+    @FieldOfView.setter
+    def FieldOfView(self, value: float):
+        self.FieldOfViewRadians = float(value) * (math.pi / 180)
     
     @property
     def FieldOfViewRadians(self):
         return self.memory_module.read_float(self.raw_address + Offsets["FOV"])
+
+    @FieldOfViewRadians.setter
+    def FieldOfViewRadians(self, value: float):
+        self._ensure_writable()
+        self.memory_module.write_float(self.raw_address + Offsets["FOV"], float(value))
     
     @property
     def ViewportSize(self):
         SizeData = self.memory_module.read_floats(self.raw_address + Offsets["ViewportSize"], 2)
         return Vector2(*SizeData)
 
+    @ViewportSize.setter
+    def ViewportSize(self, value):
+        vec = self._as_vector2(value, "ViewportSize")
+        self._ensure_writable()
+        self.memory_module.write_floats(
+            self.raw_address + Offsets["ViewportSize"],
+            (vec.X, vec.Y)
+        )
+
 # Service #
 class ServiceBase:
     def __init__(self):

{robloxmemoryapi-0.0.2 → robloxmemoryapi-0.0.4/src/robloxmemoryapi.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.0.2
-Summary: Python Library that abstracts reading data from the Roblox DataModel
+Version: 0.0.4
+Summary: Python Library that abstracts reading and writing 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
         
@@ -58,12 +58,26 @@ from robloxmemoryapi import RobloxGameClient
 client = RobloxGameClient()
 ```
 
+To request write access (e.g. to patch values), pass `allow_write=True` when creating the client.
+
+```python
+client = RobloxGameClient(allow_write=True)
+```
+
 Access the data model:
 
 ```python
 game = client.DataModel
 ```
 
+Kill the local player:
+
+```python
+# (requires allow_write=True when creating the client)
+# allow_write may be detected by roblox. It is disabled by default.
+game.Players.LocalPlayer.Character.Humanoid.Health = 0
+```
+
 Get the local player's name:
 
 ```python

robloxmemoryapi-0.0.2/src/robloxmemoryapi/data/offsets.json

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