unity-helper 1.3.2__tar.gz → 1.3.4__tar.gz

{unity_helper-1.3.2 → unity_helper-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unity_helper
-Version: 1.3.2
+Version: 1.3.4
 Summary: Runtime inspection toolkit for Unity IL2CPP applications — explore classes, methods, fields, and live objects in real time.
 License: MIT
 License-File: LICENSE

{unity_helper-1.3.2 → unity_helper-1.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unity_helper"
-version = "1.3.2"
+version = "1.3.4"
 description = "Runtime inspection toolkit for Unity IL2CPP applications — explore classes, methods, fields, and live objects in real time."
 authors = ["Chasss"]
 readme = "README.md"

{unity_helper-1.3.2 → unity_helper-1.3.4}/src/unity_helper/bindings.py

@@ -5,7 +5,6 @@ Reserved for internal use only.
 
 import ctypes
 from .structures import Vec3, Quaternion, Il2CppAssembly, Bounds, RaycastHit, Ray, Matrix4x4, Color, Vec2, Rect, Scene
-from .mono import MonoClass
 
 
 class Bindings():
@@ -62,9 +61,7 @@ class Bindings():
                 print(f"Failed to find: {method_name} some built in features wont work")
             return 0
 
-        return 0
-
-    def _initialize(self):
+    def _initialize_internals(self):
         self._il2cpp_init = self.__DO_API(self.game_asm.il2cpp_init, [], ctypes.c_void_p)
         self._il2cpp_domain_get = self.__DO_API(self.game_asm.il2cpp_domain_get, [], ctypes.c_void_p)
         self._il2cpp_thread_attach = self.__DO_API(self.game_asm.il2cpp_thread_attach, [ctypes.c_void_p], ctypes.c_void_p)
@@ -90,6 +87,7 @@ class Bindings():
         self._il2cpp_class_get_namespace = self.__DO_API(self.game_asm.il2cpp_class_get_namespace, [ctypes.c_void_p], ctypes.c_char_p)
         self._il2cpp_class_get_name = self.__DO_API(self.game_asm.il2cpp_class_get_name, [ctypes.c_void_p], ctypes.c_char_p)
         self._il2cpp_field_static_get_value = self.__DO_API(self.game_asm.il2cpp_field_static_get_value, [ctypes.c_void_p, ctypes.c_void_p], None)
+        self._il2cpp_field_static_set_value = self.__DO_API(self.game_asm.il2cpp_field_static_set_value, [ctypes.c_void_p, ctypes.c_void_p], None)
         self._il2cpp_field_get_flags = self.__DO_API(self.game_asm.il2cpp_field_get_flags, [ctypes.c_void_p], ctypes.c_int)
         self._il2cpp_field_set_value = self.__DO_API(self.game_asm.il2cpp_field_set_value, [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p], None)
         self._il2cpp_object_unbox = self.__DO_API(self.game_asm.il2cpp_object_unbox, [ctypes.c_void_p], ctypes.c_void_p)
@@ -113,18 +111,14 @@ class Bindings():
         self._il2cpp_method_is_inflated = self.__DO_API(self.game_asm.il2cpp_class_is_abstract, [ctypes.c_void_p], ctypes.c_bool)
         self._il2cpp_method_is_generic = self.__DO_API(self.game_asm.il2cpp_class_is_generic, [ctypes.c_void_p], ctypes.c_bool)
         self._il2cpp_method_is_instance = self.__DO_API(self.game_asm.il2cpp_class_is_inflated, [ctypes.c_void_p], ctypes.c_bool)
-
-        self._domain: int|None = None
-        self._attached = False
-        self._assembly_cache: dict[str, int] = {}
-        self._image_cache: dict[int, int] = {}
-        self._methodInfoData: dict[str, int] = {}
-        self._class_cache: list[MonoClass] = []
-
+        self._il2cpp_object_new = self.__DO_API(self.game_asm.il2cpp_object_new, [ctypes.c_void_p], ctypes.c_void_p)
 
         if self.init_il2cpp:
             self._il2cpp_init()
 
+    def _initialize_class_bindings(self):
+        self._ensure_attached()
+
         self._component = self.get_class_from_name('UnityEngine.CoreModule.dll', 'UnityEngine.Component')
 
         self._UnityEngine_Component__GetComponent = ctypes.WINFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p)(self.__find_method_by_criteria('_UnityEngine_Component__GetComponent', self._component, 'GetComponent', 1, 'System.Type type'))
@@ -229,6 +223,8 @@ class Bindings():
         self._UnityEngine_Object__get_hideFlags = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)(self.__find_method('_UnityEngine_Object__get_hideFlags', self._object, 'get_hideFlags'))
         self._UnityEngine_Object__set_hideFlags = ctypes.WINFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p)(self.__find_method('_UnityEngine_Object__set_hideFlags', self._object, 'set_hideFlags'))
         self._UnityEngine_Object__FindObjectFromInstanceID = ctypes.WINFUNCTYPE(ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p)(self.__find_method('_UnityEngine_Object__FindObjectFromInstanceID', self._object, 'FindObjectFromInstanceID'))
