trainerbase 3.7.0__tar.gz → 3.8.0__tar.gz

{trainerbase-3.7.0 → trainerbase-3.8.0}/LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
-Copyright (c) 2021 - 2023 v01d
-Copyright (c) 2022 - 2023 doomayka
+Copyright (c) 2021 - 2024 v01d
+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.0 → trainerbase-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trainerbase
-Version: 3.7.0
+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.0 → trainerbase-3.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trainerbase"
-version = "3.7.0"
+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.7.0 → trainerbase-3.8.0}/trainerbase/gameobject.py

@@ -15,7 +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
+    value_range: None | tuple[TrainerBaseType, TrainerBaseType] = None
 
     @staticmethod
     @abstractmethod
@@ -32,7 +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,
+        value_range: None | tuple[TrainerBaseType, TrainerBaseType] = None,
     ):
         if is_tracked:
             GameObject.tracked_objects.append(self)
@@ -68,7 +68,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
 
         min_value, max_value = self.value_range
 
-        return min_value <= value <= max_value
+        return min_value <= value <= max_value  # type: ignore
 
     @property
     @override
@@ -84,7 +84,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
 
 
 class GameFloat(GameObject[float, float]):
-    value_range = (-3.4e38, 3.4e38)
+    value_range: tuple[float, float] = (-3.4e38, 3.4e38)
     pm_read = pm.read_float  # type: ignore
     pm_write = pm.write_float
 
@@ -94,7 +94,7 @@ class GameFloat(GameObject[float, float]):
 
 
 class GameDouble(GameObject[float, float]):
-    value_range = (-1.7e308, 1.7e308)
+    value_range: tuple[float, float] = (-1.7e308, 1.7e308)
     pm_read = pm.read_double  # type: ignore
     pm_write = pm.write_double
 
@@ -104,7 +104,7 @@ class GameDouble(GameObject[float, float]):
 
 
 class GameByte(GameObject[bytes, int]):
-    value_range = (0, 255)
+    value_range: tuple[int, int] = (0, 255)
 
     @staticmethod
     @override
@@ -126,49 +126,49 @@ class GameByte(GameObject[bytes, int]):
 
 
 class GameInt(GameObject[int, int]):
-    value_range = (-2_147_483_648, 2_147_483_647)
+    value_range: tuple[int, int] = (-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)
+    value_range: tuple[int, int] = (-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)
+    value_range: tuple[int, int] = (-(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)
+    value_range: tuple[int, int] = (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)
+    value_range: tuple[int, int] = (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)
+    value_range: tuple[int, int] = (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)
+    value_range: tuple[bool, bool] = (False, True)
 
     pm_read = pm.read_bool  # type: ignore
     pm_write = pm.write_bool
@@ -188,5 +188,5 @@ def update_frozen_objects():
         if game_object.frozen is not None:
             try:
                 game_object.value = game_object.frozen
-            except MemoryWriteError:
+            except (MemoryWriteError, ValueError):
                 continue

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()