trainerbase 2.17.0__tar.gz → 3.1.0__tar.gz

{trainerbase-2.17.0 → trainerbase-3.1.0}/PKG-INFO

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

{trainerbase-2.17.0 → trainerbase-3.1.0}/pyproject.toml

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

{trainerbase-2.17.0 → trainerbase-3.1.0}/trainerbase/codeinjection.py

@@ -4,11 +4,10 @@ from subprocess import DEVNULL
 from subprocess import run as run_executable
 from tempfile import TemporaryDirectory
 from typing import Self, override
-from uuid import uuid4
 
 from pymem.exception import MemoryWriteError
 
-from trainerbase.memory import ARCH, AbstractAddress, ConvertibleToAddress, ensure_address, pm
+from trainerbase.memory import ARCH, ConvertibleToAddress, ensure_address, pm
 
 
 FASM_EXECUTABLE_PATH = Path(__file__).resolve().parent.parent / "vendor" / "FASM.EXE"
@@ -18,11 +17,7 @@ type Code = bytes | str
 
 
 class AbstractCodeInjection(ABC):
-    DPG_TAG_PREFIX = "injection__"
-
     created_code_injections: list[Self] = []
-    address: AbstractAddress
-    dpg_tag: str
 
     def __new__(cls, *_args, **_kwargs):
         instance = super().__new__(cls)
@@ -47,7 +42,6 @@ class CodeInjection(AbstractCodeInjection):
     ):
         self.address = ensure_address(address)
         self.code_to_inject = compile_asm(code_to_inject)
-        self.dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
         self.original_code: bytes = b""
         self._injected = False
 
@@ -75,7 +69,6 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
     ):
         self.address = ensure_address(address)
         self.code_to_inject = compile_asm(code_to_inject)
-        self.dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
         self.original_code: bytes = b""
 
         self.original_code_length = original_code_length
@@ -121,6 +114,21 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
             self.new_memory_address = 0
 
 
+class MultipleCodeInjection(AbstractCodeInjection):
+    def __init__(self, *injections: AbstractCodeInjection):
+        self._injections = injections
+
+    @override
+    def inject(self):
+        for injection in self._injections:
+            injection.inject()
+
+    @override
+    def eject(self):
+        for injection in self._injections:
+            injection.eject()
+
+
 def compile_asm(code: Code) -> bytes:
     if isinstance(code, str):
         fasm_mode = f"use{ARCH}"

{trainerbase-2.17.0 → trainerbase-3.1.0}/trainerbase/common.py

@@ -8,8 +8,8 @@ from typing import Self
 from keyboard import on_press_key, on_release_key
 from pymem.exception import MemoryReadError
 
-from trainerbase.gameobject import GameObject
-from trainerbase.scriptengine import Script
+from trainerbase.gameobject import AbstractReadableObject, GameObject
+from trainerbase.scriptengine import Script, system_script_engine
 
 
 type Coords[T: (int, float)] = tuple[T, T, T]
@@ -75,7 +75,8 @@ class Teleport:
         self.current_position: Coords | None = None
         self.movement_vector = Vector3(0, 0, 0)
         self.minimal_movement_vector_length = minimal_movement_vector_length
-        self.movement_vector_updater_script: Script | None = None
+
+        system_script_engine.register_script(Script(self.update_movement_vector, enabled=True))
 
     def set_coords(self, x: Number, y: Number, z: Number = 100) -> None:
         self.player_x.value = x
@@ -126,30 +127,35 @@ class Teleport:
         new_coords = Vector3(*self.get_coords()) + dash_movement_vector
         self.set_coords(*new_coords)
 
-    def create_movement_vector_updater_script(self) -> Script:
-        if self.movement_vector_updater_script is None:
-            self.movement_vector_updater_script = Script(self.update_movement_vector, enabled=True)
 
-        return self.movement_vector_updater_script
+class Switchable(ABC):
+    @abstractmethod
+    def enable(self):
+        pass
+
+    @abstractmethod
+    def disable(self):
+        pass
 
 
-class ShortLongSwitch(ABC):
-    def __init__(self, key: str, short_press_max_delta: float = 0.3, context: dict | None = None):
+class ShortLongPressSwitch:
+    def __init__(self, switchable: Switchable, key: str, short_press_max_delta: float = 0.3):
         self._key = key
         self._press_timestamp = None
         self._short_press_max_delta = short_press_max_delta
-        self._context = context or {}
+        self._switchable = switchable
+        self._enabled = False
 
     def _on_press(self, _):
         if self._press_timestamp is None:
             self._press_timestamp = time()
