robloxmemoryapi 0.2.2.1__tar.gz → 0.2.4__tar.gz

{robloxmemoryapi-0.2.2.1/src/robloxmemoryapi.egg-info → robloxmemoryapi-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.2.2.1
+Version: 0.2.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

{robloxmemoryapi-0.2.2.1 → robloxmemoryapi-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robloxmemoryapi"
-version = "0.2.2.1"
+version = "0.2.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"

{robloxmemoryapi-0.2.2.1 → robloxmemoryapi-0.2.4}/src/robloxmemoryapi/utils/rbx/datastructures.py

@@ -389,4 +389,28 @@ class AnimationTrack:
 
     @property
     def IsPlaying(self):
-        return self.memory_module.read_bool(self.raw_address, self._offsets["IsPlaying"])
+        return self.memory_module.read_bool(self.raw_address, self._offsets["IsPlaying"])
+
+class FFlag:
+    __slots__ = ("name", "type", "_value", "offset", "_manager")
+
+    def __init__(self, name: str, flag_type: str, value, offset: int, manager=None):
+        self.name = name
+        self.type = flag_type
+        self._value = value
+        self.offset = offset
+        self._manager = manager
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, new_value):
+        if self._manager is None:
+            raise RuntimeError("Cannot set value: FFlag not bound to an FFlagManager")
+        result = self._manager.set(self.name, new_value)
+        self._value = result._value
+
+    def __repr__(self):
+        return f"FFlag(name={self.name!r}, type={self.type!r}, value={self._value!r})"

{robloxmemoryapi-0.2.2.1 → robloxmemoryapi-0.2.4}/src/robloxmemoryapi/utils/rbx/fflags.py

@@ -1,4 +1,5 @@
 from ..offsets import get_fflag_offsets
+from .datastructures import FFlag
 
 _MODULE_SIZE_LIMIT = 0x20000000
 
@@ -33,17 +34,6 @@ def _encode_flog(value: str) -> int:
     return (level_byte << 8) | (param & 0xFF)
 
 
-class FFlag:
-    __slots__ = ("name", "type", "value", "offset")
-
-    def __init__(self, name: str, flag_type: str, value, offset: int):
-        self.name = name
-        self.type = flag_type   # "bool", "int", or "string"
-        self.value = value
-        self.offset = offset
-
-    def __repr__(self):
-        return f"FFlag(name={self.name!r}, type={self.type!r}, value={self.value!r})"
 
 class FFlagManager:
     def __init__(self, memory_module):
@@ -109,7 +99,7 @@ class FFlagManager:
         if offset is None:
             return None
         flag_type, value = self._reflect(name, offset)
-        return FFlag(name, flag_type, value, offset)
+        return FFlag(name, flag_type, value, offset, manager=self)
 
     def get_many(self, *names: str) -> dict[str, FFlag]:
         self._ensure_offsets()
@@ -126,7 +116,7 @@ class FFlagManager:
         for name, offset in self._offsets.items():
             try:
                 flag_type, value = self._reflect(name, offset)
-                out[name] = FFlag(name, flag_type, value, offset)
+                out[name] = FFlag(name, flag_type, value, offset, manager=self)
             except OSError:
                 pass
         return out
@@ -165,7 +155,7 @@ class FFlagManager:
             raise RuntimeError(f"Cannot write to flag with unknown type '{flag_type}'")
 
         new_type, new_value = self._reflect(name, offset)
-        return FFlag(name, new_type, new_value, offset)
+        return FFlag(name, new_type, new_value, offset, manager=self)
 
     def __getitem__(self, name: str) -> FFlag:
         flag = self.get(name)

{robloxmemoryapi-0.2.2.1 → robloxmemoryapi-0.2.4}/src/robloxmemoryapi/utils/rbx/instance.py

@@ -7,6 +7,7 @@ from .bytecode import decryptor, encryptor
 
 instance_offsets = Offsets["Instance"]
 basepart_offsets = Offsets["BasePart"]
+primitive_offsets = Offsets["Primitive"]
 camera_offsets = Offsets["Camera"]
 gui_offsets = Offsets["GuiObject"]
 misc_offsets = Offsets["Misc"]
@@ -18,6 +19,13 @@ statsitem_offsets = Offsets["StatsItem"]
 inputobject_offsets = Offsets["MouseService"]  # InputObject uses MouseService offsets
 animator_offsets = Offsets["Animator"]
 animationtrack_offsets = Offsets["AnimationTrack"]
+tool_offsets = Offsets["Tool"]
+world_offsets = Offsets["World"]
+sound_offsets = Offsets["Sound"]
+spawnlocation_offsets = Offsets["SpawnLocation"]
+clothing_offsets = Offsets["Clothing"]
+charactermesh_offsets = Offsets["CharacterMesh"]
+attachment_offsets = Offsets["Attachment"]
 
 ROTATION_MATRIX_FLOATS = 9
 
@@ -141,6 +149,11 @@ class RBXInstance:
         else:
             raise TypeError("Parent must be set to an RBXInstance, int address, or None.")
         self._ensure_writable()
+
+        current_parent = self.Parent
+        if current_parent is not None:
+            current_parent.Children.remove(self)
+        
         self.memory_module.write_long(
             self.raw_address + instance_offsets["Parent"],
             target
@@ -181,11 +194,11 @@ class RBXInstance:
 
         if "part" in className.lower():
             CFrameRotation = self.memory_module.read_floats(
-                self.primitive_address + basepart_offsets["Rotation"],
+                self.primitive_address + primitive_offsets["Rotation"],
                 ROTATION_MATRIX_FLOATS
             )
             PositionData = self.memory_module.read_floats(
-                self.primitive_address + basepart_offsets["Position"],
+                self.primitive_address + primitive_offsets["Position"],
                 3
             )
         elif className == "Camera":
@@ -226,8 +239,8 @@ class RBXInstance:
 
         className = self.ClassName
         if "part" in className.lower():
-            rotation_address = self.primitive_address + basepart_offsets["Rotation"]
-            position_address = self.primitive_address + basepart_offsets["Position"]
+            rotation_address = self.primitive_address + primitive_offsets["Rotation"]
+            position_address = self.primitive_address + primitive_offsets["Position"]
         elif className == "Camera":
             rotation_address = self.raw_address + camera_offsets["Rotation"]
             position_address = self.raw_address + camera_offsets["Position"]
@@ -242,7 +255,7 @@ class RBXInstance:
         className = self.ClassName.lower()
         if "part" in className:
             position_vector3 = self.memory_module.read_floats(
-                self.primitive_address + basepart_offsets["Position"],
+                self.primitive_address + primitive_offsets["Position"],
                 3
             )
             return Vector3(*position_vector3)
@@ -263,7 +276,7 @@ class RBXInstance:
         if "part" in className:
             vec = self._as_vector3(value, "Position")
             self.memory_module.write_floats(
-                self.primitive_address + basepart_offsets["Position"],
+                self.primitive_address + primitive_offsets["Position"],
                 (vec.X, vec.Y, vec.Z)
             )
 
@@ -284,7 +297,7 @@ class RBXInstance:
 
         if "part" in className.lower():
             velocity_vector3 = self.memory_module.read_floats(
-                self.primitive_address + basepart_offsets["AssemblyLinearVelocity"],
+                self.primitive_address + primitive_offsets["AssemblyLinearVelocity"],
                 3
             )
             return Vector3(*velocity_vector3)
@@ -301,7 +314,7 @@ class RBXInstance:
         
         self._ensure_writable()
         self.memory_module.write_floats(
-            self.primitive_address + basepart_offsets["AssemblyLinearVelocity"],
+            self.primitive_address + primitive_offsets["AssemblyLinearVelocity"],
             (vec.X, vec.Y, vec.Z)
         )
 
@@ -311,7 +324,7 @@ class RBXInstance:
 
         if "part" in className.lower():
             velocity_vector3 = self.memory_module.read_floats(
-                self.primitive_address + basepart_offsets["AssemblyAngularVelocity"],
+                self.primitive_address + primitive_offsets["AssemblyAngularVelocity"],
                 3
             )
             return Vector3(*velocity_vector3)
@@ -328,7 +341,7 @@ class RBXInstance:
         
         self._ensure_writable()
         self.memory_module.write_floats(
-            self.primitive_address + basepart_offsets["AssemblyAngularVelocity"],
+            self.primitive_address + primitive_offsets["AssemblyAngularVelocity"],
             (vec.X, vec.Y, vec.Z)
         )
 
@@ -367,6 +380,21 @@ class RBXInstance:
                 self.raw_address,
                 proximityprompt_offsets["Enabled"]
             )
+        elif self.ClassName == "Tool":
+            return self.memory_module.read_bool(
+                self.raw_address,
+                tool_offsets["Enabled"]
+            )
+        elif self.ClassName == "ColorCorrectionEffect":
+            return self.memory_module.read_bool(
+                self.raw_address,
+                Offsets["ColorCorrectionEffect"]["Enabled"]
+            )
+        elif self.ClassName == "SpawnLocation":
+            return self.memory_module.read_bool(
+                self.raw_address,
+                spawnlocation_offsets["Enabled"]
+            )
         return None
 
     @Enabled.setter
@@ -383,8 +411,26 @@ class RBXInstance:
                 self.raw_address + proximityprompt_offsets["Enabled"],
                 value
             )
