robloxmemoryapi 0.2.5__tar.gz → 0.2.6__tar.gz

{robloxmemoryapi-0.2.5/src/robloxmemoryapi.egg-info → robloxmemoryapi-0.2.6}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robloxmemoryapi"
-version = "0.2.5"
+version = "0.2.6"
 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.5 → robloxmemoryapi-0.2.6}/src/robloxmemoryapi/utils/offsets.py

@@ -5,24 +5,11 @@ BASE_URL = "https://imtheo.lol/Offsets"
 # Offsets
 OffsetsRequest = requests.get(f"{BASE_URL}/Offsets.json")
 
-# Legacy Offsets
-OldOffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
-try:
-    OldOffsets = OldOffsetsRequest.json()
-except:
-    OldOffsets = {}
-
 try:
     Offsets = OffsetsRequest.json()["Offsets"]
 except:
     Offsets = {}
 
-# Handle non-existant offsets
-try:
-    Offsets["Camera"]["ViewportSize"] = int(OldOffsets["ViewportSize"], 16)
-except:
-    Offsets["Camera"]["ViewportSize"] = 0x6AD28F
-
 # FFlag offsets (lazily loaded)
 _fflag_data = None
 _fflag_offsets = None

{robloxmemoryapi-0.2.5 → robloxmemoryapi-0.2.6}/src/robloxmemoryapi/utils/rbx/instance.py

@@ -27,6 +27,8 @@ spawnlocation_offsets = Offsets["SpawnLocation"]
 clothing_offsets = Offsets["Clothing"]
 charactermesh_offsets = Offsets["CharacterMesh"]
 attachment_offsets = Offsets["Attachment"]
+air_properties_offsets = Offsets["AirProperties"]
+seat_offsets = Offsets["Seat"]
 
 ROTATION_MATRIX_FLOATS = 9
 
@@ -404,6 +406,16 @@ class RBXInstance:
                 self.raw_address,
                 Offsets["ColorCorrectionEffect"]["Enabled"]
             )
+        elif self.ClassName == "BlurEffect":
+            return self.memory_module.read_bool(
+                self.raw_address,
+                Offsets["BlurEffect"]["Enabled"]
+            )
+        elif self.ClassName == "ColorGradingEffect":
+            return self.memory_module.read_bool(
+                self.raw_address,
+                Offsets["ColorGradingEffect"]["Enabled"]
+            )
         elif self.ClassName == "SpawnLocation":
             return self.memory_module.read_bool(
                 self.raw_address,
@@ -437,6 +449,18 @@ class RBXInstance:
                 self.raw_address + Offsets["ColorCorrectionEffect"]["Enabled"],
                 bool(value)
             )
+        elif self.ClassName == "BlurEffect":
+            self._ensure_writable()
+            self.memory_module.write_bool(
+                self.raw_address + Offsets["BlurEffect"]["Enabled"],
+                bool(value)
+            )
+        elif self.ClassName == "ColorGradingEffect":
+            self._ensure_writable()
+            self.memory_module.write_bool(
+                self.raw_address + Offsets["ColorGradingEffect"]["Enabled"],
+                bool(value)
+            )
         elif self.ClassName == "SpawnLocation":
             self._ensure_writable()
             self.memory_module.write_bool(
@@ -444,7 +468,7 @@ class RBXInstance:
                 bool(value)
             )
         else:
-            raise AttributeError("Enabled is only available on ScreenGui, ProximityPrompt, Tool, ColorCorrectionEffect, or SpawnLocation instances.")
+            raise AttributeError("Enabled is only available on ScreenGui, ProximityPrompt, Tool, ColorCorrectionEffect, BlurEffect, ColorGradingEffect, or SpawnLocation instances.")
     
     @property
     def Visible(self):
@@ -536,6 +560,12 @@ class RBXInstance:
             (vec.X, vec.Y)
         )
 