+        self._UnityEngine_Object__DontDestroyOnLoad = ctypes.WINFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p)(self.__find_method('_UnityEngine_Object__DontDestroyOnLoad', self._object, 'DontDestroyOnLoad'))
+
 
         self._transform = self.get_class_from_name('UnityEngine.CoreModule.dll', 'UnityEngine.Transform')
         
@@ -315,7 +311,7 @@ class Bindings():
         self._UnityEngine_SceneManager__LoadScene = ctypes.WINFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p)(self.__find_method('_UnityEngine_SceneManager__LoadScene', self._scene_manager, 'LoadScene', 1))
         self._UnityEngine_SceneManager__SetActiveScene = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)(self.__find_method('_UnityEngine_SceneManager__SetActiveScene', self._scene_manager, 'SetActiveScene'))
         self._UnityEngine_SceneManager__GetSceneAt = ctypes.WINFUNCTYPE(Scene, ctypes.c_int, ctypes.c_void_p)(self.__find_method('_UnityEngine_SceneManager__GetSceneAt', self._scene_manager, 'GetSceneAt', 1))
-
+        self._UnityEngine_SceneManager__MoveGameObjectToScene = ctypes.WINFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p)(self.__find_method('_UnityEngine_SceneManager__MoveGameObjectToScene', self._scene_manager, 'MoveGameObjectToScene'))
 
         self._physics = self.get_class_from_name('UnityEngine.PhysicsModule.dll', 'UnityEngine.Physics')
 

{unity_helper-1.3.2 → unity_helper-1.3.4}/src/unity_helper/main.py

@@ -9,11 +9,11 @@ import ctypes
 from . import memory
 from contextlib import contextmanager
 from .mono import MonoClass, MonoMethod
-from .objects import Camera, Object
+from .objects import Camera, GameObject
 from .bindings import Bindings
 from .structures import Il2CppArray, Vec3, Il2CppAssembly, Quaternion, Color, Vec2, Rect
 from .constants import TypeAttribute
-
+import threading
 
 class Il2cpp(Bindings):
     """
@@ -21,20 +21,93 @@ class Il2cpp(Bindings):
 
     Args:
         warn_on_missing (bool): If True, emits a warning when a built in requested method is not found; if False, missing methods fail silently. Defaults to `True`.
-        init_il2cpp (bool): If True it manually calls il2cpp_init to prevent crashing when attemping to call functions that rely on il2cpp to be initialized first (may break some games). Defaults to `True`.
+        init_il2cpp (bool): If True, manually calls il2cpp_init to prevent crashing when attemping to call functions that rely on il2cpp to be initialized first (may break some games). Defaults to `True`.
+        init_helpers (bool): If True, initializes helper functions like UnityEngine_Component__GetComponent which are used within ``objects.py`` module. Defaults to ``True``.
     """
     inst = None
-    def __init__(self, warn_on_missing:bool=True, init_il2cpp:bool=True):
+    def __init__(self, warn_on_missing:bool=True, init_il2cpp:bool=True, init_helpers=True):
         self.game_asm = ctypes.WinDLL("GameAssembly.dll")
+
         self.memory = memory
-        self.warn_on_missing = warn_on_missing
-        self.init_il2cpp = init_il2cpp
+        self.warn_on_missing:bool = warn_on_missing
+        self.init_il2cpp:bool = init_il2cpp
+        self._tls = threading.local()
+        self._tls.attached = None
+        self._tls.thread_ptr = None
+        self._tls.external_attach = None
+
+        self._assembly_cache: dict[str, int] = {}
+        self._image_cache: dict[int, int] = {}
+        self._methodInfoData: dict[str, int] = {}
+        self._class_cache: list[MonoClass] = []
+
         Il2cpp.inst = self
