trainerbase 3.6.2__tar.gz → 3.7.0__tar.gz

{trainerbase-3.6.2 → trainerbase-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trainerbase
-Version: 3.6.2
+Version: 3.7.0
 Summary: Framework for creating game trainers/mods
 Home-page: https://gitlab.com/python-trainers/trainer-base
 License: MIT

{trainerbase-3.6.2 → trainerbase-3.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trainerbase"
-version = "3.6.2"
+version = "3.7.0"
 description = "Framework for creating game trainers/mods"
 authors = ["v01d <v01d@v01d.ru>", "doomayka <zd@doomayka.ru>"]
 license = "MIT"

{trainerbase-3.6.2 → trainerbase-3.7.0}/trainerbase/codeinjection.py

@@ -3,14 +3,14 @@ from pathlib import Path
 from subprocess import DEVNULL
 from subprocess import run as run_executable
 from tempfile import TemporaryDirectory
-from typing import Never, Self, override
+from typing import Final, Never, Self, override
 
 from pymem.exception import MemoryWriteError
 
 from trainerbase.memory import ARCH, ConvertibleToAddress, ensure_address, pm
 
 
-FASM_EXECUTABLE_PATH = Path(__file__).resolve().parent.parent / "trainerbase_vendor" / "FASM.EXE"
+FASM_EXECUTABLE_PATH: Final[Path] = Path(__file__).resolve().parent.parent / "trainerbase_vendor" / "FASM.EXE"
 
 
 type Code = bytes | str

{trainerbase-3.6.2 → trainerbase-3.7.0}/trainerbase/gameobject.py

@@ -15,6 +15,7 @@ class AbstractReadableObject[T](ABC):
 
 class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseType]):
     tracked_objects: list[Self] = []
+    value_range: None | tuple[int | float, int | float] = None
 
     @staticmethod
     @abstractmethod
@@ -31,6 +32,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
         address: ConvertibleToAddress,
         frozen: TrainerBaseType | None = None,
         is_tracked: bool = True,
+        value_range: None | tuple[int | float, int | float] = None,
     ):
         if is_tracked:
             GameObject.tracked_objects.append(self)
@@ -39,6 +41,9 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
         self.frozen = frozen
         self.is_tracked = is_tracked
 
