trainerbase 3.7.1__tar.gz → 3.8.0__tar.gz

{trainerbase-3.7.1 → trainerbase-3.8.0}/LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2021 - 2024 v01d
-Copyright (c) 2022 - 2023 doomayka
+Copyright (c) 2022 - 2024 doomayka
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{trainerbase-3.7.1 → trainerbase-3.8.0}/PKG-INFO

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

{trainerbase-3.7.1 → trainerbase-3.8.0}/pyproject.toml

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

trainerbase-3.8.0/trainerbase/common/__init__.py

@@ -0,0 +1,3 @@
+from .helpers import *
+from .keyboard import *
+from .teleport import *

trainerbase-3.8.0/trainerbase/common/helpers.py

@@ -0,0 +1,95 @@
+from collections.abc import Iterator, Sequence
+from uuid import uuid4
+
+from trainerbase.gameobject import AbstractReadableObject, GameObject
+from trainerbase.memory import POINTER_SIZE, Address, allocate_pointer, pm
+
+
+type Number = int | float
+
+
+class ASMArrayManager(Sequence):
+    def __init__(
+        self,
+        array_length: int,
+        element_size: int,
+        offsets: None | list[int] = None,
+        add: int = 0,
+    ) -> None:
+        if offsets:
+            assert element_size == POINTER_SIZE, "If `offsets` is not None, `element_size` must be `POINTER_SIZE`"
+
+        self.array_length = array_length
+        self.element_size = element_size
+        self.offsets = [] if offsets is None else offsets
+        self.add = add
+
+        self.array_address = pm.allocate(array_length * element_size)
+        self.array_index_pointer = allocate_pointer()
+
+    def __len__(self) -> int:
+        return self.array_length
+
+    def __getitem__(self, index: int) -> Address:
+        element_address = self.get_pointer_to_element(index)
+        target_address = Address(element_address, self.offsets, self.add)
+
+        return Address(target_address.resolve())
+
+    def __iter__(self) -> Iterator[Address]:
+        for index in range(len(self)):
+            yield self[index]
+
+    def get_pointer_to_element(self, index: int) -> int:
+        return self.array_address + self.element_size * index
+
+    def generate_asm_append_code(self, from_register: str) -> str:
+        array_address_register = "rbx" if pm.is_64_bit else "ebx"
+        array_index_register = "rcx" if pm.is_64_bit else "ecx"
+        reserve_register = "rax" if pm.is_64_bit else "eax"
+
+        if from_register == array_address_register:
+            array_address_register = reserve_register
+
+        if from_register == array_index_register:
+            array_index_register = reserve_register
+
+        assert len({from_register, array_address_register, array_index_register}) == 3, "Registers must be unique"
+
+        label_continue = f"__label_continue_{uuid4().hex}"
+
+        asm = f"""
+            push {array_address_register}
+            push {array_index_register}
+
+            mov {array_address_register}, {self.array_address}
+            mov {array_index_register}, [{self.array_index_pointer}]
+
+            mov [{array_address_register} + {array_index_register} * {self.element_size}], {from_register}
+
+            inc {array_index_register}
+
+            cmp {array_index_register}, {self.array_length}
+            jl {label_continue}
+
+            mov {array_index_register}, 0
+
+            {label_continue}:
+
+            mov [{self.array_index_pointer}], {array_index_register}
+
+            pop {array_index_register}
+            pop {array_address_register}
+        """
+
+        return asm
+
+
+def regenerate(
+    current_value: GameObject,
+    max_value: AbstractReadableObject,
+    percent: Number,
+    min_value: Number = 1,
+):
+    if current_value.value < max_value.value:
+        current_value.value += max(round(max_value.value * percent / 100), min_value)

trainerbase-3.8.0/trainerbase/common/keyboard.py