-        self._initialize()
+        self._initialize_internals()
+        
+        if init_helpers:
+            self._initialize_class_bindings()
 
     def _get_domain_raw(self) -> int|None:
         dom = self._il2cpp_domain_get()
         return int(dom) if dom else None
+        
+    def _ensure_attached(self):
+        """
+        Attach current thread once.
+        Safe to call repeatedly.
+        """
+
+        # already attached by us
+        if getattr(self._tls, "attached", False):
+            return self._tls.thread_ptr
+
+        # already attached externally (Unity/game thread)
+        current_thread = None
+
+        if self._il2cpp_thread_current:
+            try:
+                current_thread = self._il2cpp_thread_current()
+            except Exception:
+                current_thread = None
+
+        if current_thread:
+            self._tls.attached = True
+            self._tls.thread_ptr = current_thread
+            self._tls.external_attach = True
+            return current_thread
+
+        # attach ourselves
+        dom = self._get_domain_raw()
+        if not dom:
+            raise RuntimeError("il2cpp domain not available")
+
+        thread_ptr = self._il2cpp_thread_attach(ctypes.c_void_p(dom))
+
+        self._tls.attached = True
+        self._tls.thread_ptr = thread_ptr
+        self._tls.external_attach = False
+
+        return thread_ptr
+    
+    def _detach_current_thread(self):
+        """
+        Detach only if WE attached it.
+        """
+
+        if not getattr(self._tls, "attached", False):
+            return
+
+        if getattr(self._tls, "external_attach", False):
+            return
+
+        try:
+            if self._il2cpp_thread_detach:
+                self._il2cpp_thread_detach(self._tls.thread_ptr)
+        except Exception:
+            pass
+
+        self._tls.attached = False
+        self._tls.thread_ptr = None
     
     
     @contextmanager
@@ -81,27 +154,25 @@ class Il2cpp(Bindings):
 
     
     def __open_assembly(self, assembly_name:str) -> int|None:
-        with self._attached_context():
-            if assembly_name in self._assembly_cache:
-                return self._assembly_cache[assembly_name]
-            dom = self._get_domain_raw()
-            asm = self._il2cpp_domain_assembly_open(ctypes.c_void_p(dom), assembly_name.encode())
-            if not asm:
-                return None
-            self._assembly_cache[assembly_name] = int(asm)
-            return int(asm)
+        if assembly_name in self._assembly_cache:
+            return self._assembly_cache[assembly_name]
+        dom = self._get_domain_raw()
+        asm = self._il2cpp_domain_assembly_open(ctypes.c_void_p(dom), assembly_name.encode())
+        if not asm:
+            return None
+        self._assembly_cache[assembly_name] = int(asm)
+        return int(asm)
 
     def __get_image_from_assembly(self, assembly_ptr: int) -> int|None:
-        with self._attached_context():
-            if assembly_ptr in self._image_cache:
-                return self._image_cache[assembly_ptr]
-            try:
-                ptr = ctypes.cast(ctypes.c_void_p(assembly_ptr), ctypes.POINTER(ctypes.c_void_p))
-                img = int(ptr[0])
-            except Exception:
-                return None
-            self._image_cache[assembly_ptr] = img
-            return img
+        if assembly_ptr in self._image_cache:
+            return self._image_cache[assembly_ptr]
+        try:
+            ptr = ctypes.cast(ctypes.c_void_p(assembly_ptr), ctypes.POINTER(ctypes.c_void_p))
+            img = int(ptr[0])
+        except Exception:
+            return None
+        self._image_cache[assembly_ptr] = img
+        return img
         
 
     def _read_il2cpp_array(self, arr_ptr) -> int|None:
@@ -211,21 +282,21 @@ class Il2cpp(Bindings):
         if not img:
             return None
 