+        if value_range is not None:
+            self.value_range = value_range
+
     def __repr__(self):
         return (
             f"<{self.__class__.__name__}"
@@ -54,6 +59,17 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
     def before_write(self, value: TrainerBaseType) -> PymemType:
         return value  # type: ignore
 
+    def validate_range(self, value: TrainerBaseType) -> bool:
+        if self.value_range is None:
+            return True
+
+        if not isinstance(value, (int, float)):
+            raise TypeError(f"Unable to validate range for non-numeric value: {value} (type: {type(value)})")
+
+        min_value, max_value = self.value_range
+
+        return min_value <= value <= max_value
+
     @property
     @override
     def value(self) -> TrainerBaseType:
@@ -61,10 +77,14 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
 
     @value.setter
     def value(self, new_value: TrainerBaseType):
+        if not self.validate_range(new_value):
+            raise ValueError(f"Wrong value for type {type(self)}: {new_value} not in range {self.value_range}")
+
         self.pm_write(self.address.resolve(), self.before_write(new_value))
 
 
 class GameFloat(GameObject[float, float]):
+    value_range = (-3.4e38, 3.4e38)
     pm_read = pm.read_float  # type: ignore
     pm_write = pm.write_float
 
@@ -74,6 +94,7 @@ class GameFloat(GameObject[float, float]):
 
 
 class GameDouble(GameObject[float, float]):
+    value_range = (-1.7e308, 1.7e308)
     pm_read = pm.read_double  # type: ignore
     pm_write = pm.write_double
 
@@ -83,6 +104,8 @@ class GameDouble(GameObject[float, float]):
 
 
 class GameByte(GameObject[bytes, int]):
+    value_range = (0, 255)
+
     @staticmethod
     @override
     def pm_read(address: int) -> bytes:
@@ -103,36 +126,50 @@ class GameByte(GameObject[bytes, int]):
 
 
 class GameInt(GameObject[int, int]):
+    value_range = (-2_147_483_648, 2_147_483_647)
+
     pm_read = pm.read_int  # type: ignore
     pm_write = pm.write_int
 
 
 class GameShort(GameObject[int, int]):
+    value_range = (-32_768, 32_767)
+
     pm_read = pm.read_short  # type: ignore
     pm_write = pm.write_short
 
 
 class GameLongLong(GameObject[int, int]):
+    value_range = (-(2**63), (2**63) - 1)
+
     pm_read = pm.read_longlong  # type: ignore
     pm_write = pm.write_longlong
 
 
 class GameUnsignedInt(GameObject[int, int]):
+    value_range = (0, 4_294_967_295)
+
     pm_read = pm.read_uint  # type: ignore
     pm_write = pm.write_uint
 
 
 class GameUnsignedShort(GameObject[int, int]):
+    value_range = (0, 65_535)
+
     pm_read = pm.read_ushort  # type: ignore
     pm_write = pm.write_ushort
 
 
 class GameUnsignedLongLong(GameObject[int, int]):
+    value_range = (0, 18_446_744_073_709_551_615)
+
     pm_read = pm.read_ulonglong  # type: ignore
     pm_write = pm.write_ulonglong
 
 
 class GameBool(GameObject[bool, bool]):
+    value_range = (False, True)
+
     pm_read = pm.read_bool  # type: ignore
     pm_write = pm.write_bool
 

{trainerbase-3.6.2 → trainerbase-3.7.0}/trainerbase/gui.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
-from functools import partial, wraps
+from functools import wraps
 from typing import Any, Self, override
 from uuid import uuid4
 
@@ -153,6 +153,7 @@ class GameObjectUI(AbstractUIComponent):
         default_setter_input_value: Any = 0,
         before_set: Callable | None = None,
         tts_on_hotkey: bool = True,
+        setter_input_width: int = 220,
     ):
         if not gameobject.is_tracked:
             hotkey = None
@@ -164,6 +165,7 @@ class GameObjectUI(AbstractUIComponent):
         self.default_setter_input_value = default_setter_input_value
         self.before_set = before_set
         self.tts_on_hotkey = tts_on_hotkey
+        self.setter_input_width = setter_input_width
 
         dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
         self.dpg_tag_frozen = f"{dpg_tag}{self.DPG_TAG_POSTFIX_IS_FROZEN}"
@@ -175,29 +177,56 @@ class GameObjectUI(AbstractUIComponent):
         if self.hotkey is not None:
             add_hotkey(self.hotkey, self.on_hotkey_press)
 
-        match self.gameobject:
-            case GameFloat():
-                add_setter_input = dpg.add_input_float
-            case GameDouble():
-                add_setter_input = dpg.add_input_double
-            case GameByte() | GameShort() | GameInt() | GameLongLong() | GameBool():
-                add_setter_input = dpg.add_input_int
-            case GameUnsignedShort() | GameUnsignedInt() | GameUnsignedLongLong():
-                add_setter_input = partial(dpg.add_input_int, min_clamped=True, min_value=0)
-            case _:
-                add_setter_input = dpg.add_input_text
-
         with dpg.group(horizontal=True):
             if self.gameobject.is_tracked:
                 dpg.add_checkbox(tag=self.dpg_tag_frozen, callback=self.on_frozen_state_change)
 
             dpg.add_text(self.label_with_hotkey)
             dpg.add_input_text(width=220, tag=self.dpg_tag_getter, readonly=True)
-            add_setter_input(width=220, tag=self.dpg_tag_setter, default_value=self.default_setter_input_value)
+
+            self.add_setter_input()
+
             dpg.add_button(label="Set", callback=self.on_value_set)
 
         GameObjectUI.displayed_objects.append(self)
 