+        elif self.ClassName == "Tool":
+            self._ensure_writable()
+            self.memory_module.write_bool(
+                self.raw_address + tool_offsets["Enabled"],
+                bool(value)
+            )
+        elif self.ClassName == "ColorCorrectionEffect":
+            self._ensure_writable()
+            self.memory_module.write_bool(
+                self.raw_address + Offsets["ColorCorrectionEffect"]["Enabled"],
+                bool(value)
+            )
+        elif self.ClassName == "SpawnLocation":
+            self._ensure_writable()
+            self.memory_module.write_bool(
+                self.raw_address + spawnlocation_offsets["Enabled"],
+                bool(value)
+            )
         else:
-            raise AttributeError("Enabled is only available on ScreenGui or ProximityPrompt instances.")
+            raise AttributeError("Enabled is only available on ScreenGui, ProximityPrompt, Tool, ColorCorrectionEffect, or SpawnLocation instances.")
     
     @property
     def Visible(self):
@@ -420,7 +466,7 @@ class RBXInstance:
     def Size(self):
         if "part" in self.ClassName.lower():
             size_vector3 = self.memory_module.read_floats(
-                self.primitive_address + basepart_offsets["Size"],
+                self.primitive_address + primitive_offsets["Size"],
                 3
             )
             return Vector3(*size_vector3)
