trainerbase 3.2.0__tar.gz → 3.4.0__tar.gz

{trainerbase-3.2.0 → trainerbase-3.4.0}/PKG-INFO

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

{trainerbase-3.2.0 → trainerbase-3.4.0}/pyproject.toml

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

{trainerbase-3.2.0 → trainerbase-3.4.0}/trainerbase/codeinjection.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from subprocess import DEVNULL
 from subprocess import run as run_executable
 from tempfile import TemporaryDirectory
-from typing import Self, override
+from typing import Never, Self, override
 
 from pymem.exception import MemoryWriteError
 
@@ -65,28 +65,40 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
         code_to_inject: Code,
         original_code_length: int = 0,
         new_memory_size: int = 1024,
-        is_long_x64_jump_needed: bool = False,
+        is_long_x64_jump_needed: Never = Never,
     ):
+        if is_long_x64_jump_needed is not Never:
+            raise Exception(
+                "Since TrainerBase 3.4.0 is_long_x64_jump_needed has been deprecated."
+                " Now there is not need to manually pop and push rax. That's why you must"
+                " rewrite injections based on manual pop rax, push rax and then remove is_long_x64_jump_needed"
+                " argument"
+            )
+
         self.address = ensure_address(address)
+
         self.code_to_inject = compile_asm(code_to_inject)
+
+        if not pm.is_WoW64:
+            self.code_to_inject = compile_asm("pop rax") + self.code_to_inject + compile_asm("push rax")
+
         self.original_code: bytes = b""
 
         self.original_code_length = original_code_length
         self.new_memory_size = new_memory_size
         self.new_memory_address: int = 0
-        self.is_long_x64_jump_needed = is_long_x64_jump_needed
 
     @override
     def inject(self):
         self.original_code = pm.read_bytes(self.address.resolve(), self.original_code_length)
         self.new_memory_address: int = pm.allocate(self.new_memory_size)
 
-        if self.is_long_x64_jump_needed:
-            new_mem_jump_code_generator = get_long_x64_jump_to_new_mem_code
-            jump_back_code_generator = get_long_x64_jump_back_code
-        else:
+        if pm.is_WoW64:
             new_mem_jump_code_generator = get_simple_jump_code
             jump_back_code_generator = get_simple_jump_code
+        else:
+            new_mem_jump_code_generator = get_long_x64_jump_to_new_mem_code
+            jump_back_code_generator = get_long_x64_jump_back_code
 
         jump_to_new_mem = compile_asm(new_mem_jump_code_generator(self.new_memory_address))
         jumper_length = len(jump_to_new_mem)
@@ -97,7 +109,7 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
             raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
 
         jump_back_address = self.address.resolve() + jumper_length
-        if self.is_long_x64_jump_needed:
+        if not pm.is_WoW64:
             jump_back_address -= 1
 
         jump_back = compile_asm(jump_back_code_generator(jump_back_address))

{trainerbase-3.2.0 → trainerbase-3.4.0}/trainerbase/gui.py

@@ -28,10 +28,6 @@ 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:
@@ -211,12 +207,14 @@ class GameObjectUI(AbstractUIComponent):
 
 
 class TeleportUI(AbstractUIComponent):
+    DPG_TAG_TELEPORT_LABELS = "__teleport_labels"
+
     def __init__(
         self,
         tp: Teleport,
-        hotkey_save_position: str | None = None,
-        hotkey_set_saved_position: str | None = None,
-        hotkey_dash: str | None = None,
+        hotkey_save_position: str | None = "Insert",
+        hotkey_set_saved_position: str | None = "Home",
+        hotkey_dash: str | None = "End",
         tts_on_hotkey: bool = True,
     ):
         self.tp = tp
@@ -261,7 +259,7 @@ class TeleportUI(AbstractUIComponent):
             say("Dash!")
 
     def on_goto_label(self):