-        self.on_press(self._context)
+        self.on_press()
 
     def _on_release(self, _):
         if self._is_short_delta():
-            self.on_short_press(self._context)
+            self.on_short_press()
         else:
-            self.on_long_press(self._context)
+            self.on_long_press()
 
         self._press_timestamp = None
 
@@ -166,22 +172,25 @@ class ShortLongSwitch(ABC):
         on_release_key(self._key, self._on_release)
         on_press_key(self._key, self._on_press)
 
-    @abstractmethod
-    def on_press(self, context: dict):
-        pass
+    def on_press(self):
+        self._switchable.enable()
 
-    @abstractmethod
-    def on_short_press(self, context: dict):
-        pass
+    def on_short_press(self):
+        if self._enabled:
+            self._enabled = False
+            self._switchable.disable()
+        else:
+            self._enabled = True
+            self._switchable.enable()
 
-    @abstractmethod
-    def on_long_press(self, context: dict):
-        pass
+    def on_long_press(self):
+        self._enabled = False
+        self._switchable.disable()
 
 
 def regenerate(
     current_value: GameObject,
-    max_value: GameObject,
+    max_value: AbstractReadableObject,
     percent: Number,
     min_value: Number = 1,
 ):

{trainerbase-2.17.0 → trainerbase-3.1.0}/trainerbase/gameobject.py

@@ -1,17 +1,20 @@
 from abc import ABC, abstractmethod
 from typing import Self, override
-from uuid import uuid4
+
+from pymem.exception import MemoryWriteError
 
 from trainerbase.memory import ConvertibleToAddress, ensure_address, pm
 
 
-class GameObject[PymemType, TrainerBaseType](ABC):
-    DPG_TAG_PREFIX = "object__"
-    DPG_TAG_POSTFIX_IS_FROZEN = "__frozen"
-    DPG_TAG_POSTFIX_GETTER = "__getter"
-    DPG_TAG_POSTFIX_SETTER = "__setter"
+class AbstractReadableObject[T](ABC):
+    @property
+    @abstractmethod
+    def value(self) -> T:
+        pass
 
-    updated_objects: list[Self] = []
+
+class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseType]):
+    created_objects: list[Self] = []
 
     @staticmethod
     @abstractmethod
@@ -28,25 +31,17 @@ class GameObject[PymemType, TrainerBaseType](ABC):
         address: ConvertibleToAddress,
         frozen: TrainerBaseType | None = None,
     ):
-        GameObject.updated_objects.append(self)
+        GameObject.created_objects.append(self)
 
         self.address = ensure_address(address)
         self.frozen = frozen
 
-        dpg_tag = f"{GameObject.DPG_TAG_PREFIX}{uuid4()}"
-        self.dpg_tag_frozen = f"{dpg_tag}{GameObject.DPG_TAG_POSTFIX_IS_FROZEN}"
-        self.dpg_tag_getter = f"{dpg_tag}{GameObject.DPG_TAG_POSTFIX_GETTER}"
-        self.dpg_tag_setter = f"{dpg_tag}{GameObject.DPG_TAG_POSTFIX_SETTER}"
-
     def __repr__(self):
         return (
             f"<{self.__class__.__name__}"
             f" at {hex(self.address.resolve())}:"
             f" value={self.value},"
-            f" frozen={self.frozen},"
-            f" dpg_tag_frozen={self.dpg_tag_frozen},"
-            f" dpg_tag_getter={self.dpg_tag_getter}"
-            f" dpg_tag_setter={self.dpg_tag_setter}"
+            f" frozen={self.frozen}"
             ">"
         )
 
@@ -57,6 +52,7 @@ class GameObject[PymemType, TrainerBaseType](ABC):
         return value  # type: ignore
 
     @property
+    @override
     def value(self) -> TrainerBaseType:
         return self.after_read(self.pm_read(self.address.resolve()))
 
@@ -136,3 +132,21 @@ class GameUnsignedLongLong(GameObject[int, int]):
 class GameBool(GameObject[bool, bool]):
     pm_read = pm.read_bool  # type: ignore
     pm_write = pm.write_bool
+
+
+class ReadonlyGameObjectSumGetter(AbstractReadableObject[int | float]):
+    def __init__(self, *game_numbers: GameInt | GameFloat):
+        self.game_numbers = game_numbers
+
+    @property
+    def value(self) -> int | float:
+        return sum(number.value for number in self.game_numbers)
+
+
+def update_frozen_objects():
+    for game_object in GameObject.created_objects:
+        if game_object.frozen is not None:
+            try:
+                game_object.value = game_object.frozen
+            except MemoryWriteError:
+                continue