@@ -0,0 +1,121 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from time import time
+from typing import override
+
+from keyboard import on_press_key, on_release_key
+
+
+class Switchable(ABC):
+    @abstractmethod
+    def enable(self):
+        pass
+
+    @abstractmethod
+    def disable(self):
+        pass
+
+
+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 AbstractKeyboardSwitch(ABC):
+    @property
+    @abstractmethod
+    def hotkey(self) -> str:
+        pass
+
+    @abstractmethod
+    def handle(self):
+        pass
+
+
+class ReleaseHotkeySwitch(AbstractKeyboardSwitch):
+    def __init__(self, switchable: Switchable, key: str):
+        self._key = key
+        self._switchable = switchable
+        self._enabled = False
+
+    def _on_release(self, _):
+        if self._enabled:
+            self._switchable.disable()
+        else:
+            self._switchable.enable()
+
+        self._enabled = not self._enabled
+
+    @property
+    @override
+    def hotkey(self):
+        return self._key
+
+    @override
+    def handle(self):
+        on_release_key(self._key, self._on_release)
+
+
+class ShortLongHotkeyPressSwitch(AbstractKeyboardSwitch):
+    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._switchable = switchable
+        self._enabled = False
+
+    def _on_press(self, _):
+        if self._press_timestamp is None:
+            self._press_timestamp = time()
+        self.on_press()
+
+    def _on_release(self, _):
+        if self._is_short_delta():
+            self.on_short_press()
+        else:
+            self.on_long_press()
+
+        self._press_timestamp = None
+
+    def _get_press_delta(self):
+        if self._press_timestamp is None:
+            return 0
+
+        return time() - self._press_timestamp
+
+    def _is_short_delta(self):
+        return self._get_press_delta() <= self._short_press_max_delta
+
+    def on_press(self):
+        self._switchable.enable()
+
+    def on_short_press(self):
+        if self._enabled:
+            self._enabled = False
+            self._switchable.disable()
+        else:
+            self._enabled = True
+            self._switchable.enable()
+
+    def on_long_press(self):
+        self._enabled = False
+        self._switchable.disable()
+
+    @property
+    @override
+    def hotkey(self):
+        return self._key
+
+    @override
+    def handle(self):
+        on_release_key(self._key, self._on_release)
+        on_press_key(self._key, self._on_press)

trainerbase-3.8.0/trainerbase/common/teleport.py

@@ -0,0 +1,125 @@
+from itertools import repeat, starmap
+from math import sqrt
+from operator import add, mul
+from typing import Self
+
+from pymem.exception import MemoryReadError
+
+from trainerbase.common.helpers import Number
+from trainerbase.gameobject import GameObject
+from trainerbase.scriptengine import Script, system_script_engine
+
+
+type Coords[T: (int, float)] = tuple[T, T, T]
+
+
+class Vector3:
+    def __init__(self, x: Number, y: Number, z: Number):
+        self.x = x
+        self.y = y
+        self.z = z
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+        yield self.z
+
+    def __abs__(self) -> Number:
+        return sqrt(sum(d * d for d in self))
+
+    def __mul__(self, other) -> Self:
+        return self.__apply_binary_function(other, mul)
+
+    def __add__(self, other) -> Self:
+        return self.__apply_binary_function(other, add)
+
+    def __apply_binary_function(self, other, function) -> Self:
+        if isinstance(other, (float, int)):
+            other = repeat(other, 3)
+        elif not isinstance(other, self.__class__):
+            raise TypeError(f"Can't apply function {function}. Wrong type: {type(other)}")
+
+        return self.__class__(*starmap(function, zip(self, other)))
+
+    @classmethod
+    def from_coords(cls, x1, y1, z1, x2, y2, z2) -> Self:
+        return cls(x2 - x1, y2 - y1, z2 - z1)
+
+    def get_normalized(self) -> Self:
+        length = abs(self)
+        return self.__class__(*(d / length for d in self))
+
+
+class Teleport:
+    def __init__(
+        self,
+        player_x: GameObject,
+        player_y: GameObject,
+        player_z: GameObject,
+        labels: dict[str, Coords] | None = None,
+        dash_coefficients: Vector3 | None = None,
+        minimal_movement_vector_length: float = 0.1,
+    ):
+        self.player_x = player_x
+        self.player_y = player_y
+        self.player_z = player_z
+        self.labels = {} if labels is None else labels
+
+        self.saved_position: Coords | None = None
+
+        self.dash_coefficients = Vector3(5, 5, 5) if dash_coefficients is None else dash_coefficients
+        self.previous_position: Coords | None = None
+        self.current_position: Coords | None = None
+        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))
+
+    def set_coords(self, x: Number, y: Number, z: Number = 100) -> None:
+        self.player_x.value = x
+        self.player_y.value = y
+        self.player_z.value = z
+
+    def get_coords(self) -> Coords:
+        return self.player_x.value, self.player_y.value, self.player_z.value
+
+    def goto(self, label: str) -> None:
+        self.set_coords(*self.labels[label])
+
+    def save_position(self) -> None:
+        self.saved_position = self.get_coords()
+
+    def restore_saved_position(self) -> bool:
+        """
+        Returns False if position is not saved else True
+        """
+
+        if self.saved_position is None:
+            return False
+
+        self.set_coords(*self.saved_position)
+
+        return True
+
+    def update_movement_vector(self) -> None:
+        try:
+            self.current_position = self.get_coords()
+        except MemoryReadError:
+            return
+
+        if self.previous_position is None:
+            self.previous_position = self.current_position
+            return
+
+        movement_vector = Vector3.from_coords(*self.previous_position, *self.current_position)
+
+        if abs(movement_vector) < self.minimal_movement_vector_length:
+            return
+
+        self.movement_vector = movement_vector.get_normalized()
+        self.previous_position = self.current_position
+
+    def dash(self) -> None:
+        dash_movement_vector = self.movement_vector * self.dash_coefficients
+        new_coords = Vector3(*self.get_coords()) + dash_movement_vector
+        self.set_coords(*new_coords)