@@ -433,7 +479,7 @@ class RBXInstance:
         if "part" in self.ClassName.lower():
             vec = self._as_vector3(value, "Size")
             self.memory_module.write_floats(
-                self.primitive_address + basepart_offsets["Size"],
+                self.primitive_address + primitive_offsets["Size"],
                 (vec.X, vec.Y, vec.Z)
             )
         else:
@@ -486,7 +532,7 @@ class RBXInstance:
 
     def _read_primitive_flags(self):
         data = self.memory_module.read(
-            self.primitive_address + basepart_offsets["PrimitiveFlags"], 
+            self.primitive_address + primitive_offsets["Flags"], 
             1
         )
         return int.from_bytes(data, 'little') if data else 0
@@ -494,7 +540,7 @@ class RBXInstance:
     def _write_primitive_flags(self, flags: int):
         self._ensure_writable()
         self.memory_module.write(
-            self.primitive_address + basepart_offsets["PrimitiveFlags"],
+            self.primitive_address + primitive_offsets["Flags"],
             (flags & 0xFF).to_bytes(1, 'little')
         )
 
@@ -907,6 +953,531 @@ class RBXInstance:
             float(value)
         )
 
+    @property
+    def BackgroundTransparency(self):
+        return self.memory_module.read_float(
+            self.raw_address,
+            gui_offsets["BackgroundTransparency"]
+        )
+
+    @BackgroundTransparency.setter
+    def BackgroundTransparency(self, value: float):
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + gui_offsets["BackgroundTransparency"],
+            float(value)
+        )
+
+    @property
+    def ZIndex(self):
+        return self.memory_module.read_int(
+            self.raw_address,
+            gui_offsets["ZIndex"]
+        )
+
+    @ZIndex.setter
+    def ZIndex(self, value: int):
+        self._ensure_writable()
+        self.memory_module.write_int(
+            self.raw_address + gui_offsets["ZIndex"],
+            int(value)
+        )
+
+    # tool props #
+    @property
+    def CanBeDropped(self):
+        if self.ClassName != "Tool":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            tool_offsets["CanBeDropped"]
+        )
+
+    @CanBeDropped.setter
+    def CanBeDropped(self, value: bool):
+        if self.ClassName != "Tool":
+            raise AttributeError("CanBeDropped is only available on Tool instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + tool_offsets["CanBeDropped"],
+            bool(value)
+        )
+
+    @property
+    def Grip(self):
+        if self.ClassName != "Tool":
+            return None
+        grip_data = self.memory_module.read_floats(
+            self.raw_address + tool_offsets["Grip"],
+            12  # CFrame: 9 rotation + 3 position
+        )
+        return grip_data
+
+    @property
+    def ManualActivationOnly(self):
+        if self.ClassName != "Tool":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            tool_offsets["ManualActivationOnly"]
+        )
+
+    @ManualActivationOnly.setter
+    def ManualActivationOnly(self, value: bool):
+        if self.ClassName != "Tool":
+            raise AttributeError("ManualActivationOnly is only available on Tool instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + tool_offsets["ManualActivationOnly"],
+            bool(value)
+        )
+
+    @property
+    def RequiresHandle(self):
+        if self.ClassName != "Tool":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            tool_offsets["RequiresHandle"]
+        )
+
+    @RequiresHandle.setter
+    def RequiresHandle(self, value: bool):
+        if self.ClassName != "Tool":
+            raise AttributeError("RequiresHandle is only available on Tool instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + tool_offsets["RequiresHandle"],
+            bool(value)
+        )
+
+    @property
+    def TextureId(self):
+        if self.ClassName != "Tool":
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            tool_offsets["TextureId"]
+        )
+
+    @TextureId.setter
+    def TextureId(self, value: str):
+        if self.ClassName != "Tool":
+            raise AttributeError("TextureId is only available on Tool instances.")
+        self._ensure_writable()
+        self.memory_module.write_string(
+            self.raw_address + tool_offsets["TextureId"],
+            str(value)
+        )
+
+    @property
+    def Tooltip(self):
+        if self.ClassName != "Tool":
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            tool_offsets["Tooltip"]
+        )
+
+    @Tooltip.setter
+    def Tooltip(self, value: str):
+        if self.ClassName != "Tool":
+            raise AttributeError("Tooltip is only available on Tool instances.")
+        self._ensure_writable()
+        self.memory_module.write_string(
+            self.raw_address + tool_offsets["Tooltip"],
+            str(value)
+        )
+
+    # colorcorrection props #
+    @property
+    def Brightness(self):
+        if self.ClassName == "ColorCorrectionEffect":
+            return self.memory_module.read_float(
+                self.raw_address,
+                Offsets["ColorCorrectionEffect"]["Brightness"]
+            )
+        return None
+
+    @Brightness.setter
+    def Brightness(self, value: float):
+        if self.ClassName == "ColorCorrectionEffect":
+            self._ensure_writable()
+            self.memory_module.write_float(
+                self.raw_address + Offsets["ColorCorrectionEffect"]["Brightness"],
+                float(value)
+            )
+        else:
+            raise AttributeError("Brightness is only available on ColorCorrectionEffect instances (use LightingService.Brightness for Lighting).")
+
+    @property
+    def Contrast(self):
+        if self.ClassName != "ColorCorrectionEffect":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            Offsets["ColorCorrectionEffect"]["Contrast"]
+        )
+
+    @Contrast.setter
+    def Contrast(self, value: float):
+        if self.ClassName != "ColorCorrectionEffect":
+            raise AttributeError("Contrast is only available on ColorCorrectionEffect instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + Offsets["ColorCorrectionEffect"]["Contrast"],
+            float(value)
+        )
+
+    @property
+    def TintColor(self):
+        if self.ClassName != "ColorCorrectionEffect":
+            return None
+        color_data = self.memory_module.read_floats(
+            self.raw_address + Offsets["ColorCorrectionEffect"]["TintColor"],
+            3
+        )
+        return Color3(*color_data)
+
+    @TintColor.setter
+    def TintColor(self, value):
+        if self.ClassName != "ColorCorrectionEffect":
+            raise AttributeError("TintColor is only available on ColorCorrectionEffect instances.")
+        self._ensure_writable()
+        vec = self._as_color3(value, "TintColor")
+        self.memory_module.write_floats(
+            self.raw_address + Offsets["ColorCorrectionEffect"]["TintColor"],
+            (vec.X, vec.Y, vec.Z)
+        )
+
+    # attachment props #
+    @property
+    def AttachmentPosition(self):
+        if self.ClassName != "Attachment":
+            return None
+        pos_data = self.memory_module.read_floats(
+            self.raw_address + attachment_offsets["Position"],
+            3
+        )
+        return Vector3(*pos_data)
+
+    @AttachmentPosition.setter
+    def AttachmentPosition(self, value):
+        if self.ClassName != "Attachment":
+            raise AttributeError("AttachmentPosition is only available on Attachment instances.")
+        self._ensure_writable()
+        vec = self._as_vector3(value, "AttachmentPosition")
+        self.memory_module.write_floats(
+            self.raw_address + attachment_offsets["Position"],
+            (vec.X, vec.Y, vec.Z)
+        )
+
+    # charactermesh props #
+    @property
+    def BaseTextureId(self):
+        if self.ClassName != "CharacterMesh":
+            return None
+        return self.memory_module.read_long(
+            self.raw_address,
+            charactermesh_offsets["BaseTextureId"]
+        )
+
+    @BaseTextureId.setter
+    def BaseTextureId(self, value: int):
+        if self.ClassName != "CharacterMesh":
+            raise AttributeError("BaseTextureId is only available on CharacterMesh instances.")
+        self._ensure_writable()
+        self.memory_module.write_long(
+            self.raw_address + charactermesh_offsets["BaseTextureId"],
+            int(value)
+        )
+
+    @property
+    def OverlayTextureId(self):
+        if self.ClassName != "CharacterMesh":
+            return None
+        return self.memory_module.read_long(
+            self.raw_address,
+            charactermesh_offsets["OverlayTextureId"]
+        )
+
+    @OverlayTextureId.setter
+    def OverlayTextureId(self, value: int):
+        if self.ClassName != "CharacterMesh":
+            raise AttributeError("OverlayTextureId is only available on CharacterMesh instances.")
+        self._ensure_writable()
+        self.memory_module.write_long(
+            self.raw_address + charactermesh_offsets["OverlayTextureId"],
+            int(value)
+        )
+
+    @property
+    def BodyPart(self):
+        if self.ClassName != "CharacterMesh":
+            return None
+        return self.memory_module.read_int(
+            self.raw_address,
+            charactermesh_offsets["BodyPart"]
+        )
+
+    @property
+    def CharacterMeshId(self):
+        if self.ClassName != "CharacterMesh":
+            return None
+        return self.memory_module.read_long(
+            self.raw_address,
+            charactermesh_offsets["MeshId"]
+        )
+
+    # clothing props (Shirt/Pants) #
+    @property
+    def ClothingColor3(self):
+        cn = self.ClassName
+        if cn != "Shirt" and cn != "Pants":
+            return None
+        color_data = self.memory_module.read_floats(
+            self.raw_address + clothing_offsets["Color3"],
+            3
+        )
+        return Color3(*color_data)
+
+    @ClothingColor3.setter
+    def ClothingColor3(self, value):
+        cn = self.ClassName
+        if cn != "Shirt" and cn != "Pants":
+            raise AttributeError("ClothingColor3 is only available on Shirt or Pants instances.")
+        self._ensure_writable()
+        vec = self._as_color3(value, "ClothingColor3")
+        self.memory_module.write_floats(
+            self.raw_address + clothing_offsets["Color3"],
+            (vec.X, vec.Y, vec.Z)
+        )
+
+    @property
+    def Template(self):
+        cn = self.ClassName
+        if cn != "Shirt" and cn != "Pants":
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            clothing_offsets["Template"]
+        )
+
+    @Template.setter
+    def Template(self, value: str):
+        cn = self.ClassName
+        if cn != "Shirt" and cn != "Pants":
+            raise AttributeError("Template is only available on Shirt or Pants instances.")
+        self._ensure_writable()
+        self.memory_module.write_string(
+            self.raw_address + clothing_offsets["Template"],
+            str(value)
+        )
+
+    # sound props #
+    @property
+    def SoundId(self):
+        if self.ClassName != "Sound":
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            sound_offsets["SoundId"]
+        )
+
+    @SoundId.setter
+    def SoundId(self, value: str):
+        if self.ClassName != "Sound":
+            raise AttributeError("SoundId is only available on Sound instances.")
+        self._ensure_writable()
+        self.memory_module.write_string(
+            self.raw_address + sound_offsets["SoundId"],
+            str(value)
+        )
+
+    @property
+    def Volume(self):
+        if self.ClassName != "Sound":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            sound_offsets["Volume"]
+        )
+
+    @Volume.setter
+    def Volume(self, value: float):
+        if self.ClassName != "Sound":
+            raise AttributeError("Volume is only available on Sound instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + sound_offsets["Volume"],
+            float(value)
+        )
+
+    @property
+    def PlaybackSpeed(self):
+        if self.ClassName != "Sound":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            sound_offsets["PlaybackSpeed"]
+        )
+
+    @PlaybackSpeed.setter
+    def PlaybackSpeed(self, value: float):
+        if self.ClassName != "Sound":
+            raise AttributeError("PlaybackSpeed is only available on Sound instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + sound_offsets["PlaybackSpeed"],
+            float(value)
+        )
+
+    @property
+    def Looped(self):
+        if self.ClassName != "Sound":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            sound_offsets["Looped"]
+        )
+
+    @Looped.setter
+    def Looped(self, value: bool):
+        if self.ClassName != "Sound":
+            raise AttributeError("Looped is only available on Sound instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + sound_offsets["Looped"],
+            bool(value)
+        )
+
+    @property
+    def RollOffMaxDistance(self):
+        if self.ClassName != "Sound":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            sound_offsets["RollOffMaxDistance"]
+        )
+
+    @RollOffMaxDistance.setter
+    def RollOffMaxDistance(self, value: float):
+        if self.ClassName != "Sound":
+            raise AttributeError("RollOffMaxDistance is only available on Sound instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + sound_offsets["RollOffMaxDistance"],
+            float(value)
+        )
+
+    @property
+    def RollOffMinDistance(self):
+        if self.ClassName != "Sound":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            sound_offsets["RollOffMinDistance"]
+        )
+
+    @RollOffMinDistance.setter
+    def RollOffMinDistance(self, value: float):
+        if self.ClassName != "Sound":
+            raise AttributeError("RollOffMinDistance is only available on Sound instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + sound_offsets["RollOffMinDistance"],
+            float(value)
+        )
+
+    @property
+    def SoundGroup(self):
+        if self.ClassName != "Sound":
+            return None
+        ptr = self.memory_module.get_pointer(
+            self.raw_address,
+            sound_offsets["SoundGroup"]
+        )
+        if ptr == 0:
+            return None
+        return RBXInstance(ptr, self.memory_module)
+
+    # spawnlocation props #
+    @property
+    def AllowTeamChangeOnTouch(self):
+        if self.ClassName != "SpawnLocation":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            spawnlocation_offsets["AllowTeamChangeOnTouch"]
+        )
+
+    @AllowTeamChangeOnTouch.setter
+    def AllowTeamChangeOnTouch(self, value: bool):
+        if self.ClassName != "SpawnLocation":
+            raise AttributeError("AllowTeamChangeOnTouch is only available on SpawnLocation instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + spawnlocation_offsets["AllowTeamChangeOnTouch"],
+            bool(value)
+        )
+
+    @property
+    def Neutral(self):
+        if self.ClassName != "SpawnLocation":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            spawnlocation_offsets["Neutral"]
+        )
+
+    @Neutral.setter
+    def Neutral(self, value: bool):
+        if self.ClassName != "SpawnLocation":
+            raise AttributeError("Neutral is only available on SpawnLocation instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + spawnlocation_offsets["Neutral"],
+            bool(value)
+        )
+
+    @property
+    def ForcefieldDuration(self):
+        if self.ClassName != "SpawnLocation":
+            return None
+        return self.memory_module.read_int(
+            self.raw_address,
+            spawnlocation_offsets["ForcefieldDuration"]
+        )
+
+    @ForcefieldDuration.setter
+    def ForcefieldDuration(self, value: int):
+        if self.ClassName != "SpawnLocation":
+            raise AttributeError("ForcefieldDuration is only available on SpawnLocation instances.")
+        self._ensure_writable()
+        self.memory_module.write_int(
+            self.raw_address + spawnlocation_offsets["ForcefieldDuration"],
+            int(value)
+        )
+
+    @property
+    def TeamColor(self):
+        if self.ClassName != "SpawnLocation":
+            return None
+        return self.memory_module.read_int(
+            self.raw_address,
+            spawnlocation_offsets["TeamColor"]
+        )
+
+    @TeamColor.setter
+    def TeamColor(self, value: int):
+        if self.ClassName != "SpawnLocation":
+            raise AttributeError("TeamColor is only available on SpawnLocation instances.")
+        self._ensure_writable()
+        self.memory_module.write_int(
+            self.raw_address + spawnlocation_offsets["TeamColor"],
+            int(value)
+        )
+
     # humanoid props #
     @property
     def WalkSpeed(self):