-        with self._attached_context():
-            cls = self._il2cpp_class_from_name(ctypes.c_void_p(img), namespace.encode(), klass.encode())
-            if not cls:
-                return None
-            
-            type_ = self._il2cpp_class_get_type(ctypes.c_void_p(cls))
-            type_obj = self._il2cpp_type_get_object(type_)
-            flags = TypeAttribute(self._il2cpp_class_get_flags(cls))
-            is_static = (TypeAttribute.ABSTRACT in flags) and (TypeAttribute.SEALED in flags)
-    
-            monoclass = MonoClass(self, int(cls), klass, flags, type_obj, type_, is_static)
-            if not any(i.name == monoclass.name and i.cls == monoclass.cls for i in self._class_cache):
-                self._class_cache.append(monoclass)
+        
+        cls = self._il2cpp_class_from_name(ctypes.c_void_p(img), namespace.encode(), klass.encode())
+        if not cls:
+            return None
+        
+        type_ = self._il2cpp_class_get_type(ctypes.c_void_p(cls))
+        type_obj = self._il2cpp_type_get_object(type_)
+        flags = TypeAttribute(self._il2cpp_class_get_flags(cls))
+        is_static = (TypeAttribute.ABSTRACT in flags) and (TypeAttribute.SEALED in flags)
 
-            return monoclass
+        monoclass = MonoClass(self, int(cls), klass, flags, type_obj, type_, is_static)
+        if not any(i.name == monoclass.name and i.cls == monoclass.cls for i in self._class_cache):
+            self._class_cache.append(monoclass)
+
+        return monoclass
 
     def find_method(self, assembly_name:str, klass:str, method_name:str, param_count:int|None = None, cache:bool = True) -> MonoMethod|None:
         """
@@ -316,56 +387,56 @@ class Il2cpp(Bindings):
             return None
 
 
-    def find_object(self, object_str:str) -> Object|None:
+    def find_object(self, object_str:str) -> GameObject|None:
         """
-        Retrieve an object by name.
+        Retrieve an game object by name.
 
         Args:
-            object_str (str): Object name e.g., ``'Player'``.
+            object_str (str): GameObject name e.g., ``'Player'``.
 
         Returns:
-            Object | None: Matching object if found, otherwise ``None``.
+            GameObject | None: Matching game object if found, otherwise ``None``.
         """
         try:
             obj = self._UnityEngine_GameObject__Find(self._il2cpp_string_new(object_str.encode()), self._methodInfoData['_UnityEngine_GameObject__Find'])
             if not obj:
                 return None
-            return Object(obj)
+            return GameObject(obj)
         except:
             return None
     
-    def find_object_with_tag(self, tag_str:str) -> Object|None:
+    def find_object_with_tag(self, tag_str:str) -> GameObject|None:
         """
         Retreives a object by tag
 
         Args:
-            tag_str (str): Object name e.g., ``'Player'``.
+            tag_str (str): GameObject name e.g., ``'Player'``.
 
         Returns:
-            Object | None: Matching object if found, otherwise ``None``.
+            GameObject | None: Matching object if found, otherwise ``None``.
         """
         try:
             obj = self._UnityEngine_GameObject__FindGameObjectWithTag(self._il2cpp_string_new(tag_str.encode()), self._methodInfoData['_UnityEngine_GameObject__FindGameObjectWithTag'])
             if not obj:
                 return None
-            return Object(obj)
+            return GameObject(obj)
         except:
             return None
         
 
-    def find_objects_with_tag(self, tag_str:str) -> list[Object]:
+    def find_objects_with_tag(self, tag_str:str) -> list[GameObject]:
         """
         Retreives a list of objects based on the given name
 
         Args:
-            tag_str (str): Object name e.g., 'Player'
+            tag_str (str): GameObject name e.g., 'Player'
 
         Returns:
