trainerbase 3.16.2__tar.gz → 4.0.0__tar.gz

{trainerbase-3.16.2 → trainerbase-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trainerbase
-Version: 3.16.2
+Version: 4.0.0
 Summary: Framework for creating game trainers/mods
 Home-page: https://gitlab.com/python-trainers/trainer-base
 License: MIT
@@ -12,10 +12,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: dearpygui (>=1.11.1,<2.0.0)
 Requires-Dist: keyboard (>=0.13.5,<0.14.0)
+Requires-Dist: mouse (>=0.7.1,<0.8.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: pyinjector (>=1.3.0,<2.0.0)
 Requires-Dist: pymem (>=1.13.1,<2.0.0)
-Requires-Dist: pyttsx3 (>=2.90,<3.0)
+Requires-Dist: pyttsx3 (>=2.98,<3.0)
 Project-URL: Repository, https://gitlab.com/python-trainers/trainer-base
 Description-Content-Type: text/markdown
 

{trainerbase-3.16.2 → trainerbase-4.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trainerbase"
-version = "3.16.2"
+version = "4.0.0"
 description = "Framework for creating game trainers/mods"
 authors = ["v01d <v01d@v01d.ru>", "doomayka <zd@doomayka.ru>"]
 license = "MIT"
@@ -17,7 +17,7 @@ include = [
 ]
 
 [tool.poetry.group.dev.dependencies]
-ruff = "^0.5.7"
+ruff = "^0.6.8"
 
 [tool.ruff]
 src = ["trainerbase"]
@@ -51,9 +51,10 @@ python = "^3.12"
 pymem = "^1.13.1"
 dearpygui = "^1.11.1"
 keyboard = "^0.13.5"
-pyttsx3 = "^2.90"
+pyttsx3 = "^2.98"
 pyinjector = "^1.3.0"
 psutil = "^6.0.0"
+mouse = "^0.7.1"
 
 [build-system]
 requires = ["poetry-core"]

trainerbase-4.0.0/trainerbase/common/abc.py

@@ -0,0 +1,18 @@
+from collections.abc import Callable
+from typing import override
+
+from trainerbase.abc import Switchable
+
+
+class SimpleSwitchable(Switchable):
+    def __init__(self, on_enabled: Callable[[], None], on_disabled: Callable[[], None]):
+        self._on_enabled = on_enabled
+        self._on_disabled = on_disabled
+
+    @override
+    def enable(self):
+        self._on_enabled()
+
+    @override
+    def disable(self):
+        self._on_disabled()

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/common/keyboard.py

@@ -4,24 +4,10 @@ from typing import override
 
 from keyboard import add_hotkey, on_press_key, on_release_key
 
-from trainerbase.common.abc import AbstractKeyboardHandler, Switchable
+from trainerbase.abc import AbstractKeyboardHandler, Switchable
 from trainerbase.gameobject import GameBool
 
 
-class SimpleSwitchable(Switchable):
-    def __init__(self, on_enabled: Callable[[], None], on_disabled: Callable[[], None]):
-        self._on_enabled = on_enabled
-        self._on_disabled = on_disabled
-
-    @override
-    def enable(self):
-        self._on_enabled()
-
-    @override
-    def disable(self):
-        self._on_disabled()
-
-
 class SimpleHotkeyHandler(AbstractKeyboardHandler):
     def __init__(self, callback: Callable[[], None], hotkey: str):
         self.callback = callback

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/common/rainbow.py

@@ -1,15 +1,18 @@
 from collections.abc import Iterable, Iterator
 from itertools import cycle
+from typing import override
 
 from dearpygui import dearpygui as dpg
 
+from trainerbase.scriptengine import AbstractBaseScript
+
 
 type TagList = list[int | str]
 type Color = tuple[int, int, int]
 type Colors = Iterable[Color]
 
 
-class GradientUpdater:
+class GradientUpdater(AbstractBaseScript):
     def __init__(self):
         self.tags: TagList | None = None
         self.colors: list[Color] | None = None
@@ -18,6 +21,7 @@ class GradientUpdater:
         self.initial_delta: tuple[int, int, int] | None = None
         self.color_length: int | None = None
 
+    @override
     def __call__(self):
         if self.tags is None or self.colors is None:
             raise RuntimeError("Call setup(...)")

trainerbase-4.0.0/trainerbase/common/tapper.py

@@ -0,0 +1,56 @@
+from collections.abc import Callable
+from enum import StrEnum, auto
+from functools import partial
+from typing import assert_never, override
+
+from keyboard import send
+from mouse import click
+
+from trainerbase.abc import Switchable
+from trainerbase.scriptengine import ScriptEngine
+
+
+class TappingDevice(StrEnum):
+    MOUSE = auto()
+    KEYBOARD = auto()
+
+    @property
+    def function(self) -> Callable[[str], None]:
+        match self:
+            case self.MOUSE:
+                return click
+            case self.KEYBOARD:
+                return send
+            case _:
+                assert_never(self)
+
+
+class Tapper(Switchable):
+    def __init__(self, default_delay: float, tap_button: str = "left", device: TappingDevice = TappingDevice.MOUSE):
+        self._delay = default_delay
+        self.tapper_script_engine: ScriptEngine | None = None
+        self.tapper_function = partial(device.function, tap_button)
+
+    @override
+    def enable(self):
+        self.disable()
+
+        self.tapper_script_engine = ScriptEngine(self._delay)
+        self.tapper_script_engine.simple_script(self.tapper_function, enabled=True)
+        self.tapper_script_engine.start()
+
+    @override
+    def disable(self):
+        if self.tapper_script_engine is not None:
+            self.tapper_script_engine.stop()
+
+    @property
+    def delay(self):
+        return self._delay
+
+    @delay.setter
+    def delay(self, new_delay: float):
+        if self.tapper_script_engine is not None:
+            self.tapper_script_engine.delay = new_delay
+
+        self._delay = new_delay

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/common/teleport.py

@@ -8,7 +8,7 @@ from pymem.exception import MemoryReadError
 
 from trainerbase.common.helpers import Number
 from trainerbase.gameobject import GameObject
-from trainerbase.scriptengine import Script, system_script_engine
+from trainerbase.scriptengine import system_script_engine
 
 
 type Coords[T: (int, float)] = tuple[T, T, T]
@@ -74,7 +74,7 @@ class Teleport:
         self.movement_vector = Vector3(0, 0, 0)
         self.minimal_movement_vector_length = minimal_movement_vector_length
 
-        system_script_engine.register_script(Script(self.update_movement_vector, enabled=True))
+        system_script_engine.simple_script(self.update_movement_vector, enabled=True)
 
     def set_coords(self, x: Number, y: Number, z: Number = 100) -> None:
         self.player_x.value = x

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/gameobject.py

@@ -6,7 +6,7 @@ from typing import ClassVar, Self, cast, override
 
 from pymem.exception import MemoryWriteError
 
-from trainerbase.common.abc import Switchable
+from trainerbase.abc import Switchable
 from trainerbase.memory import ConvertibleToAddress, ensure_address, pm
 
 

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/gui/scripts.py

@@ -5,16 +5,16 @@ from dearpygui import dearpygui as dpg
 from keyboard import add_hotkey
 
 from trainerbase.gui.types import AbstractUIComponent
-from trainerbase.scriptengine import Script
+from trainerbase.scriptengine import AbstractBaseScript
 from trainerbase.tts import say
 
 
-class ScriptUI(AbstractUIComponent):
+class ScriptUI[T: AbstractBaseScript](AbstractUIComponent):
     DPG_TAG_PREFIX = "script__"
 
     def __init__(
         self,
-        script: Script,
+        script: T,
         label: str,
         hotkey: str | None = None,
         *,

trainerbase-4.0.0/trainerbase/gui/tapper.py

@@ -0,0 +1,71 @@
+from typing import override
+
+from dearpygui import dearpygui as dpg
+
+from trainerbase.common.keyboard import ReleaseHotkeySwitch
+from trainerbase.common.tapper import Tapper
+from trainerbase.gui.helpers import add_components
+from trainerbase.gui.misc import HotkeyHandlerUI
+from trainerbase.gui.types import AbstractUIComponent
+
+
+class TapperUI(AbstractUIComponent):
+    DPG_TAG_TAPPER_DELAY_INPUT = "tag_tapper_delay_input"
+    DPG_TAG_TAPPER_PRESET_INPUT = "tag_tapper_preset_input"
+
+    PRESETS: tuple[float, ...] = (0.05, 0.15, 0.25, 0.3, 0.5, 0.7, 1, 2, 5, 10)
+
+    def __init__(
+        self,
+        tapper: Tapper | None = None,
+        key: str = "PageUp",
+        default_delay: float = 0.15,
+    ):
+        if tapper is None:
+            self.tapper = Tapper(default_delay)
+            self.default_delay = default_delay
+        else:
+            self.tapper = tapper
+            self.default_delay = tapper.delay
+
+        self.key = key
+
+    @override
+    def add_to_ui(self) -> None:
+        add_components(HotkeyHandlerUI(ReleaseHotkeySwitch(self.tapper, self.key), "Tapper"))
+
+        dpg.add_input_double(
+            tag=self.DPG_TAG_TAPPER_DELAY_INPUT,
+            label="Tapper Delay",
+            min_value=0.0,
+            max_value=60.0,
+            default_value=self.default_delay,
+            min_clamped=True,
+            max_clamped=True,
+            callback=self.on_delay_change,
+        )
+
+        dpg.add_slider_int(
+            tag=self.DPG_TAG_TAPPER_PRESET_INPUT,
+            label="Preset",
+            min_value=0,
+            max_value=len(self.PRESETS) - 1,
+            clamped=True,
+            default_value=self.get_closest_preset_index(self.default_delay),
+            callback=self.on_preset_change,
+        )
+
+    def on_preset_change(self):
+        new_delay = self.PRESETS[dpg.get_value(self.DPG_TAG_TAPPER_PRESET_INPUT)]
+        self.tapper.delay = new_delay
+        dpg.set_value(self.DPG_TAG_TAPPER_DELAY_INPUT, new_delay)
+
+    def on_delay_change(self):
+        new_delay = dpg.get_value(self.DPG_TAG_TAPPER_DELAY_INPUT)
+        closest_preset_index = self.get_closest_preset_index(new_delay)
+        self.tapper.delay = new_delay
+        dpg.set_value(self.DPG_TAG_TAPPER_PRESET_INPUT, closest_preset_index)
+
+    def get_closest_preset_index(self, delay: float) -> int:
+        closest_preset = min(self.PRESETS, key=lambda preset: abs(preset - delay))
+        return self.PRESETS.index(closest_preset)

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/main.py

@@ -7,9 +7,9 @@ from trainerbase.codeinjection import safely_eject_all_code_injections
 from trainerbase.common.rainbow import gradient_updater
 from trainerbase.gameobject import update_frozen_objects
 from trainerbase.gui.objects import update_displayed_objects
-from trainerbase.process import show_message_and_shutdown_if_process_exited
+from trainerbase.process import shutdown_if_process_exited
 from trainerbase.scriptengine import (
-    Script,
+    enabled_by_default,
     process_healthcheck_script_engine,
     rainbow_script_engine,
     system_script_engine,
@@ -50,10 +50,10 @@ def run(  # pylint: disable=too-complex
                 print_exc()
                 on_shutdown()
 
-    system_script_engine.register_script(Script(update_frozen_objects, enabled=True))
-    system_script_engine.register_script(Script(update_displayed_objects, enabled=True))
-    process_healthcheck_script_engine.register_script(Script(show_message_and_shutdown_if_process_exited, enabled=True))
-    rainbow_script_engine.register_script(Script(gradient_updater, enabled=True))
+    system_script_engine.simple_script(update_frozen_objects, enabled=True)
+    system_script_engine.simple_script(update_displayed_objects, enabled=True)
+    process_healthcheck_script_engine.simple_script(shutdown_if_process_exited, enabled=True)
+    rainbow_script_engine.register_script(enabled_by_default(gradient_updater))
 
     try:
         run_gui(on_gui_initialized, on_shutdown)

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/memory.py

@@ -1,6 +1,8 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from functools import partial
+from itertools import count
+from time import sleep
 from types import MappingProxyType
 from typing import Final, Self, assert_never, cast, override
 
@@ -170,14 +172,24 @@ def allocate(size: int = POINTER_SIZE, count: int = 1) -> int:
     return pm.allocate(size * count)
 
 
-def get_module_address(module_name: str) -> int:
+def get_module_address(module_name: str, *, delay: float = 2, retry_limit: int | None = 4) -> int:
     """
-    Returns 0 if module is not found else module address
+    Returns module address.
+    Raises RuntimeError if the address was not found and retry_limit is reached.
+
+    Set retry_limit to None or negative value if you need infinite retry cycle.
+    Set retry_limit to 0 if you want to disable retries.
     """
 
-    module_info = module_from_name(pm.process_handle, module_name)
+    for try_counter in count():
+        module_info = module_from_name(pm.process_handle, module_name)
+
+        if module_info is not None:
+            return module_info.lpBaseOfDll
+
+        if try_counter == retry_limit:
+            raise RuntimeError(f"Failed to find module: {module_name}, tried {try_counter + 1} time(s).")
 
-    if module_info is None:
-        return 0
+        sleep(delay)
 
-    return module_info.lpBaseOfDll
+    raise RuntimeError("This code must be unreachable!")

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/process.py

@@ -3,11 +3,9 @@ from itertools import cycle
 from os import _exit as force_exit
 from typing import cast
 
-from psutil import pid_exists
+from psutil import Process, pid_exists
 from pymem import Pymem
 from pymem.exception import ProcessNotFound
-from win32api import MessageBox
-from win32con import MB_ICONERROR, MB_OK
 
 from trainerbase.config import pymem_config
 
@@ -38,18 +36,13 @@ def attach_to_process() -> Pymem:
     force_exit(0)
 
 
-def show_message_and_shutdown_if_process_exited():
-    if pid_exists(cast(int, _pm.process_id)):
-        return
+def shutdown_if_process_exited():
+    if not pid_exists(cast(int, _pm.process_id)):
+        force_exit(0)
 
-    MessageBox(
-        None,
-        "Shut down trainer?",
-        "Process Exited!",
-        MB_ICONERROR | MB_OK,
-    )
 
-    force_exit(0)
+def kill_game_process():
+    Process(_pm.process_id).kill()
 
 
 _pm = attach_to_process()

{trainerbase-3.16.2 → trainerbase-4.0.0}/trainerbase/scriptengine.py

@@ -1,22 +1,46 @@
+from abc import ABC, abstractmethod
 from collections.abc import Callable
 from contextlib import suppress
 from sys import stderr
 from threading import Thread
 from time import sleep
+from typing import Any, override
 
 from pymem.exception import MemoryReadError, MemoryWriteError
 
+from trainerbase.abc import Switchable
 
-class Script:
-    def __init__(self, callback: Callable, *, enabled: bool = False):
-        self.callback = callback
+
+class AbstractBaseScript(Switchable, ABC):
+    enabled: bool = False
+
+    @abstractmethod
+    def __call__(self) -> Any:
+        pass
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: enabled={self.enabled}>"
+
+    @override
+    def enable(self):
+        self.enabled = True
+
+    @override
+    def disable(self):
+        self.enabled = False
+
+
+class SimpleScript(AbstractBaseScript):
+    def __init__(self, callback: Callable[[], None], *, enabled: bool = False):
+        self._callback = callback
         self.enabled = enabled
 
     def __repr__(self):
-        return f"<Script {getattr(self.callback, '__name__', 'Anon')}:" f" enabled={self.enabled}" f">"
+        return f"<Script {getattr(self._callback, "__name__", "Anon function-based script")}: enabled={self.enabled}>"
 
+    @override
     def __call__(self):
-        return self.callback()
+        self._callback()
 
 
 class ScriptEngine:
@@ -24,7 +48,7 @@ class ScriptEngine:
         self.delay = delay
         self.should_run = False
         self.thread = Thread(target=self.script_loop)
-        self.scripts: list[Script] = []
+        self.scripts: list[AbstractBaseScript] = []
 
     def __repr__(self):
         return f"<ScriptEngine delay={self.delay} should_run={self.should_run} scripts={len(self.scripts)}>"
@@ -55,18 +79,16 @@ class ScriptEngine:
 
             sleep(self.delay)
 
-    def register_script(self, script: Script) -> Script:
+    def register_script[T: AbstractBaseScript](self, script: T) -> T:
         self.scripts.append(script)
         return script
 
-    def simple_script(self, executor: Callable) -> Script:
-        script = Script(executor)
-        self.register_script(script)
-        return script
+    def simple_script(self, executor: Callable[[], None], *, enabled: bool = False) -> AbstractBaseScript:
+        return self.register_script(SimpleScript(executor, enabled=enabled))
 
 
-def enabled_by_default(script: Script) -> Script:
-    script.enabled = True
+def enabled_by_default[T: AbstractBaseScript](script: T) -> T:
+    script.enable()
     return script