trainerbase 3.13.0__tar.gz → 3.14.0__tar.gz

{trainerbase-3.13.0 → trainerbase-3.14.0}/PKG-INFO

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

{trainerbase-3.13.0 → trainerbase-3.14.0}/pyproject.toml

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

{trainerbase-3.13.0 → trainerbase-3.14.0}/trainerbase/codeinjection.py

@@ -8,7 +8,7 @@ from typing import ClassVar, Final, Self, override
 
 from pymem.exception import MemoryWriteError
 
-from trainerbase.memory import ARCH, ConvertibleToAddress, ensure_address, pm
+from trainerbase.memory import ARCH, ConvertibleToAddress, allocate, ensure_address, pm
 
 
 FASM_EXECUTABLE_PATH: Final[Path] = Path(__file__).resolve().parent.parent / "trainerbase_vendor" / "FASM.EXE"
@@ -67,9 +67,11 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
         self,
         address: ConvertibleToAddress,
         code_to_inject: Code,
+        *,
         original_code_length: int = 0,
         new_memory_size: int = 1024,
         is_long_x64_jump_needed: bool | None = None,
+        experimental_allocate_nearest_to_injection_point: bool = False,
     ):
         if is_long_x64_jump_needed is None:
             is_long_x64_jump_needed = pm.is_64_bit
@@ -88,11 +90,14 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
         self.new_memory_address: int = 0
         self.injection_point: int = 0
 
+        self._experimental_allocate_nearest_to_injection_point = experimental_allocate_nearest_to_injection_point
+
     @override
     def inject(self):
         self.injection_point = self.address.resolve()
 
-        self.new_memory_address: int = pm.allocate(self.new_memory_size)
+        nearest_to = self.injection_point if self._experimental_allocate_nearest_to_injection_point else None
+        self.new_memory_address: int = allocate(self.new_memory_size, nearest_to=nearest_to)
 
         self.original_code = pm.read_bytes(self.injection_point, self.original_code_length)
 

{trainerbase-3.13.0 → trainerbase-3.14.0}/trainerbase/common/helpers.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterator, Sequence
+from typing import overload
 from uuid import uuid4
 
 from trainerbase.gameobject import AbstractReadableObject, GameObject
@@ -30,11 +31,17 @@ class ASMArrayManager(Sequence):
     def __len__(self) -> int:
         return self.array_length
 
-    def __getitem__(self, index: int) -> Address:  # type: ignore TODO: Support slices
-        element_address = self.get_pointer_to_element(index)
-        target_address = Address(element_address, self.offsets, self.add)
+    @overload
+    def __getitem__(self, index: int) -> Address: ...
 
-        return Address(target_address.resolve())
+    @overload
+    def __getitem__(self, index: slice) -> list[Address]: ...
+
+    def __getitem__(self, index: int | slice) -> Address | list[Address]:
+        if isinstance(index, int):
+            return self.get_address_of_element(index)
+
+        return [self.get_address_of_element(i) for i in range(index.start, index.stop, index.step)]
 
     def __iter__(self) -> Iterator[Address]:
         for index in range(len(self)):
@@ -43,6 +50,12 @@ class ASMArrayManager(Sequence):
     def get_pointer_to_element(self, index: int) -> int:
         return self.array_address + self.element_size * index
 
+    def get_address_of_element(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 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"

{trainerbase-3.13.0 → trainerbase-3.14.0}/trainerbase/gui/helpers.py

@@ -18,10 +18,9 @@ def simple_trainerbase_menu(window_title: str, width: int, height: int):
             dpg.create_context()
             dpg.create_viewport(
                 title=window_title,
-                min_width=width,
-                min_height=height,
                 width=width,
                 height=height,
+                resizable=False,
             )
             dpg.setup_dearpygui()
 
@@ -33,9 +32,11 @@ def simple_trainerbase_menu(window_title: str, width: int, height: int):
                 no_move=True,
                 no_title_bar=True,
                 horizontal_scrollbar=True,
+                autosize=True,
             ):
                 initializer()
 
+            dpg.set_primary_window("menu", value=True)
             dpg.show_viewport()
 
             on_initialized()

{trainerbase-3.13.0 → trainerbase-3.14.0}/trainerbase/memory.py

@@ -6,6 +6,8 @@ from typing import Final, Self, assert_never, cast, override
 
 from pymem.pattern import pattern_scan_all, pattern_scan_module
 from pymem.process import module_from_name
+from pymem.ressources.kernel32 import SetLastError, VirtualAllocEx
+from pymem.ressources.structure import MEMORY_PROTECTION, MEMORY_STATE
 
 from trainerbase.process import _pm as pm
 
@@ -19,6 +21,9 @@ type ConvertibleToAddress = AbstractAddress | int | bytes | str
 
 read_pointer = cast(Callable[[int], int], pm.read_ulonglong if pm.is_64_bit else pm.read_uint)
 
+__set_last_error = cast(Callable[[int], None], SetLastError)
+__virtual_alloc_ex = cast(Callable[..., int], VirtualAllocEx)
+
 
 class AbstractAddress(ABC):
     @abstractmethod
@@ -166,8 +171,8 @@ def ensure_address(obj: ConvertibleToAddress) -> AbstractAddress:
             raise TypeError(f"Cannot create AbstractAddress from {type(obj)}")
 
 
-def allocate(size: int = POINTER_SIZE, count: int = 1) -> int:
-    return pm.allocate(size * count)
+def allocate(size: int = POINTER_SIZE, count: int = 1, nearest_to: int | None = None) -> int:
+    return __pm_allocate_memory(cast(int, pm.process_handle), size * count, nearest_to)
 
 
 def get_module_address(module_name: str) -> int:
@@ -181,3 +186,32 @@ def get_module_address(module_name: str) -> int:
         return 0
 
     return module_info.lpBaseOfDll
+
+
+def __pm_allocate_memory(
+    handle: int,
+    size: int,
+    nearest_to: int | None = None,
+    allocation_type: MEMORY_STATE | None = None,
+    protection_type: MEMORY_PROTECTION | None = None,
+):
+    """
+    Pymem fork.
+
+    Reserves or commits a region of memory within the virtual address space of a specified process.
+    The function initializes the memory it allocates to zero, unless MEM_RESET is used.
+
+    https://msdn.microsoft.com/en-us/library/windows/desktop/aa366890%28v=vs.85%29.aspx
+    """
+
+    if allocation_type is None:
+        allocation_type = MEMORY_STATE.MEM_COMMIT
+
+    if protection_type is None:
+        protection_type = MEMORY_PROTECTION.PAGE_EXECUTE_READWRITE
+
+    __set_last_error(0)
+
+    address = __virtual_alloc_ex(handle, nearest_to, size, allocation_type.value, protection_type.value)
+
+    return address