trainerbase-3.1.0/trainerbase/gui.py

@@ -0,0 +1,370 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from functools import partial, wraps
+from typing import Any, Self, override
+from uuid import uuid4
+
+from dearpygui import dearpygui as dpg
+from keyboard import add_hotkey
+from pymem.exception import MemoryReadError
+
+from trainerbase.codeinjection import AbstractCodeInjection
+from trainerbase.common import ShortLongPressSwitch, Switchable, Teleport
+from trainerbase.gameobject import (
+    GameBool,
+    GameByte,
+    GameDouble,
+    GameFloat,
+    GameInt,
+    GameLongLong,
+    GameObject,
+    GameShort,
+    GameUnsignedInt,
+    GameUnsignedLongLong,
+    GameUnsignedShort,
+)
+from trainerbase.scriptengine import Script
+from trainerbase.speedhack import SpeedHack
+from trainerbase.tts import say
+
+
+TAG_TELEPORT_LABELS = "__teleport_labels"
+TAG_SPEEDHACK_FACTOR_INPUT = "tag_speedhack_factor_input"
+
+
+class AbstractUIComponent(ABC):
+    @abstractmethod
+    def add_to_ui(self) -> None:
+        pass
+
+
+class ScriptUI(AbstractUIComponent):
+    DPG_TAG_PREFIX = "script__"
+
+    def __init__(
+        self,
+        script: Script,
+        label: str,
+        hotkey: str | None = None,
+        tts_on_hotkey: bool = True,
+    ):
+        self.script = script
+        self.pure_label = label
+        self.label_with_hotkey = label if hotkey is None else f"[{hotkey}] {label}"
+        self.hotkey = hotkey
+        self.tts_on_hotkey = tts_on_hotkey
+
+        self.dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
+
+    @override
+    def add_to_ui(self) -> None:
+        if self.hotkey is not None:
+            add_hotkey(self.hotkey, self.on_hotkey_press)
+
+        dpg.add_checkbox(
+            label=self.label_with_hotkey,
+            tag=self.dpg_tag,
+            callback=self.on_script_state_change,
+            default_value=self.script.enabled,
+        )
+
+    def on_script_state_change(self):
+        self.script.enabled = dpg.get_value(self.dpg_tag)
+
+    def on_hotkey_press(self):
+        dpg.set_value(self.dpg_tag, not dpg.get_value(self.dpg_tag))
+
+        self.on_script_state_change()
+
+        if self.tts_on_hotkey:
+            status = "enabled" if self.script.enabled else "disabled"
+            say(f"Script {self.pure_label} {status}")
+
+
+class CodeInjectionUI(AbstractUIComponent):
+    DPG_TAG_PREFIX = "injection__"
+
+    def __init__(
+        self,
+        injection: AbstractCodeInjection,
+        label: str,
+        hotkey: str | None = None,
+        tts_on_hotkey: bool = True,
+    ):
+        self.injection = injection
+        self.pure_label = label
+        self.label_with_hotkey = label if hotkey is None else f"[{hotkey}] {label}"
+        self.hotkey = hotkey
+        self.tts_on_hotkey = tts_on_hotkey
+
+        self.dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
+
+    @override
+    def add_to_ui(self) -> None:
+        if self.hotkey is not None:
+            add_hotkey(self.hotkey, self.on_hotkey_press)
+
+        dpg.add_checkbox(label=self.label_with_hotkey, tag=self.dpg_tag, callback=self.on_codeinjection_state_change)
+
+    def on_codeinjection_state_change(self):
+        if dpg.get_value(self.dpg_tag):
+            self.injection.inject()
+        else:
+            self.injection.eject()
+
+    def on_hotkey_press(self):
+        dpg.set_value(self.dpg_tag, not dpg.get_value(self.dpg_tag))
+        self.on_codeinjection_state_change()
+
+        if self.tts_on_hotkey:
+            status = "applied" if dpg.get_value(self.dpg_tag) else "removed"
+            say(f"CodeInjection {self.pure_label} {status}")
+
+
+class GameObjectUI(AbstractUIComponent):
+    DPG_TAG_PREFIX = "object__"
+    DPG_TAG_POSTFIX_IS_FROZEN = "__frozen"
+    DPG_TAG_POSTFIX_GETTER = "__getter"
+    DPG_TAG_POSTFIX_SETTER = "__setter"
+
+    displayed_objects: list[Self] = []
+
+    def __init__(
+        self,
+        gameobject: GameObject,
+        label: str,
+        hotkey: str | None = None,
+        default_setter_input_value: Any = 0,
+        before_set: Callable = int,
+        tts_on_hotkey: bool = True,
+    ):
+        self.gameobject = gameobject
+        self.pure_label = label
+        self.label_with_hotkey = label if hotkey is None else f"[{hotkey}] {label}"
+        self.hotkey = hotkey
+        self.default_setter_input_value = default_setter_input_value
+        self.before_set = before_set
+        self.tts_on_hotkey = tts_on_hotkey
+
+        dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
+        self.dpg_tag_frozen = f"{dpg_tag}{self.DPG_TAG_POSTFIX_IS_FROZEN}"
+        self.dpg_tag_getter = f"{dpg_tag}{self.DPG_TAG_POSTFIX_GETTER}"
+        self.dpg_tag_setter = f"{dpg_tag}{self.DPG_TAG_POSTFIX_SETTER}"
+
+    @override
+    def add_to_ui(self) -> None:
+        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):
+            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)
+            dpg.add_button(label="Set", callback=self.on_value_set)
+
+        GameObjectUI.displayed_objects.append(self)
+
+    def on_frozen_state_change(self):
+        self.gameobject.frozen = self.gameobject.value if dpg.get_value(self.dpg_tag_frozen) else None
+
+    def on_value_set(self):
+        new_value = self.before_set(dpg.get_value(self.dpg_tag_setter))
+
+        if self.gameobject.frozen is None:
+            self.gameobject.value = new_value
+        else:
+            self.gameobject.frozen = new_value
+
+    def on_hotkey_press(self):
+        dpg.set_value(self.dpg_tag_frozen, not dpg.get_value(self.dpg_tag_frozen))
+
+        self.on_frozen_state_change()
+
+        if self.tts_on_hotkey:
+            status = "released" if self.gameobject.frozen is None else "frozen"
+            say(f"GameObject {self.pure_label} {status}")
+
+
+class TeleportUI(AbstractUIComponent):
+    def __init__(
+        self,
+        tp: Teleport,
+        hotkey_save_position: str | None = None,
+        hotkey_set_saved_position: str | None = None,
+        hotkey_dash: str | None = None,
+        tts_on_hotkey: bool = True,
+    ):
+        self.tp = tp
+        self.hotkey_save_position = hotkey_save_position
+        self.hotkey_set_saved_position = hotkey_set_saved_position
+        self.hotkey_dash = hotkey_dash
+        self.tts_on_hotkey = tts_on_hotkey
+
+    @override
+    def add_to_ui(self) -> None:
+        self._tp_add_save_set_position_hotkeys_if_needed()
+        self._tp_add_dash_hotkeys_if_needed()
+
+        add_components(
+            GameObjectUI(self.tp.player_x, "X"),
+            GameObjectUI(self.tp.player_y, "Y"),
+            GameObjectUI(self.tp.player_z, "Z"),
+        )
+
+        self._tp_add_labels_if_needed()
+
+        dpg.add_button(label="Clip Coords", callback=self.on_clip_coords)
+
+    def on_clip_coords(self):
+        dpg.set_clipboard_text(repr(self.tp.get_coords()))
+
+    def on_hotkey_save_position_press(self):
+        self.tp.save_position()
+
+        if self.tts_on_hotkey:
+            say("Position saved")
+
+    def on_hotkey_set_saved_position_press(self):
+        is_position_restored = self.tp.restore_saved_position()
+
+        if self.tts_on_hotkey:
+            say("Position restored" if is_position_restored else "Save position at first")
+
+    def on_hotkey_dash_press(self):
+        self.tp.dash()
+        if self.tts_on_hotkey:
+            say("Dash!")
+
+    def on_goto_label(self):
+        self.tp.goto(dpg.get_value(TAG_TELEPORT_LABELS))
+
+    def _tp_add_save_set_position_hotkeys_if_needed(self):
+        if self.hotkey_save_position is None or self.hotkey_set_saved_position is None:
+            return
+
+        add_hotkey(self.hotkey_save_position, self.on_hotkey_save_position_press)
+        add_hotkey(self.hotkey_set_saved_position, self.on_hotkey_set_saved_position_press)
+
+        dpg.add_text(f"[{self.hotkey_save_position}] Save Position")
+        dpg.add_text(f"[{self.hotkey_set_saved_position}] Set Saved Position")
+
+    def _tp_add_dash_hotkeys_if_needed(self):
+        if self.hotkey_dash is None:
+            return
+
+        add_hotkey(self.hotkey_dash, self.on_hotkey_dash_press)
+
+        dpg.add_text(f"[{self.hotkey_dash}] Dash")
+
+    def _tp_add_labels_if_needed(self):
+        if not self.tp.labels:
+            return
+
+        labels = sorted(self.tp.labels.keys())
+
+        with dpg.group(horizontal=True):
+            dpg.add_button(label="Go To", callback=self.on_goto_label)
+            dpg.add_combo(label="Labels", tag=TAG_TELEPORT_LABELS, items=labels, default_value=labels[0])
+
+
+class SpeedHackUI(AbstractUIComponent):
+    def __init__(self, speedhack: SpeedHack, key: str):
+        self.speedhack = speedhack
+        self.key = key
+        self.switch = ShortLongPressSwitch(SpeedHackUISwitch(speedhack, TAG_SPEEDHACK_FACTOR_INPUT), key)
+
+    @override
+    def add_to_ui(self) -> None:
+        dpg.add_text(f"Hold [{self.key}] Enable SpeedHack")
+        dpg.add_text(f"Press [{self.key}] Toggle SpeedHack")
+
+        dpg.add_input_double(
+            tag=TAG_SPEEDHACK_FACTOR_INPUT,
+            label="SpeedHack Factor",
+            min_value=0.0,
+            max_value=100.0,
+            default_value=3.0,
+            min_clamped=True,
+            max_clamped=True,
+        )
+
+        self.switch.handle()
+
+
+class SpeedHackUISwitch(Switchable):
+    def __init__(self, speedhack: SpeedHack, dpg_tag: str):
+        self.speedhack = speedhack
+        self.dpg_tag = dpg_tag
+
+    @override
+    def enable(self):
+        self.speedhack.factor = dpg.get_value(self.dpg_tag)
+
+    @override
+    def disable(self):
+        self.speedhack.factor = 1.0
+
+
+def add_components(*components: AbstractUIComponent):
+    for component in components:
+        component.add_to_ui()
+
+
+def simple_trainerbase_menu(window_title: str, width: int, height: int):
+    def menu_decorator(initializer: Callable):
+        @wraps(initializer)
+        def run_menu_wrapper(on_initialized: Callable):
+            dpg.create_context()
+            dpg.create_viewport(
+                title=window_title,
+                min_width=width,
+                min_height=height,
+                width=width,
+                height=height,
+            )
+            dpg.setup_dearpygui()
+
+            with dpg.window(
+                label=window_title,
+                tag="menu",
+                min_size=[width, height],
+                no_close=True,
+                no_move=True,
+                no_title_bar=True,
+                horizontal_scrollbar=True,
+            ):
+                initializer()
+
+            dpg.show_viewport()
+
+            on_initialized()
+
+            dpg.start_dearpygui()
+            dpg.destroy_context()
+
+        return run_menu_wrapper
+
+    return menu_decorator
+
+
+def update_displayed_objects():
+    for game_object_ui in GameObjectUI.displayed_objects:
+        try:
+            new_value = game_object_ui.gameobject.value
+        except MemoryReadError:
+            new_value = "<Unresolved>"
+
+        dpg.set_value(game_object_ui.dpg_tag_getter, new_value)