@@ -1353,6 +1924,35 @@ class RBXInstance:
 
         self.memory_module.write_long(bytecode_ptr + Offsets["ByteCode"]["Pointer"], new_content_ptr)
         self.memory_module.write_int(bytecode_ptr + Offsets["ByteCode"]["Size"], new_size)
+
+    # script identification #
+    @property
+    def GUID(self):
+        classname = self.ClassName
+        if classname == "LocalScript":
+            guid_offset = Offsets["LocalScript"]["GUID"]
+        elif classname == "ModuleScript":
+            guid_offset = Offsets["ModuleScript"]["GUID"]
+        else:
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            guid_offset
+        )
+
+    @property
+    def Hash(self):
+        classname = self.ClassName
+        if classname == "LocalScript":
+            hash_offset = Offsets["LocalScript"]["Hash"]
+        elif classname == "ModuleScript":
+            hash_offset = Offsets["ModuleScript"]["Hash"]
+        else:
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            hash_offset
+        )
     
     # functions #
     def GetChildren(self):
@@ -1725,6 +2325,36 @@ class PlayerClass(RBXInstance):
             int(value)
         )
 
+    @property
+    def HealthDisplayDistance(self):
+        return self.memory_module.read_float(
+            self.raw_address,
+            self.offset_base["HealthDisplayDistance"]
+        )
+
+    @HealthDisplayDistance.setter
+    def HealthDisplayDistance(self, value: float):
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + self.offset_base["HealthDisplayDistance"],
+            float(value)
+        )
+
+    @property
+    def NameDisplayDistance(self):
+        return self.memory_module.read_float(
+            self.raw_address,
+            self.offset_base["NameDisplayDistance"]
+        )
+
+    @NameDisplayDistance.setter
+    def NameDisplayDistance(self, value: float):
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + self.offset_base["NameDisplayDistance"],
+            float(value)
+        )
+
 class CameraClass(RBXInstance):
     def __init__(self, memory_module, camera: RBXInstance):
         super().__init__(camera.raw_address, memory_module)