+    @property
+    def AbsoluteRotation(self):
+        return self.memory_module.read_float(
+            self.raw_address + gui_2d_offsets["AbsoluteRotation"]
+        )
+
     @property
     def Transparency(self):
         if "part" not in self.ClassName.lower():
@@ -937,15 +967,15 @@ class RBXInstance:
             self.raw_address + gui_offsets["BackgroundColor3"],
             3
         )
-        return Vector3(*color_data)
+        return Color3(*color_data)
 
     @BackgroundColor3.setter
     def BackgroundColor3(self, value):
         self._ensure_writable()
-        vec = self._as_vector3(value, "BackgroundColor3")
+        vec = self._as_color3(value, "BackgroundColor3")
         self.memory_module.write_floats(
             self.raw_address + gui_offsets["BackgroundColor3"],
-            (vec.X, vec.Y, vec.Z)
+            (vec.R, vec.G, vec.B)
         )
 
     @property
@@ -954,15 +984,15 @@ class RBXInstance:
             self.raw_address + gui_offsets["BorderColor3"],
             3
         )
-        return Vector3(*color_data)
+        return Color3(*color_data)
 
     @BorderColor3.setter
     def BorderColor3(self, value):
         self._ensure_writable()
-        vec = self._as_vector3(value, "BorderColor3")
+        vec = self._as_color3(value, "BorderColor3")
         self.memory_module.write_floats(
             self.raw_address + gui_offsets["BorderColor3"],
-            (vec.X, vec.Y, vec.Z)
+            (vec.R, vec.G, vec.B)
         )
 
     @property
@@ -971,15 +1001,15 @@ class RBXInstance:
             self.raw_address + gui_offsets["TextColor3"],
             3
         )
-        return Vector3(*color_data)
+        return Color3(*color_data)
 
     @TextColor3.setter
     def TextColor3(self, value):
         self._ensure_writable()
-        vec = self._as_vector3(value, "TextColor3")
+        vec = self._as_color3(value, "TextColor3")
         self.memory_module.write_floats(
             self.raw_address + gui_offsets["TextColor3"],
-            (vec.X, vec.Y, vec.Z)
+            (vec.R, vec.G, vec.B)
         )
 
     @property
@@ -1008,8 +1038,7 @@ class RBXInstance:
     @property
     def BackgroundTransparency(self):
         return self.memory_module.read_float(
-            self.raw_address,
-            gui_offsets["BackgroundTransparency"]
+            self.raw_address + gui_offsets["BackgroundTransparency"]
         )
 
     @BackgroundTransparency.setter
@@ -1023,8 +1052,7 @@ class RBXInstance:
     @property
     def ZIndex(self):
         return self.memory_module.read_int(
-            self.raw_address,
-            gui_offsets["ZIndex"]
+            self.raw_address + gui_offsets["ZIndex"]
         )
 
     @ZIndex.setter
@@ -1070,8 +1098,7 @@ class RBXInstance:
         if self.ClassName != "Tool":
             return None
         return self.memory_module.read_bool(
-            self.raw_address,
-            tool_offsets["ManualActivationOnly"]
+            self.raw_address + tool_offsets["ManualActivationOnly"]
         )
 
     @ManualActivationOnly.setter
@@ -1202,15 +1229,66 @@ class RBXInstance:
             (vec.X, vec.Y, vec.Z)
         )
 
