trainerbase 3.11.2__tar.gz → 3.11.4__tar.gz

{trainerbase-3.11.2 → trainerbase-3.11.4}/PKG-INFO

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

{trainerbase-3.11.2 → trainerbase-3.11.4}/pyproject.toml

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

{trainerbase-3.11.2 → trainerbase-3.11.4}/trainerbase/codeinjection.py

@@ -47,8 +47,10 @@ class CodeInjection(AbstractCodeInjection):
 
     @override
     def inject(self):
-        self.original_code = pm.read_bytes(self.address.resolve(), len(self.code_to_inject))
-        pm.write_bytes(self.address.resolve(), self.code_to_inject, len(self.code_to_inject))
+        injection_point = self.address.resolve()
+
+        self.original_code = pm.read_bytes(injection_point, len(self.code_to_inject))
+        pm.write_bytes(injection_point, self.code_to_inject, len(self.code_to_inject))
         self._injected = True
 
     @override
@@ -90,33 +92,34 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
 
     @override
     def inject(self):
-        self.original_code = pm.read_bytes(self.address.resolve(), self.original_code_length)
+        injection_point = self.address.resolve()
+
         self.new_memory_address: int = pm.allocate(self.new_memory_size)
 
+        self.original_code = pm.read_bytes(injection_point, self.original_code_length)
+
         if pm.is_64_bit:
-            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(get_long_x64_jump_to_new_mem_code(self.new_memory_address))
+            jumper_length = len(jump_to_new_mem)
+            jump_back_address = injection_point + jumper_length - 1
+            jump_back = compile_asm(get_long_x64_jump_back_code(jump_back_address))
         else:
-            new_mem_jump_code_generator = get_simple_jump_code
-            jump_back_code_generator = get_simple_jump_code
-
-        jump_to_new_mem = compile_asm(new_mem_jump_code_generator(self.new_memory_address))
-        jumper_length = len(jump_to_new_mem)
+            jump_to_new_mem = compile_asm(get_simple_jump_code(self.new_memory_address, injection_point))
+            jumper_length = len(jump_to_new_mem)
+            jump_back_address = injection_point + jumper_length
+            jump_back = compile_asm(
+                get_simple_jump_code(jump_back_address, self.new_memory_address + len(self.code_to_inject)),
+            )
 
         if jumper_length < self.original_code_length:
             jump_to_new_mem += b"\x90" * (self.original_code_length - len(jump_to_new_mem))
         elif jumper_length > self.original_code_length:
             raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
 
-        jump_back_address = self.address.resolve() + jumper_length
-        if pm.is_64_bit:
-            jump_back_address -= 1
-
-        jump_back = compile_asm(jump_back_code_generator(jump_back_address))
         code_to_inject = self.code_to_inject + jump_back
 
         pm.write_bytes(self.new_memory_address, code_to_inject, len(code_to_inject))
-        pm.write_bytes(self.address.resolve(), jump_to_new_mem, len(jump_to_new_mem))
+        pm.write_bytes(injection_point, jump_to_new_mem, len(jump_to_new_mem))
 
     @override
     def eject(self):
@@ -158,10 +161,9 @@ def compile_asm(code: Code) -> bytes:
     return code
 
 
-def get_simple_jump_code(address: int) -> str:
+def get_simple_jump_code(address: int, ip: int) -> str:
     return f"""
-        push {address}
-        ret
+        jmp {address - ip}
     """
 
 

{trainerbase-3.11.2 → trainerbase-3.11.4}/trainerbase/main.py

@@ -11,7 +11,7 @@ from trainerbase.scriptengine import Script, system_script_engine
 from trainerbase.speedhack import SpeedHack
 
 
-def run(
+def run(  # pylint: disable=too-complex
     run_gui: Callable[[Callable], None],
     on_gui_initialized_hook: Callable | None = None,
     on_shutdown_hook: Callable | None = None,
@@ -32,13 +32,16 @@ def run(
         if on_gui_initialized_hook is not None:
             try:
                 on_gui_initialized_hook()
-            except Exception:  # pylint: disable=broad-exception-caught
+            except:  # pylint: disable=bare-except
                 print(format_exc(), file=stderr)
                 on_shutdown()
 
     system_script_engine.register_script(Script(update_frozen_objects, enabled=True))
     system_script_engine.register_script(Script(update_displayed_objects, enabled=True))
 
-    run_gui(on_gui_initialized)
+    try:
+        run_gui(on_gui_initialized)
+    except:  # pylint: disable=bare-except
+        print(format_exc(), file=stderr)
 
     on_shutdown()