trainerbase-3.1.0/trainerbase/main.py

@@ -0,0 +1,37 @@
+from collections.abc import Callable
+from functools import partial
+from os import _exit as force_exit
+from typing import NoReturn
+
+from trainerbase.codeinjection import safely_eject_all_code_injections
+from trainerbase.gameobject import update_frozen_objects
+from trainerbase.gui import update_displayed_objects
+from trainerbase.scriptengine import Script, system_script_engine
+from trainerbase.speedhack import SpeedHack
+
+
+def run(
+    run_gui: Callable[[Callable], None],
+    on_gui_initialized_hook: Callable | None = None,
+    on_shutdown_hook: Callable | None = None,
+) -> NoReturn:
+    system_script_engine.register_script(Script(update_frozen_objects, enabled=True))
+    system_script_engine.register_script(Script(update_displayed_objects, enabled=True))
+
+    run_gui(partial(on_gui_initialized, on_gui_initialized_hook))
+
+    system_script_engine.stop()
+    safely_eject_all_code_injections()
+    SpeedHack.disable()
+
+    if on_shutdown_hook is not None:
+        on_shutdown_hook()
+
+    force_exit(0)
+
+
+def on_gui_initialized(on_gui_initialized_hook: Callable | None = None):
+    system_script_engine.start()
+
+    if on_gui_initialized_hook is not None:
+        on_gui_initialized_hook()