@@ -2235,27 +2865,27 @@ class WorkspaceService(ServiceBase):
     
     @property
     def Gravity(self):
-        GravityContainer = self.memory_module.get_pointer(
+        World = self.memory_module.get_pointer(
             self.instance.raw_address,
-            self.offset_base["GravityContainer"]
+            self.offset_base["World"]
         )
 
         return self.memory_module.read_float(
-            GravityContainer,
-            self.offset_base["Gravity"]
+            World,
+            world_offsets["Gravity"]
         )
 
     @Gravity.setter
     def Gravity(self, value: float):
         self._ensure_writable()
 
-        GravityContainer = self.memory_module.get_pointer(
+        World = self.memory_module.get_pointer(
             self.instance.raw_address,
-            self.offset_base["GravityContainer"]
+            self.offset_base["World"]
         )
 
         self.memory_module.write_float(
-            GravityContainer + self.offset_base["Gravity"],
+            World + world_offsets["Gravity"],
             float(value)
         )
 
@@ -2269,6 +2899,35 @@ class WorkspaceService(ServiceBase):
             self.offset_base["DistributedGameTime"]
         )
 
+    @property
+    def WorldStepsPerSec(self):
+        if self.failed:
+            return 0.0
+
+        World = self.memory_module.get_pointer(
+            self.instance.raw_address,
+            self.offset_base["World"]
+        )
+
+        return self.memory_module.read_float(
+            World,
+            world_offsets["worldStepsPerSec"]
+        )
+
+    @WorldStepsPerSec.setter
+    def WorldStepsPerSec(self, value: float):
+        self._ensure_writable()
+
+        World = self.memory_module.get_pointer(
+            self.instance.raw_address,
+            self.offset_base["World"]
+        )
+
+        self.memory_module.write_float(
+            World + world_offsets["worldStepsPerSec"],
+            float(value)
+        )
+
 class LightingService(ServiceBase):
     def __init__(self, memory_module, game: DataModel):
         super().__init__()
@@ -2469,6 +3128,77 @@ class LightingService(ServiceBase):
             float(value)
         )
 