+    # blureffect props #
+    @property
+    def BlurSize(self):
+        if self.ClassName != "BlurEffect":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address + Offsets["BlurEffect"]["Size"]
+        )
+
+    @BlurSize.setter
+    def BlurSize(self, value: float):
+        if self.ClassName != "BlurEffect":
+            raise AttributeError("BlurSize is only available on BlurEffect instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + Offsets["BlurEffect"]["Size"],
+            float(value)
+        )
+
+    # colorgradingeffect props #
+    @property
+    def TonemapperPreset(self):
+        if self.ClassName != "ColorGradingEffect":
+            return None
+        return self.memory_module.read_int(
+            self.raw_address + Offsets["ColorGradingEffect"]["TonemapperPreset"]
+        )
+
+    @TonemapperPreset.setter
+    def TonemapperPreset(self, value: int):
+        if self.ClassName != "ColorGradingEffect":
+            raise AttributeError("TonemapperPreset is only available on ColorGradingEffect instances.")
+        self._ensure_writable()
+        self.memory_module.write_int(
+            self.raw_address + Offsets["ColorGradingEffect"]["TonemapperPreset"],
+            int(value)
+        )
+
+    # seat props #
+    @property
+    def Occupant(self):
+        if self.ClassName != "Seat":
+            return None
+        ptr = self.memory_module.get_pointer(
+            self.raw_address,
+            seat_offsets["Occupant"]
+        )
+        if ptr == 0:
+            return None
+        return RBXInstance(ptr, self.memory_module)
 
     # charactermesh props #
     @property
     def BaseTextureId(self):
         if self.ClassName != "CharacterMesh":
             return None
-        return self.memory_module.read_long(
-            self.raw_address,
-            charactermesh_offsets["BaseTextureId"]
+        offset = charactermesh_offsets.get("BaseTextureId", 0)
+        if offset == 0: return None
+        return self.memory_module.read_string(
+            self.raw_address + offset
         )
 
     @BaseTextureId.setter
@@ -1218,18 +1296,21 @@ class RBXInstance:
         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)
+        offset = charactermesh_offsets.get("BaseTextureId", 0)
+        if offset == 0: return
+        self.memory_module.write_string(
+            self.raw_address + offset,
+            str(value)
         )
 
     @property
     def OverlayTextureId(self):
         if self.ClassName != "CharacterMesh":
             return None
-        return self.memory_module.read_long(
-            self.raw_address,
-            charactermesh_offsets["OverlayTextureId"]
+        offset = charactermesh_offsets.get("OverlayTextureId", 0)
+        if offset == 0: return None
+        return self.memory_module.read_string(
+            self.raw_address + offset
         )
 
     @OverlayTextureId.setter
@@ -1237,9 +1318,11 @@ class RBXInstance:
         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)
+        offset = charactermesh_offsets.get("OverlayTextureId", 0)
+        if offset == 0: return
+        self.memory_module.write_string(
+            self.raw_address + offset,
+            str(value)
         )
 
     @property
@@ -1255,9 +1338,10 @@ class RBXInstance:
     def CharacterMeshId(self):
         if self.ClassName != "CharacterMesh":
             return None
-        return self.memory_module.read_long(
-            self.raw_address,
-            charactermesh_offsets["MeshId"]
+        offset = charactermesh_offsets.get("MeshId", 0)
+        if offset == 0: return None
+        return self.memory_module.read_string(
+            self.raw_address + offset
         )
 
     # clothing props (Shirt/Pants) #
@@ -1735,6 +1819,272 @@ class RBXInstance:
             bool(value)
         )
 