{trainerbase-2.17.0 → trainerbase-3.1.0}/trainerbase/scriptengine.py

@@ -1,29 +1,17 @@
 from collections.abc import Callable
 from threading import Thread
 from time import sleep
-from uuid import uuid4
 
-from dearpygui import dearpygui as dpg
 from pymem.exception import MemoryReadError, MemoryWriteError
 
-from trainerbase.gameobject import GameObject
-
 
 class Script:
-    DPG_TAG_PREFIX = "script__"
-
     def __init__(self, callback: Callable, enabled: bool = False):
         self.callback = callback
         self.enabled = enabled
-        self.dpg_tag = f"{Script.DPG_TAG_PREFIX}{uuid4()}"
 
     def __repr__(self):
-        return (
-            f"<Script {getattr(self.callback, '__name__', 'Anon')}:"
-            f" enabled={self.enabled},"
-            f" dpg_tag={repr(self.dpg_tag)}"
-            f">"
-        )
+        return f"<Script {getattr(self.callback, '__name__', 'Anon')}:" f" enabled={self.enabled}" f">"
 
     def __call__(self):
         return self.callback()
@@ -72,27 +60,3 @@ class ScriptEngine:
 
 
 system_script_engine = ScriptEngine()
-
-
-@system_script_engine.simple_script
-def update_frozen_objects():
-    for game_object in GameObject.updated_objects:
-        if game_object.frozen is not None:
-            try:
-                game_object.value = game_object.frozen
-            except MemoryWriteError:
-                continue
-
-
-@system_script_engine.simple_script
-def update_displayed_objects():
-    for game_object in GameObject.updated_objects:
-        if dpg.does_alias_exist(game_object.dpg_tag_getter):
-            try:
-                dpg.set_value(game_object.dpg_tag_getter, game_object.value)
-            except MemoryReadError:
-                dpg.set_value(game_object.dpg_tag_getter, "<Unresolved>")
-
-
-update_frozen_objects.enabled = True
-update_displayed_objects.enabled = True