+    @property
+    def Sky(self):
+        if self.failed: return None
+        sky_ptr = self.memory_module.get_pointer(
+            self.instance.raw_address,
+            self.offset_base["Sky"]
+        )
+        if sky_ptr == 0:
+            return None
+        return RBXInstance(sky_ptr, self.memory_module)
+
+    @property
+    def Source(self):
+        if self.failed: return None
+        return self.memory_module.read_int(
+            self.instance.raw_address,
+            self.offset_base["Source"]
+        )
+
+    @property
+    def SunPosition(self):
+        if self.failed: return None
+        pos_data = self.memory_module.read_floats(
+            self.instance.raw_address + self.offset_base["SunPosition"],
+            3
+        )
+        return Vector3(*pos_data)
+
+    @property
+    def MoonPosition(self):
+        if self.failed: return None
+        pos_data = self.memory_module.read_floats(
+            self.instance.raw_address + self.offset_base["MoonPosition"],
+            3
+        )
+        return Vector3(*pos_data)
+
+    @property
+    def EnvironmentDiffuseScale(self):
+        if self.failed: return 0.0
+        return self.memory_module.read_float(
+            self.instance.raw_address,
+            self.offset_base["EnvironmentDiffuseScale"]
+        )
+
+    @EnvironmentDiffuseScale.setter
+    def EnvironmentDiffuseScale(self, value: float):
+        if self.failed: return
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.instance.raw_address + self.offset_base["EnvironmentDiffuseScale"],
+            float(value)
+        )
+
+    @property
+    def EnvironmentSpecularScale(self):
+        if self.failed: return 0.0
+        return self.memory_module.read_float(
+            self.instance.raw_address,
+            self.offset_base["EnvironmentSpecularScale"]
+        )
+
+    @EnvironmentSpecularScale.setter
+    def EnvironmentSpecularScale(self, value: float):
+        if self.failed: return
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.instance.raw_address + self.offset_base["EnvironmentSpecularScale"],
+            float(value)
+        )
+
 class InputObject(RBXInstance):
     def __init__(self, raw_address: int, memory_module):
         super().__init__(raw_address, memory_module)

{robloxmemoryapi-0.2.2.1 → robloxmemoryapi-0.2.4/src/robloxmemoryapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.2.2.1
+Version: 0.2.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