trainerbase-3.8.0/trainerbase/gui/__init__.py

@@ -0,0 +1,8 @@
+from .helpers import *
+from .injections import *
+from .misc import *
+from .objects import *
+from .scripts import *
+from .speedhack import *
+from .teleport import *
+from .types import *

trainerbase-3.8.0/trainerbase/gui/helpers.py

@@ -0,0 +1,48 @@
+from collections.abc import Callable
+from functools import wraps
+
+from dearpygui import dearpygui as dpg
+
+from trainerbase.gui.types import AbstractUIComponent
+
+
+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

trainerbase-3.8.0/trainerbase/gui/injections.py

@@ -0,0 +1,55 @@
+from typing import override
+from uuid import uuid4
+
+from dearpygui import dearpygui as dpg
+from keyboard import add_hotkey
+from pymem.exception import MemoryReadError, MemoryWriteError
+
+from trainerbase.codeinjection import AbstractCodeInjection
+from trainerbase.gui.types import AbstractUIComponent
+from trainerbase.tts import say
+
+
+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):
+            change_codeinjection_state = self.injection.inject
+        else:
+            change_codeinjection_state = self.injection.eject
+
+        try:
+            change_codeinjection_state()
+        except (MemoryReadError, MemoryWriteError):
+            dpg.set_value(self.dpg_tag, not 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_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}")

trainerbase-3.8.0/trainerbase/gui/misc.py

@@ -0,0 +1,40 @@
+from typing import override
+from uuid import uuid4
+
+from dearpygui import dearpygui as dpg
+
+from trainerbase.common.keyboard import AbstractKeyboardSwitch
+from trainerbase.gui.types import AbstractUIComponent
+
+
+class SeparatorUI(AbstractUIComponent):
+    @override
+    def add_to_ui(self) -> None:
+        dpg.add_separator()
+
+
+class TextUI(AbstractUIComponent):
+    def __init__(self, text: str):
+        self.text = text
+
+    @override
+    def add_to_ui(self) -> None:
+        dpg.add_text(self.text)
+
+
+class HotkeySwitchUI(AbstractUIComponent):
+    DPG_TAG_PREFIX = "switch__"
+
+    def __init__(
+        self,
+        switch: AbstractKeyboardSwitch,
+        label: str,
+    ):
+        self.switch = switch
+        self.label_with_hotkey = f"[{switch.hotkey}] {label}"
+        self.dpg_tag = f"{self.DPG_TAG_PREFIX}{uuid4()}"
+
+    @override
+    def add_to_ui(self) -> None:
+        dpg.add_text(self.label_with_hotkey, tag=self.dpg_tag)
+        self.switch.handle()

trainerbase-3.8.0/trainerbase/gui/objects.py

@@ -0,0 +1,161 @@
+from collections.abc import Callable
+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, MemoryWriteError
+
+from trainerbase.gameobject import (
+    GameBool,
+    GameByte,
+    GameDouble,
+    GameFloat,
+    GameInt,
+    GameLongLong,
+    GameObject,
+    GameShort,
+    GameUnsignedInt,
+    GameUnsignedLongLong,
+    GameUnsignedShort,
+)
+from trainerbase.gui.types import AbstractUIComponent
+from trainerbase.tts import say
+
+
+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 | None = None,
+        tts_on_hotkey: bool = True,
+        setter_input_width: int = 220,
+    ):
+        if not gameobject.is_tracked:
+            hotkey = None
+
+        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
+        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}"
+        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)
+
+        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)
+
+            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()
+            ):
+                # There is no input for integers that are not simple `signed long int`.
+                # TODO: Use better input component if it's already added to dpg. Remove this crutch.
+
+                min_value = default_kwargs.pop("min_value", GameInt.value_range[0])
+                max_value = default_kwargs.pop("max_value", GameInt.value_range[1])
+
+                if self.gameobject.value_range is not None:
+                    min_value = max(min_value, GameInt.value_range[0])
+                    max_value = min(max_value, GameInt.value_range[1])
+
+                dpg.add_input_int(min_value=min_value, max_value=max_value, **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
+        except MemoryReadError:
+            dpg.set_value(self.dpg_tag_frozen, False)
+
+    def on_value_set(self):
+        raw_new_value = dpg.get_value(self.dpg_tag_setter)
+        new_value = raw_new_value if self.before_set is None else self.before_set(raw_new_value)
+
+        if self.gameobject.frozen is None:
+            try:
+                self.gameobject.value = new_value
+            except (MemoryWriteError, ValueError):
+                pass
+        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}")
+
+
+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)