{trainerbase-2.17.0 → trainerbase-3.1.0}/trainerbase/speedhack.py

@@ -1,11 +1,10 @@
 from pathlib import Path
-from typing import override
+from typing import Self
 
 from pyinjector import inject
 from pymem.exception import MemoryWriteError
 from pymem.process import module_from_name
 
-from trainerbase.common import ShortLongSwitch
 from trainerbase.gameobject import GameDouble
 from trainerbase.memory import ARCH, pm
 
@@ -16,6 +15,14 @@ SPEED_MODIFIER_OFFSET = 0x78048 if ARCH == 32 else 0x86040
 
 
 class SpeedHack:
+    _instance: Self | None = None
+
+    def __new__(cls, *_args, **_kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+
+        return cls._instance
+
     def __init__(self):
         self._dll_injection_address = self._inject()
         self._speed_modifier = GameDouble(self._dll_injection_address + SPEED_MODIFIER_OFFSET)
@@ -37,35 +44,13 @@ class SpeedHack:
     def factor(self, value: float):
         self._speed_modifier.value = value
 
-    def disable(self):
+    @classmethod
+    def disable(cls):
+        if cls._instance is None:
+            return
+
         # TODO: Should I eject dll?
         try:
-            self.factor = 1.0
+            cls._instance.factor = 1.0
         except MemoryWriteError:
             pass
-
-
-class SpeedHackShortLongSwitch(ShortLongSwitch):
-    @override
-    def on_press(self, context: dict):
-        speedhack = context["speedhack"]
-        dpg_tag = context["dpg_tag"]
-        dpg = context["dpg"]
-        speedhack.factor = dpg.get_value(dpg_tag)
-
-    @override
-    def on_short_press(self, context: dict):
-        speedhack = context["speedhack"]
-
-        if context["enabled"]:
-            context["enabled"] = False
-            speedhack.factor = 1.0
-        else:
-            context["enabled"] = True
-            speedhack.factor = context["dpg"].get_value(context["dpg_tag"])
-
-    @override
-    def on_long_press(self, context: dict):
-        speedhack = context["speedhack"]
-        context["enabled"] = False
-        speedhack.factor = 1.0

trainerbase-2.17.0/trainerbase/gui.py

@@ -1,277 +0,0 @@
-from collections.abc import Callable
-from functools import partial, wraps
-from typing import Any
-
-from dearpygui import dearpygui as dpg
-from keyboard import add_hotkey
-
-from trainerbase.codeinjection import AbstractCodeInjection
-from trainerbase.common import Teleport
-from trainerbase.gameobject import (
-    GameBool,
-    GameByte,
-    GameDouble,
-    GameFloat,
-    GameInt,
-    GameLongLong,
-    GameObject,
-    GameShort,
-    GameUnsignedInt,
-    GameUnsignedLongLong,
-    GameUnsignedShort,
-)
-from trainerbase.scriptengine import Script
-from trainerbase.speedhack import SpeedHack, SpeedHackShortLongSwitch
-from trainerbase.tts import say
-
-
-TAG_TELEPORT_LABELS = "__teleport_labels"
-TAG_SPEEDHACK_FACTOR_INPUT = "tag_speedhack_factor_input"
-
-
-def simple_trainerbase_menu(window_title: str, width: int, height: int):
-    def menu_decorator(initializer: Callable):
-        @wraps(initializer)
-        def run_menu_wrapper(on_initialized: Callable):
-            dpg.create_context()
-            dpg.create_viewport(
-                title=window_title,
-                min_width=width,
-                min_height=height,
-                width=width,
-                height=height,
-            )
-            dpg.setup_dearpygui()
-
-            with dpg.window(
-                label=window_title,
-                tag="menu",
-                min_size=[width, height],
-                no_close=True,
-                no_move=True,
-                no_title_bar=True,
-                horizontal_scrollbar=True,
-            ):
-                initializer()
-
-            dpg.show_viewport()
-
-            on_initialized()
-
-            dpg.start_dearpygui()
-            dpg.destroy_context()
-
-        return run_menu_wrapper
-
-    return menu_decorator
-
-
-def add_script_to_gui(
-    script: Script,
-    label: str,
-    hotkey: str | None = None,
-    tts_on_hotkey: bool = True,
-):
-    def on_script_state_change():
-        script.enabled = dpg.get_value(script.dpg_tag)
-
-    if hotkey is not None:
-        pure_label = label
-
-        def on_hotkey_press():
-            dpg.set_value(script.dpg_tag, not dpg.get_value(script.dpg_tag))
-            on_script_state_change()
-            if tts_on_hotkey:
-                status = "enabled" if script.enabled else "disabled"
-                say(f"Script {pure_label} {status}")
-
-        add_hotkey(hotkey, on_hotkey_press)
-
-        label = f"[{hotkey}] {label}"
-
-    dpg.add_checkbox(label=label, tag=script.dpg_tag, callback=on_script_state_change, default_value=script.enabled)
-
-
-def add_gameobject_to_gui(
-    gameobject: GameObject,
-    label: str,
-    hotkey: str | None = None,
-    default_setter_input_value: Any = 0,
-    before_set: Callable = int,
-    tts_on_hotkey: bool = True,
-):
-    def on_frozen_state_change():
-        gameobject.frozen = gameobject.value if dpg.get_value(gameobject.dpg_tag_frozen) else None
-
-    def on_value_set():
-        new_value = before_set(dpg.get_value(gameobject.dpg_tag_setter))
-
-        if gameobject.frozen is None:
-            gameobject.value = new_value
-        else:
-            gameobject.frozen = new_value
-
-    if hotkey is not None:
-        pure_label = label
-
-        def on_hotkey_press():
-            dpg.set_value(gameobject.dpg_tag_frozen, not dpg.get_value(gameobject.dpg_tag_frozen))
-            on_frozen_state_change()
-            if tts_on_hotkey:
-                status = "released" if gameobject.frozen is None else "frozen"
-                say(f"GameObject {pure_label} {status}")
-
-        add_hotkey(hotkey, on_hotkey_press)
-
-        label = f"[{hotkey}] {label}"
-
-    match 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):
-        dpg.add_checkbox(tag=gameobject.dpg_tag_frozen, callback=on_frozen_state_change)
-        dpg.add_text(label)
-        dpg.add_input_text(width=220, tag=gameobject.dpg_tag_getter, readonly=True)
-        add_setter_input(width=220, tag=gameobject.dpg_tag_setter, default_value=default_setter_input_value)
-        dpg.add_button(label="Set", callback=on_value_set)
-
-
-def add_codeinjection_to_gui(
-    injection: AbstractCodeInjection,
-    label: str,
-    hotkey: str | None = None,
-    tts_on_hotkey: bool = True,
-):
-    def on_codeinjection_state_change():
-        if dpg.get_value(injection.dpg_tag):
-            injection.inject()
-        else:
-            injection.eject()
-
-    if hotkey is not None:
-        pure_label = label
-
-        def on_hotkey_press():
-            dpg.set_value(injection.dpg_tag, not dpg.get_value(injection.dpg_tag))
-            on_codeinjection_state_change()
-            if tts_on_hotkey:
-                status = "applied" if dpg.get_value(injection.dpg_tag) else "removed"
-                say(f"CodeInjection {pure_label} {status}")
-
-        add_hotkey(hotkey, on_hotkey_press)
-
-        label = f"[{hotkey}] {label}"
-
-    dpg.add_checkbox(label=label, tag=injection.dpg_tag, callback=on_codeinjection_state_change)
-
-
-def add_teleport_to_gui(
-    tp: Teleport,
-    hotkey_save_position: str | None = None,
-    hotkey_set_saved_position: str | None = None,
-    hotkey_dash: str | None = None,
-    tts_on_hotkey: bool = True,
-):
-    _tp_add_save_set_position_hotkeys_if_needed(tp, hotkey_save_position, hotkey_set_saved_position, tts_on_hotkey)
-    _tp_add_dash_hotkeys_if_needed(tp, hotkey_dash, tts_on_hotkey)
-
-    add_gameobject_to_gui(tp.player_x, "X")
-    add_gameobject_to_gui(tp.player_y, "Y")
-    add_gameobject_to_gui(tp.player_z, "Z")
-
-    _tp_add_labels_if_needed(tp)
-
-    def on_clip_coords():
-        dpg.set_clipboard_text(repr(tp.get_coords()))
-
-    dpg.add_button(label="Clip Coords", callback=on_clip_coords)
-
-
-def _tp_add_save_set_position_hotkeys_if_needed(
-    tp: Teleport,
-    hotkey_save_position: str | None,
-    hotkey_set_saved_position: str | None,
-    tts_on_hotkey: bool,
-):
-    if hotkey_save_position is None or hotkey_set_saved_position is None:
-        return
-
-    def on_hotkey_save_position_press():
-        tp.save_position()
-        if tts_on_hotkey:
-            say("Position saved")
-
-    def on_hotkey_set_saved_position_press():
-        is_position_restored = tp.restore_saved_position()
-
-        if tts_on_hotkey:
-            say("Position restored" if is_position_restored else "Save position at first")
-
-    add_hotkey(hotkey_save_position, on_hotkey_save_position_press)
-    add_hotkey(hotkey_set_saved_position, on_hotkey_set_saved_position_press)
-
-    dpg.add_text(f"[{hotkey_save_position}] Save Position")
-    dpg.add_text(f"[{hotkey_set_saved_position}] Set Saved Position")
-
-
-def _tp_add_dash_hotkeys_if_needed(tp, hotkey_dash: str | None, tts_on_hotkey: bool):
-    if tp.movement_vector_updater_script is None or hotkey_dash is None:
-        return
-
-    def on_hotkey_dash_press():
-        tp.dash()
-        if tts_on_hotkey:
-            say("Dash!")
-
-    add_hotkey(hotkey_dash, on_hotkey_dash_press)
-
-    dpg.add_text(f"[{hotkey_dash}] Dash")
-
-
-def _tp_add_labels_if_needed(tp: Teleport):
-    if not tp.labels:
-        return
-
-    def on_goto_label():
-        tp.goto(dpg.get_value(TAG_TELEPORT_LABELS))
-
-    labels = sorted(tp.labels.keys())
-
-    with dpg.group(horizontal=True):
-        dpg.add_button(label="Go To", callback=on_goto_label)
-        dpg.add_combo(label="Labels", tag=TAG_TELEPORT_LABELS, items=labels, default_value=labels[0])
-
-
-def add_speedhack_to_gui(speedhack: SpeedHack, key: str):
-    switch = SpeedHackShortLongSwitch(
-        key,
-        context={
-            "speedhack": speedhack,
-            "dpg_tag": TAG_SPEEDHACK_FACTOR_INPUT,
-            "enabled": False,
-            "dpg": dpg,
-        },
-    )
-    switch.handle()
-
-    dpg.add_text(f"Hold [{key}] Enable SpeedHack")
-    dpg.add_text(f"Press [{key}] Toggle SpeedHack")
-
-    dpg.add_input_double(
-        tag=TAG_SPEEDHACK_FACTOR_INPUT,
-        label="SpeedHack Factor",
-        min_value=0.0,
-        max_value=100.0,
-        default_value=3.0,
-        min_clamped=True,
-        max_clamped=True,
-    )