-        self.tp.goto(dpg.get_value(TAG_TELEPORT_LABELS))
+        self.tp.goto(dpg.get_value(self.DPG_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:
@@ -289,14 +287,20 @@ class TeleportUI(AbstractUIComponent):
 
         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])
+            dpg.add_combo(label="Labels", tag=self.DPG_TAG_TELEPORT_LABELS, items=labels, default_value=labels[0])
 
 
 class SpeedHackUI(AbstractUIComponent):
-    def __init__(self, speedhack: SpeedHack, key: str):
+    DPG_TAG_SPEEDHACK_FACTOR_INPUT = "tag_speedhack_factor_input"
+    DPG_TAG_SPEEDHACK_PRESET_INPUT = "tag_speedhack_preset_input"
+
+    PRESETS: tuple[float, ...] = (0.1, 0.2, 0.3, 0.5, 1.0, 2.0, 3.0, 5.0, 10.0, 20.0, 50.0)
+
+    def __init__(self, speedhack: SpeedHack, key: str = "Delete", default_factor_input_value: float = 3.0):
         self.speedhack = speedhack
         self.key = key
-        self.switch = ShortLongPressSwitch(SpeedHackUISwitch(speedhack, TAG_SPEEDHACK_FACTOR_INPUT), key)
+        self.default_factor_input_value = default_factor_input_value
+        self.switch = ShortLongPressSwitch(SpeedHackUISwitch(speedhack, self.DPG_TAG_SPEEDHACK_FACTOR_INPUT), key)
 
     @override
     def add_to_ui(self) -> None:
@@ -304,17 +308,41 @@ class SpeedHackUI(AbstractUIComponent):
         dpg.add_text(f"Press [{self.key}] Toggle SpeedHack")
 
         dpg.add_input_double(
-            tag=TAG_SPEEDHACK_FACTOR_INPUT,
+            tag=self.DPG_TAG_SPEEDHACK_FACTOR_INPUT,
             label="SpeedHack Factor",
             min_value=0.0,
             max_value=100.0,
-            default_value=3.0,
+            default_value=self.default_factor_input_value,
             min_clamped=True,
             max_clamped=True,
+            callback=self.on_factor_change,
+        )
+
+        dpg.add_slider_int(
+            tag=self.DPG_TAG_SPEEDHACK_PRESET_INPUT,
+            label="Preset",
+            min_value=0,
+            max_value=len(self.PRESETS) - 1,
+            clamped=True,
+            default_value=self.get_closest_preset_index(self.default_factor_input_value),
+            callback=self.on_preset_change,
         )
 
         self.switch.handle()
 
+    def on_preset_change(self):
+        new_factor = self.PRESETS[dpg.get_value(self.DPG_TAG_SPEEDHACK_PRESET_INPUT)]
+        dpg.set_value(self.DPG_TAG_SPEEDHACK_FACTOR_INPUT, new_factor)
+
+    def on_factor_change(self):
+        new_factor = dpg.get_value(self.DPG_TAG_SPEEDHACK_FACTOR_INPUT)
+        closest_preset_index = self.get_closest_preset_index(new_factor)
+        dpg.set_value(self.DPG_TAG_SPEEDHACK_PRESET_INPUT, closest_preset_index)
+
+    def get_closest_preset_index(self, factor: float) -> int:
+        closest_preset = min(self.PRESETS, key=lambda preset: abs(preset - factor))
+        return self.PRESETS.index(closest_preset)
+
 
 class SpeedHackUISwitch(Switchable):
     def __init__(self, speedhack: SpeedHack, dpg_tag: str):

{trainerbase-3.2.0 → trainerbase-3.4.0}/trainerbase/memory.py

@@ -154,3 +154,7 @@ def ensure_address(obj: ConvertibleToAddress) -> AbstractAddress:
             return AOBScan(obj)
         case _:
             raise TypeError(f"Cannot create AbstractAddress from {type(obj)}")
+
+
+def allocate_pointer() -> int:
+    return pm.allocate(POINTER_SIZE)