+    @property
+    def AutoJumpEnabled(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            humanoid_offsets["AutoJumpEnabled"]
+        )
+
+    @AutoJumpEnabled.setter
+    def AutoJumpEnabled(self, value: bool):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("AutoJumpEnabled is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + humanoid_offsets["AutoJumpEnabled"],
+            bool(value)
+        )
+
+    @property
+    def BreakJointsOnDeath(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            humanoid_offsets["BreakJointsOnDeath"]
+        )
+
+    @BreakJointsOnDeath.setter
+    def BreakJointsOnDeath(self, value: bool):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("BreakJointsOnDeath is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + humanoid_offsets["BreakJointsOnDeath"],
+            bool(value)
+        )
+
+    @property
+    def CameraOffset(self):
+        if self.ClassName != "Humanoid":
+            return None
+        data = self.memory_module.read_floats(
+            self.raw_address + humanoid_offsets["CameraOffset"],
+            3
+        )
+        return Vector3(*data)
+
+    @CameraOffset.setter
+    def CameraOffset(self, value):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("CameraOffset is only available on Humanoid instances.")
+        self._ensure_writable()
+        vec = self._as_vector3(value, "CameraOffset")
+        self.memory_module.write_floats(
+            self.raw_address + humanoid_offsets["CameraOffset"],
+            (vec.X, vec.Y, vec.Z)
+        )
+
+    @property
+    def DisplayName(self):
+        """Humanoid display name label. Use PlayerClass.DisplayName for the player display name."""
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_string(
+            self.raw_address,
+            humanoid_offsets["DisplayName"]
+        )
+
+    @property
+    def EvaluateStateMachine(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            humanoid_offsets["EvaluateStateMachine"]
+        )
+
+    @EvaluateStateMachine.setter
+    def EvaluateStateMachine(self, value: bool):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("EvaluateStateMachine is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + humanoid_offsets["EvaluateStateMachine"],
+            bool(value)
+        )
+
+    @property
+    def HealthDisplayDistance(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            humanoid_offsets["HealthDisplayDistance"]
+        )
+
+    @HealthDisplayDistance.setter
+    def HealthDisplayDistance(self, value: float):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("HealthDisplayDistance is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + humanoid_offsets["HealthDisplayDistance"],
+            float(value)
+        )
+
+    @property
+    def HealthDisplayType(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_int(
+            self.raw_address,
+            humanoid_offsets["HealthDisplayType"]
+        )
+
+    @HealthDisplayType.setter
+    def HealthDisplayType(self, value: int):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("HealthDisplayType is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_int(
+            self.raw_address + humanoid_offsets["HealthDisplayType"],
+            int(value)
+        )
+
+    @property
+    def HumanoidRootPart(self):
+        if self.ClassName != "Humanoid":
+            return None
+        ptr = self.memory_module.get_pointer(
+            self.raw_address,
+            humanoid_offsets["HumanoidRootPart"]
+        )
+        if ptr == 0:
+            return None
+        return RBXInstance(ptr, self.memory_module)
+
+    @property
+    def NameDisplayDistance(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_float(
+            self.raw_address,
+            humanoid_offsets["NameDisplayDistance"]
+        )
+
+    @NameDisplayDistance.setter
+    def NameDisplayDistance(self, value: float):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("NameDisplayDistance is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_float(
+            self.raw_address + humanoid_offsets["NameDisplayDistance"],
+            float(value)
+        )
+
+    @property
+    def NameOcclusion(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_int(
+            self.raw_address,
+            humanoid_offsets["NameOcclusion"]
+        )
+
+    @NameOcclusion.setter
+    def NameOcclusion(self, value: int):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("NameOcclusion is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_int(
+            self.raw_address + humanoid_offsets["NameOcclusion"],
+            int(value)
+        )
+
+    @property
+    def PlatformStand(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            humanoid_offsets["PlatformStand"]
+        )
+
+    @PlatformStand.setter
+    def PlatformStand(self, value: bool):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("PlatformStand is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + humanoid_offsets["PlatformStand"],
+            bool(value)
+        )
+
+    @property
+    def RequiresNeck(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            humanoid_offsets["RequiresNeck"]
+        )
+
+    @RequiresNeck.setter
+    def RequiresNeck(self, value: bool):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("RequiresNeck is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + humanoid_offsets["RequiresNeck"],
+            bool(value)
+        )
+
+    @property
+    def SeatPart(self):
+        if self.ClassName != "Humanoid":
+            return None
+        ptr = self.memory_module.get_pointer(
+            self.raw_address,
+            humanoid_offsets["SeatPart"]
+        )
+        if ptr == 0:
+            return None
+        return RBXInstance(ptr, self.memory_module)
+
+    @property
+    def Sit(self):
+        if self.ClassName != "Humanoid":
+            return None
+        return self.memory_module.read_bool(
+            self.raw_address,
+            humanoid_offsets["Sit"]
+        )
+
+    @Sit.setter
+    def Sit(self, value: bool):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("Sit is only available on Humanoid instances.")
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.raw_address + humanoid_offsets["Sit"],
+            bool(value)
+        )
+
+    @property
+    def TargetPoint(self):
+        if self.ClassName != "Humanoid":
+            return None
+        data = self.memory_module.read_floats(
+            self.raw_address + humanoid_offsets["TargetPoint"],
+            3
+        )
+        return Vector3(*data)
+
+    @TargetPoint.setter
+    def TargetPoint(self, value):
+        if self.ClassName != "Humanoid":
+            raise AttributeError("TargetPoint is only available on Humanoid instances.")
+        self._ensure_writable()
+        vec = self._as_vector3(value, "TargetPoint")
+        self.memory_module.write_floats(
+            self.raw_address + humanoid_offsets["TargetPoint"],
+            (vec.X, vec.Y, vec.Z)
+        )
+
     @property
     def HumanoidState(self):
         if self.ClassName != "Humanoid":
@@ -2959,6 +3309,93 @@ class WorkspaceService(ServiceBase):
             float(value)
         )
 
+    @property
+    def FallenPartsDestroyHeight(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["FallenPartsDestroyHeight"]
+        )
+
+    @FallenPartsDestroyHeight.setter
+    def FallenPartsDestroyHeight(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["FallenPartsDestroyHeight"],
+            float(value)
+        )
+
+    def _get_air_properties(self):
+        """Returns the AirProperties pointer from World."""
+        World = self.memory_module.get_pointer(
+            self.instance.raw_address,
+            self.offset_base["World"]
+        )
+        return self.memory_module.get_pointer(
+            World,
+            world_offsets["AirProperties"]
+        )
+
+    @property
+    def AirDensity(self):
+        if self.failed:
+            return 0.0
+
+        air = self._get_air_properties()
+        return self.memory_module.read_float(
+            air,
+            air_properties_offsets["AirDensity"]
+        )
+
+    @AirDensity.setter
+    def AirDensity(self, value: float):
+        self._ensure_writable()
+        air = self._get_air_properties()
+        self.memory_module.write_float(
+            air + air_properties_offsets["AirDensity"],
+            float(value)
+        )
+
+    @property
+    def GlobalWind(self):
+        if self.failed:
+            return None
+
+        air = self._get_air_properties()
+        data = self.memory_module.read_floats(
+            air + air_properties_offsets["GlobalWind"],
+            3
+        )
+        return Vector3(*data)
+
+    @GlobalWind.setter
+    def GlobalWind(self, value):
+        self._ensure_writable()
+        if isinstance(value, Vector3):
+            v = value
+        elif isinstance(value, (tuple, list)) and len(value) == 3:
+            v = Vector3(*value)
+        else:
+            raise TypeError("GlobalWind must be a Vector3 or iterable of 3 numbers.")
+        air = self._get_air_properties()
+        self.memory_module.write_floats(
+            air + air_properties_offsets["GlobalWind"],
+            (v.X, v.Y, v.Z)
+        )
+
 class LightingService(ServiceBase):
     def __init__(self, memory_module, game: DataModel):
         super().__init__()
@@ -3230,6 +3667,23 @@ class LightingService(ServiceBase):
             float(value)
         )
 
+    @property
+    def GlobalShadows(self):
+        if self.failed: return None
+        return self.memory_module.read_bool(
+            self.instance.raw_address,
+            self.offset_base["GlobalShadows"]
+        )
+
+    @GlobalShadows.setter
+    def GlobalShadows(self, value: bool):
+        if self.failed: return
+        self._ensure_writable()
+        self.memory_module.write_bool(
+            self.instance.raw_address + self.offset_base["GlobalShadows"],
+            bool(value)
+        )
+
 class InputObject(RBXInstance):
     def __init__(self, raw_address: int, memory_module):
         super().__init__(raw_address, memory_module)

{robloxmemoryapi-0.2.5 → robloxmemoryapi-0.2.6/src/robloxmemoryapi.egg-info}/PKG-INFO

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