+    def add_setter_input(self):
+        default_kwargs = {
+            "tag": self.dpg_tag_setter,
+            "width": self.setter_input_width,
+            "default_value": self.default_setter_input_value,
+        }
+
+        if self.gameobject.value_range is not None:
+            min_value, max_value = self.gameobject.value_range
+            default_kwargs["min_clamped"] = True
+            default_kwargs["max_clamped"] = True
+            default_kwargs["min_value"] = min_value
+            default_kwargs["max_value"] = max_value
+
+        match self.gameobject:
+            case GameFloat():
+                dpg.add_input_float(**default_kwargs)
+            case GameDouble():
+                dpg.add_input_double(**default_kwargs)
+            case (
+                GameByte()
+                | GameShort()
+                | GameInt()
+                | GameLongLong()
+                | GameUnsignedShort()
+                | GameUnsignedInt()
+                | GameUnsignedLongLong()
+            ):
+                dpg.add_input_int(**default_kwargs)
+            case GameBool():
+                dpg.add_checkbox(
+                    tag=self.dpg_tag_setter,
+                    default_value=bool(self.default_setter_input_value),
+                )
+            case _:
+                dpg.add_input_text(**default_kwargs)
+
     def on_frozen_state_change(self):
         try:
             self.gameobject.frozen = self.gameobject.value if dpg.get_value(self.dpg_tag_frozen) else None
@@ -316,11 +345,13 @@ class SpeedHackUI(AbstractUIComponent):
 
     PRESETS: tuple[float, ...] = (0.1, 0.2, 0.3, 0.5, 1.0, 2.0, 3.0, 5.0, 10.0, 20.0, 50.0)
 
-    def __init__(self, speedhack: SpeedHack, key: str = "Delete", default_factor_input_value: float = 3.0):
-        self.speedhack = speedhack
+    def __init__(
+        self, speedhack: SpeedHack | None = None, key: str = "Delete", default_factor_input_value: float = 3.0
+    ):
+        self.speedhack = SpeedHack() if speedhack is None else speedhack
         self.key = key
         self.default_factor_input_value = default_factor_input_value
-        self.switch = ShortLongPressSwitch(SpeedHackUISwitch(speedhack, self.DPG_TAG_SPEEDHACK_FACTOR_INPUT), key)
+        self.switch = ShortLongPressSwitch(SpeedHackUISwitch(self.speedhack, self.DPG_TAG_SPEEDHACK_FACTOR_INPUT), key)
 
     @override
     def add_to_ui(self) -> None:

{trainerbase-3.6.2 → trainerbase-3.7.0}/trainerbase/memory.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from functools import partial
-from typing import Self, assert_never, override
+from typing import Final, Self, assert_never, override
 
 from pymem import Pymem
 from pymem.exception import ProcessNotFound
@@ -21,8 +21,8 @@ else:
     raise ProcessNotFound(f"not any: {pymem_config['process_names']}")
 
 
-ARCH = 64 if pm.is_64_bit else 32
-POINTER_SIZE = 8 if pm.is_64_bit else 4
+ARCH: Final[int] = 64 if pm.is_64_bit else 32
+POINTER_SIZE: Final[int] = 8 if pm.is_64_bit else 4
 
 
 type ConvertibleToAddress = AbstractAddress | int | bytes

{trainerbase-3.6.2 → trainerbase-3.7.0}/trainerbase/speedhack.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Self
+from typing import Final, Self
 
 from pyinjector import inject
 from pymem.exception import MemoryWriteError
@@ -9,9 +9,11 @@ from trainerbase.gameobject import GameDouble
 from trainerbase.memory import ARCH, pm
 
 
-SPEEDHACK_DLL_MODULE_NAME = f"speedhack{ARCH}.dll"
-SPEEDHACK_DLL_PATH = Path(__file__).resolve().parent.parent / "trainerbase_vendor" / SPEEDHACK_DLL_MODULE_NAME
-SPEED_MODIFIER_OFFSET = 0x40058 if ARCH == 32 else 0x47098
+SPEEDHACK_DLL_MODULE_NAME: Final[str] = f"speedhack{ARCH}.dll"
+SPEEDHACK_DLL_PATH: Final[Path] = (
+    Path(__file__).resolve().parent.parent / "trainerbase_vendor" / SPEEDHACK_DLL_MODULE_NAME
+)
+SPEED_MODIFIER_OFFSET: Final[int] = 0x40058 if ARCH == 32 else 0x47098
 
 
 class SpeedHack: