robloxmemoryapi 0.2.2__tar.gz → 0.2.3__tar.gz

{robloxmemoryapi-0.2.2/src/robloxmemoryapi.egg-info → robloxmemoryapi-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.2.2
+Version: 0.2.3
 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 → robloxmemoryapi-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robloxmemoryapi"
-version = "0.2.2"
+version = "0.2.3"
 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 → robloxmemoryapi-0.2.3}/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 → robloxmemoryapi-0.2.3}/src/robloxmemoryapi/utils/rbx/fflags.py

@@ -1,18 +1,20 @@
 from ..offsets import get_fflag_offsets
+from .datastructures import FFlag
 
 _MODULE_SIZE_LIMIT = 0x20000000
 
 # FLog level byte → display name.
 _FLOG_LEVELS = {
-    0: "None",
-    1: "Trace",
-    2: "Info",
+    2: "Error",
     3: "Warning",
-    4: "Error",
-    5: "Assert",
-    6: "Fatal",
+    4: "Info",
+    5: "Debug",
+    6: "Verbose",
+    255: "None",
 }
 
+_VALID_FLOG_LEVELS = set(_FLOG_LEVELS.keys())
+
 _FLOG_LEVELS_REV = {v: k for k, v in _FLOG_LEVELS.items()}
 
 def _decode_flog(raw_int: int) -> str:
@@ -32,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):
@@ -77,7 +68,11 @@ class FFlagManager:
                 return "bool", bool(raw[0])
             else:
                 raw_int = int.from_bytes(raw[0:4], "little")
-                return "string", _decode_flog(raw_int)
+                level_byte = (raw_int >> 8) & 0xFF
+                if level_byte in _VALID_FLOG_LEVELS:
+                    return "flog", _decode_flog(raw_int)
+                else:
+                    return "int", int.from_bytes(raw[0:4], "little", signed=True)
         else:
             str_len = int.from_bytes(raw[16:24], "little")
             str_cap = int.from_bytes(raw[24:32], "little")
@@ -104,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()
@@ -121,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
@@ -146,22 +141,21 @@ class FFlagManager:
             self._mem.write_int(addr, value)
 
         elif flag_type == "string":
-            if not isinstance(value, (str, int)):
-                raise TypeError(f"Expected str or int for flag '{name}', got {type(value).__name__}")
+            if not isinstance(value, str):
+                raise TypeError(f"Expected str for flag '{name}', got {type(value).__name__}")
 
-            _, current = self._reflect(name, offset)
-            is_flog = isinstance(current, str) and "," in current
+            self._mem.write_string(addr, str(value))
 
-            if is_flog:
-                self._mem.write_int(addr, _encode_flog(str(value)) if isinstance(value, str) else value)
-            else:
-                self._mem.write_string(addr, str(value))
+        elif flag_type == "flog":
+            if not isinstance(value, (str, int)):
+                raise TypeError(f"Expected str or int for flag '{name}', got {type(value).__name__}")
 
+            self._mem.write_int(addr, _encode_flog(str(value)) if isinstance(value, str) else value)
         else:
             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 → robloxmemoryapi-0.2.3}/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,8 @@ 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"]
 
 ROTATION_MATRIX_FLOATS = 9
 
@@ -141,6 +144,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 +189,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 +234,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 +250,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 +271,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 +292,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 +309,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 +319,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 +336,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 +375,16 @@ 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"]
+            )
         return None
 
     @Enabled.setter
@@ -383,8 +401,20 @@ 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)
+            )
         else:
-            raise AttributeError("Enabled is only available on ScreenGui or ProximityPrompt instances.")
+            raise AttributeError("Enabled is only available on ScreenGui, ProximityPrompt, Tool, or ColorCorrectionEffect instances.")
     
     @property
     def Visible(self):
@@ -420,7 +450,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 +463,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 +516,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 +524,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 +937,203 @@ 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)
+        )
+
     # humanoid props #
     @property
     def WalkSpeed(self):
@@ -1353,6 +1580,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 +1981,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 +2521,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)
         )
 
@@ -2469,6 +2755,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 → robloxmemoryapi-0.2.3/src/robloxmemoryapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.2.2
+Version: 0.2.3
 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