-            List[Object]: A list containing object objects if found otherwise ``None``.
+            List[Ga,eObject]: A list containing object objects if found otherwise ``None``.
         """
         try:
             arr = self._UnityEngine_GameObject__FindGameObjectsWithTag(self._il2cpp_string_new(tag_str.encode()), self._methodInfoData['_UnityEngine_GameObject__FindGameObjectsWithTag'])
-            objs = [Object(i) for i in self._read_il2cpp_array(arr) if i]
+            objs = [GameObject(i) for i in self._read_il2cpp_array(arr) if i]
             return objs
         except:
             return None
@@ -389,29 +460,28 @@ class Il2cpp(Bindings):
             return []
 
         classes = []
-        with self._attached_context():
-            class_count = self._il2cpp_image_get_class_count(ctypes.c_void_p(img_ptr))
-            for i in range(class_count):
-                cls_ptr = self._il2cpp_image_get_class(ctypes.c_void_p(img_ptr), i)
-                if not cls_ptr:
-                    continue
-                cls_namespace = self._il2cpp_class_get_namespace(ctypes.c_void_p(cls_ptr))
-                cls_namespace = cls_namespace.decode() if cls_namespace else ""
-                cls_name = self._il2cpp_class_get_name(ctypes.c_void_p(cls_ptr))
-                cls_name = cls_name.decode() if cls_name else ""
-                type_ = self._il2cpp_class_get_type(ctypes.c_void_p(cls_ptr))
-                type_obj = self._il2cpp_type_get_object(type_)
-                
-                full_name = ".".join(filter(None, [cls_namespace, cls_name]))
-                flags = TypeAttribute(self._il2cpp_class_get_flags(cls_ptr))
-                is_static = (TypeAttribute.ABSTRACT in flags) and (TypeAttribute.SEALED in flags)
-
-                cls = MonoClass(self, cls_ptr, full_name, flags, type_obj, type_, is_static)
-                
-                if not any(i.name == cls.name and i.object == i.object for i in self._class_cache):
-                    self._class_cache.append(cls)
-
-                classes.append(cls)
+        class_count = self._il2cpp_image_get_class_count(ctypes.c_void_p(img_ptr))
+        for i in range(class_count):
+            cls_ptr = self._il2cpp_image_get_class(ctypes.c_void_p(img_ptr), i)
+            if not cls_ptr:
+                continue
+            cls_namespace = self._il2cpp_class_get_namespace(ctypes.c_void_p(cls_ptr))
+            cls_namespace = cls_namespace.decode() if cls_namespace else ""
+            cls_name = self._il2cpp_class_get_name(ctypes.c_void_p(cls_ptr))
+            cls_name = cls_name.decode() if cls_name else ""
+            type_ = self._il2cpp_class_get_type(ctypes.c_void_p(cls_ptr))
+            type_obj = self._il2cpp_type_get_object(type_)
+            
+            full_name = ".".join(filter(None, [cls_namespace, cls_name]))
+            flags = TypeAttribute(self._il2cpp_class_get_flags(cls_ptr))
+            is_static = (TypeAttribute.ABSTRACT in flags) and (TypeAttribute.SEALED in flags)
+
+            cls = MonoClass(self, cls_ptr, full_name, flags, type_obj, type_, is_static)
+            
+            if not any(i.name == cls.name and i.object == i.object for i in self._class_cache):
+                self._class_cache.append(cls)
+
+            classes.append(cls)
 
         return classes
     
@@ -424,36 +494,35 @@ class Il2cpp(Bindings):
         """
         assemblies = []
 
-        with self._attached_context():
-            domain = self._get_domain_raw()
+        domain = self._get_domain_raw()
 
-            size = ctypes.c_size_t()
-            assembly_array_ptr = self._il2cpp_domain_get_assemblies(
-                ctypes.c_void_p(domain),
-                ctypes.byref(size)
-            )
+        size = ctypes.c_size_t()
+        assembly_array_ptr = self._il2cpp_domain_get_assemblies(
+            ctypes.c_void_p(domain),
+            ctypes.byref(size)
+        )
 
-            assembly_array = ctypes.cast(
-                assembly_array_ptr,
-                ctypes.POINTER(ctypes.POINTER(Il2CppAssembly))
-            )
+        assembly_array = ctypes.cast(
+            assembly_array_ptr,
+            ctypes.POINTER(ctypes.POINTER(Il2CppAssembly))
+        )
 
-            for i in range(size.value):
-                assembly_ptr = assembly_array[i]
-                if not assembly_ptr:
-                    continue
+        for i in range(size.value):
+            assembly_ptr = assembly_array[i]
+            if not assembly_ptr:
+                continue
 
-                assembly = assembly_ptr.contents
-                if not assembly.image:
-                    continue
+            assembly = assembly_ptr.contents
+            if not assembly.image:
+                continue
 
-                image = assembly.image.contents
-                if not image.name:
-                    continue
+            image = assembly.image.contents
+            if not image.name:
+                continue
 
-                name = image.name.decode("utf-8", errors="ignore")
+            name = image.name.decode("utf-8", errors="ignore")
 
-                assemblies.append(name)
+            assemblies.append(name)
 
         return assemblies