trainerbase 3.14.1__tar.gz → 3.16.0__tar.gz

{trainerbase-3.14.1 → trainerbase-3.16.0}/PKG-INFO

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

{trainerbase-3.14.1 → trainerbase-3.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trainerbase"
-version = "3.14.1"
+version = "3.16.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.4.4"
+ruff = "^0.4.10"
 
 [tool.ruff]
 src = ["trainerbase"]

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/common/helpers.py

@@ -1,7 +1,11 @@
-from collections.abc import Iterator, Sequence
+from collections.abc import Callable, Iterator, Sequence
+from contextlib import suppress
+from functools import wraps
 from typing import overload
 from uuid import uuid4
 
+from pymem.exception import MemoryReadError, MemoryWriteError
+
 from trainerbase.gameobject import AbstractReadableObject, GameObject
 from trainerbase.memory import POINTER_SIZE, Address, allocate, pm
 
@@ -119,3 +123,12 @@ def regenerate(
 ):
     if current_value.value < max_value.value:
         current_value.value += max(round(max_value.value * percent / 100), min_value)
+
+
+def suppress_memory_exceptions[**P, T](callback: Callable[P, T]) -> Callable[P, T | None]:
+    @wraps(callback)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
+        with suppress(MemoryReadError, MemoryWriteError):
+            return callback(*args, **kwargs)
+
+    return wrapper

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/common/keyboard.py

@@ -24,7 +24,7 @@ class SimpleSwitchable(Switchable):
 
 class SimpleHotkeyHandler(AbstractKeyboardHandler):
     def __init__(self, callback: Callable[[], None], hotkey: str):
-        self._callback = callback
+        self.callback = callback
         self._hotkey = hotkey
 
     @property
@@ -34,7 +34,7 @@ class SimpleHotkeyHandler(AbstractKeyboardHandler):
 
     @override
     def handle(self):
-        add_hotkey(self._hotkey, self._callback)
+        add_hotkey(self._hotkey, self.callback)
 
 
 class ReleaseHotkeySwitch(AbstractKeyboardHandler):

trainerbase-3.16.0/trainerbase/common/rainbow.py

@@ -0,0 +1,94 @@
+from collections.abc import Iterable, Iterator
+from itertools import cycle
+
+from dearpygui import dearpygui as dpg
+
+from trainerbase.scriptengine import Script, rainbow_script_engine
+
+
+type TagList = list[int | str]
+type Color = tuple[int, int, int]
+type Colors = Iterable[Color]
+
+
+class GradientUpdater:
+    def __init__(self):
+        self.tags: TagList | None = None
+        self.colors: list[Color] | None = None
+        self.index_iter: Iterator[int] | None = None
+        self.initial_color: Color | None = None
+        self.initial_delta: tuple[int, int, int] | None = None
+        self.color_length: int | None = None
+
+    def __call__(self):
+        if self.tags is None or self.colors is None:
+            raise RuntimeError("Call setup(...)")
+
+        for tag, color in zip(self.tags, self.get_colors(len(self.tags))):
+            dpg.configure_item(tag, color=color)
+
+    def setup(
+        self,
+        *,
+        tags: TagList | None = None,
+        initial_color: Color | None = None,
+        initial_delta: tuple[int, int, int] | None = None,
+        color_length: int | None = None,
+    ) -> None:
+        if tags is not None:
+            self.tags = tags
+            self.colors = self.generate_colors(len(tags))
+            self.index_iter = cycle(range(len(self.colors)))
+
+        if initial_color is not None:
+            self.initial_color = initial_color
+
+        if initial_delta is not None:
+            self.initial_delta = initial_delta
+
+        if color_length is not None:
+            self.color_length = color_length
+
+    def generate_colors(self, length: int) -> list[Color]:
+        if self.initial_color is None or self.initial_delta is None or self.color_length is None:
+            raise RuntimeError("Call setup(...)")
+
+        red, green, blue = self.initial_color
+        delta_red, delta_green, delta_blue = self.initial_delta
+
+        colors = []
+
+        for _ in range(length // 2):
+            for _ in range(self.color_length):
+                colors.append((red, green, blue))
+
+            red, delta_red = self.next_color_channel_value(red, delta_red)
+            green, delta_green = self.next_color_channel_value(green, delta_green)
+            blue, delta_blue = self.next_color_channel_value(blue, delta_blue)
+
+        colors = colors + colors[::-1]
+
+        return colors
+
+    def get_colors(self, n: int) -> Colors:
+        if self.colors is None or self.index_iter is None:
+            raise RuntimeError("Call setup(...)")
+
+        index = next(self.index_iter)
+
+        colors = self.colors[index : index + n]
+
+        if len(colors) < n:
+            colors += self.colors[: n - len(colors)]
+
+        return colors
+
+    def next_color_channel_value(self, current: int, delta: int) -> tuple[int, int]:
+        if not (0 <= current + delta <= 255):
+            delta = -delta
+
+        return current + delta, delta
+
+
+gradient_updater = GradientUpdater()
+rainbow_script_engine.register_script(Script(gradient_updater, enabled=True))

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/gui/helpers.py

@@ -3,6 +3,8 @@ from functools import wraps
 
 from dearpygui import dearpygui as dpg
 
+from trainerbase.common.rainbow import Color, gradient_updater
+from trainerbase.gui.rainbow import RainbowUI
 from trainerbase.gui.types import AbstractUIComponent
 
 
@@ -11,10 +13,17 @@ def add_components(*components: AbstractUIComponent):
         component.add_to_ui()
 
 
-def simple_trainerbase_menu(window_title: str, width: int, height: int):
-    def menu_decorator(initializer: Callable):
+def simple_trainerbase_menu(
+    window_title: str,
+    width: int,
+    height: int,
+    rainbow_initial_color: Color = (1, 255, 125),
+    rainbow_initial_delta: tuple[int, int, int] = (1, 1, 1),
+    rainbow_color_length: int = 3,
+):
+    def menu_decorator(initializer: Callable[[], None]):
         @wraps(initializer)
-        def run_menu_wrapper(on_initialized: Callable):
+        def run_menu_wrapper(on_initialized: Callable[[], None]):
             dpg.create_context()
             dpg.create_viewport(
                 title=window_title,
@@ -34,6 +43,14 @@ def simple_trainerbase_menu(window_title: str, width: int, height: int):
                 horizontal_scrollbar=True,
                 autosize=True,
             ):
+                gradient_updater.setup(
+                    initial_color=rainbow_initial_color,
+                    initial_delta=rainbow_initial_delta,
+                    color_length=rainbow_color_length,
+                )
+
+                add_components(RainbowUI(width, gradient_updater))
+
                 initializer()
 
             dpg.set_primary_window("menu", value=True)

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/gui/injections.py

@@ -1,3 +1,4 @@
+from traceback import print_exc
 from typing import override
 from uuid import uuid4
 
@@ -41,8 +42,9 @@ class CodeInjectionUI(AbstractUIComponent):
 
         try:
             change_codeinjection_state()
-        except (MemoryReadError, MemoryWriteError):
+        except (MemoryReadError, MemoryWriteError, ValueError):
             dpg.set_value(self.dpg_tag, not dpg.get_value(self.dpg_tag))
+            print_exc()
 
     def on_hotkey_press(self):
         dpg.set_value(self.dpg_tag, not dpg.get_value(self.dpg_tag))

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/gui/misc.py

@@ -1,9 +1,13 @@
 from typing import override
-from uuid import uuid4
 
 from dearpygui import dearpygui as dpg
 
-from trainerbase.common.keyboard import AbstractKeyboardHandler, ReleaseHotkeySwitch, ShortLongHotkeyPressSwitch
+from trainerbase.common.keyboard import (
+    AbstractKeyboardHandler,
+    ReleaseHotkeySwitch,
+    ShortLongHotkeyPressSwitch,
+    SimpleHotkeyHandler,
+)
 from trainerbase.gui.types import AbstractUIComponent
 
 
@@ -33,27 +37,25 @@ class TextUI(AbstractUIComponent):
 
 
 class HotkeyHandlerUI(AbstractUIComponent):
-    DPG_TAG_PREFIX = "switch__"
-
     def __init__(
         self,
         handler: AbstractKeyboardHandler,
         label: str,
     ):
         self.handler = handler
-        self.dpg_tag_press = f"{self.DPG_TAG_PREFIX}{uuid4()}_press"
-        self.dpg_tag_hold = f"{self.DPG_TAG_PREFIX}{uuid4()}_hold"
         self.label = label
 
     @override
     def add_to_ui(self) -> None:
         match self.handler:
             case ShortLongHotkeyPressSwitch():
-                dpg.add_text(f"Hold [{self.handler.hotkey}] Enable {self.label}", tag=self.dpg_tag_hold)
-                dpg.add_text(f"Press [{self.handler.hotkey}] Toggle {self.label}", tag=self.dpg_tag_press)
+                dpg.add_text(f"Hold [{self.handler.hotkey}] Enable {self.label}")
+                dpg.add_text(f"Press [{self.handler.hotkey}] Toggle {self.label}")
             case ReleaseHotkeySwitch():
-                dpg.add_text(f"[{self.handler.hotkey}] Toggle {self.label}", tag=self.dpg_tag_press)
+                dpg.add_text(f"[{self.handler.hotkey}] Toggle {self.label}")
+            case SimpleHotkeyHandler():
+                dpg.add_button(label=f"[{self.handler.hotkey}] {self.label}", callback=self.handler.callback)
             case _:
-                dpg.add_text(f"[{self.handler.hotkey}] {self.label}", tag=self.dpg_tag_press)
+                dpg.add_text(f"[{self.handler.hotkey}] {self.label}")
 
         self.handler.handle()

trainerbase-3.16.0/trainerbase/gui/rainbow.py

@@ -0,0 +1,22 @@
+from typing import override
+
+from dearpygui import dearpygui as dpg
+
+from trainerbase.common.rainbow import GradientUpdater
+from trainerbase.gui.types import AbstractUIComponent
+
+
+class RainbowUI(AbstractUIComponent):
+    def __init__(self, width: int, gradient_updater: GradientUpdater) -> None:
+        self.gradient_updater = gradient_updater
+        self.width = width
+
+    @override
+    def add_to_ui(self) -> None:
+        dpg.add_spacer()
+        dpg.add_spacer()
+        tags = [dpg.draw_line([-10.0 + i, 0.0], [1.0 + i, 0.0], thickness=2) for i in range(self.width)]
+
+        self.gradient_updater.setup(tags=tags)
+
+        return super().add_to_ui()

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/main.py

@@ -1,14 +1,18 @@
 from collections.abc import Callable
 from os import _exit as force_exit
-from sys import stderr
-from traceback import format_exc
+from traceback import print_exc
 from typing import NoReturn
 
 from trainerbase.codeinjection import safely_eject_all_code_injections
 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.scriptengine import Script, process_healthcheck_script_engine, system_script_engine
+from trainerbase.scriptengine import (
+    Script,
+    process_healthcheck_script_engine,
+    rainbow_script_engine,
+    system_script_engine,
+)
 from trainerbase.speedhack import SpeedHack
 
 
@@ -20,6 +24,8 @@ def run(  # pylint: disable=too-complex
     def on_shutdown() -> NoReturn:
         system_script_engine.stop()
         process_healthcheck_script_engine.stop()
+        rainbow_script_engine.stop()
+
         safely_eject_all_code_injections()
         SpeedHack.disable()
 
@@ -31,12 +37,13 @@ def run(  # pylint: disable=too-complex
     def on_gui_initialized() -> None:
         system_script_engine.start()
         process_healthcheck_script_engine.start()
+        rainbow_script_engine.start()
 
         if on_gui_initialized_hook is not None:
             try:
                 on_gui_initialized_hook()
             except Exception:
-                print(format_exc(), file=stderr)
+                print_exc()
                 on_shutdown()
 
     system_script_engine.register_script(Script(update_frozen_objects, enabled=True))
@@ -46,6 +53,6 @@ def run(  # pylint: disable=too-complex
     try:
         run_gui(on_gui_initialized)
     except Exception:
-        print(format_exc(), file=stderr)
+        print_exc()
 
     on_shutdown()

{trainerbase-3.14.1 → trainerbase-3.16.0}/trainerbase/scriptengine.py

@@ -68,4 +68,5 @@ def enabled_by_default(script: Script) -> Script:
 
 
 system_script_engine = ScriptEngine()
+rainbow_script_engine = ScriptEngine(delay=0.0025)
 process_healthcheck_script_engine = ScriptEngine(delay=3)