Better types & some patches

PicoShot · PicoShot · commit 88da08a7fca6 · 2026-02-15T06:02:13.000+03:00
diff --git a/UnityInspector/src/game/features/inspector/inspector_esp.cpp b/UnityInspector/src/game/features/inspector/inspector_esp.cpp
@@ -5,22 +5,19 @@ void Inspector::DrawSelectedObjectBoundingBox() const
 {
 	UR::ThreadAttach();
 
-	if (activeTabIndex < 0 || std::cmp_greater_equal(activeTabIndex, openTabs.size()))
-		return;
+	if (activeTabIndex < 0 || std::cmp_greater_equal(activeTabIndex, openTabs.size())) return;
 
 	const auto& tab = openTabs[activeTabIndex];
-	if (!tab.gameObject || !Core::helper->SafeIsAlive(tab.gameObject))
-		return;
+	if (!tab.gameObject || !Core::helper->SafeIsAlive(tab.gameObject)) return;
 
 	UT::Transform* transform = nullptr;
-	if (!Core::helper->SafeGetTransform(tab.gameObject, transform) || !transform)
-		return;
+	if (!Core::helper->SafeGetTransform(tab.gameObject, transform) || !transform) return;
 
-	const Vec3 position = Core::helper->TryGetPosition(transform);
+	Vec3 position;
+	if (!Core::helper->TryGetPosition(transform, position)) return;
 
 	Vec2 screenPos;
-	if (!Core::helper->WorldToScreen(position, screenPos))
-		return;
+	if (!Core::helper->WorldToScreen(position, screenPos)) return;
 
 	const auto& drawList = ImGui::GetBackgroundDrawList();
 	const ImU32 redColor = ImGui::GetColorU32(ImVec4(1.0f, 0.0f, 0.0f, 1.0f));
diff --git a/UnityInspector/src/game/helper/helper.cpp b/UnityInspector/src/game/helper/helper.cpp
@@ -3,7 +3,7 @@
 #include "game/core/core.h"
 
 
-bool Helper::SafeIsAlive(UT::UnityObject* obj)
+bool Helper::SafeIsAlive(UnityObject* obj)
 {
     if (!obj) return false;
 
@@ -17,7 +17,7 @@ bool Helper::SafeIsAlive(UT::UnityObject* obj)
     }
 }
 
-bool Helper::SafeGetTag(UT::GameObject* obj, UT::String*& outTag)
+bool Helper::SafeGetTag(GameObject* obj, UT::String*& outTag)
 {
     if (!obj) return false;
 
@@ -32,7 +32,7 @@ bool Helper::SafeGetTag(UT::GameObject* obj, UT::String*& outTag)
     }
 }
 
-bool Helper::SafeGetActiveSelf(UT::GameObject* obj, bool& outActive)
+bool Helper::SafeGetActiveSelf(GameObject* obj, bool& outActive)
 {
     if (!obj) return false;
 
@@ -47,7 +47,7 @@ bool Helper::SafeGetActiveSelf(UT::GameObject* obj, bool& outActive)
     }
 }
 
-bool Helper::SafeSetActive(UT::GameObject* obj, bool value)
+bool Helper::SafeSetActive(GameObject* obj, bool value)
 {
     if (!obj) return false;
 
@@ -62,7 +62,7 @@ bool Helper::SafeSetActive(UT::GameObject* obj, bool value)
     }
 }
 
-bool Helper::SafeGetIsStatic(UT::GameObject* obj, bool& outStatic)
+bool Helper::SafeGetIsStatic(GameObject* obj, bool& outStatic)
 {
     if (!obj) return false;
 
@@ -165,111 +165,111 @@ bool Helper::SafeWriteBool(void* ptr, const int offset, const bool value)
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeReadVector2(void* ptr, const int offset, UT::Vector2& outValue)
+bool Helper::SafeReadVector2(void* ptr, const int offset, Vec2& outValue)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        outValue = *reinterpret_cast<UT::Vector2*>(reinterpret_cast<uintptr_t>(ptr) + offset);
+        outValue = *reinterpret_cast<Vec2*>(reinterpret_cast<uintptr_t>(ptr) + offset);
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeWriteVector2(void* ptr, const int offset, const UT::Vector2& value)
+bool Helper::SafeWriteVector2(void* ptr, const int offset, const Vec2& value)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        *reinterpret_cast<UT::Vector2*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
+        *reinterpret_cast<Vec2*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeReadVector3(void* ptr, const int offset, UT::Vector3& outValue)
+bool Helper::SafeReadVector3(void* ptr, const int offset, Vec3& outValue)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        outValue = *reinterpret_cast<UT::Vector3*>(reinterpret_cast<uintptr_t>(ptr) + offset);
+        outValue = *reinterpret_cast<Vec3*>(reinterpret_cast<uintptr_t>(ptr) + offset);
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeWriteVector3(void* ptr, const int offset, const UT::Vector3& value)
+bool Helper::SafeWriteVector3(void* ptr, const int offset, const Vec3& value)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        *reinterpret_cast<UT::Vector3*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
+        *reinterpret_cast<Vec3*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeReadVector4(void* ptr, const int offset, UT::Vector4& outValue)
+bool Helper::SafeReadVector4(void* ptr, const int offset, Vec4& outValue)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        outValue = *reinterpret_cast<UT::Vector4*>(reinterpret_cast<uintptr_t>(ptr) + offset);
+        outValue = *reinterpret_cast<Vec4*>(reinterpret_cast<uintptr_t>(ptr) + offset);
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeWriteVector4(void* ptr, const int offset, const UT::Vector4& value)
+bool Helper::SafeWriteVector4(void* ptr, const int offset, const Vec4& value)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        *reinterpret_cast<UT::Vector4*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
+        *reinterpret_cast<Vec4*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeReadQuaternion(void* ptr, const int offset, UT::Quaternion& outValue)
+bool Helper::SafeReadQuaternion(void* ptr, const int offset, Quat& outValue)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        outValue = *reinterpret_cast<UT::Quaternion*>(reinterpret_cast<uintptr_t>(ptr) + offset);
+        outValue = *reinterpret_cast<Quat*>(reinterpret_cast<uintptr_t>(ptr) + offset);
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeWriteQuaternion(void* ptr, const int offset, const UT::Quaternion& value)
+bool Helper::SafeWriteQuaternion(void* ptr, const int offset, const Quat& value)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        *reinterpret_cast<UT::Quaternion*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
+        *reinterpret_cast<Quat*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeReadColor(void* ptr, const int offset, UT::Color& outValue)
+bool Helper::SafeReadColor(void* ptr, const int offset, Color& outValue)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        outValue = *reinterpret_cast<UT::Color*>(reinterpret_cast<uintptr_t>(ptr) + offset);
+        outValue = *reinterpret_cast<Color*>(reinterpret_cast<uintptr_t>(ptr) + offset);
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
 }
 
-bool Helper::SafeWriteColor(void* ptr, const int offset, const UT::Color& value)
+bool Helper::SafeWriteColor(void* ptr, const int offset, const Color& value)
 {
     if (!ptr || offset < 0) return false;
     __try
     {
-        *reinterpret_cast<UT::Color*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
+        *reinterpret_cast<Color*>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;
         return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
@@ -450,7 +450,7 @@ bool Helper::SafeSetStaticFieldDouble(void* fieldHandle, double value)
     catch (...) { return false; }
 }
 
-bool Helper::SafeGetStaticFieldVector3(void* fieldHandle, UT::Vector3& outValue)
+bool Helper::SafeGetStaticFieldVector3(void* fieldHandle, Vec3& outValue)
 {
     if (!fieldHandle) return false;
     try
@@ -459,32 +459,32 @@ bool Helper::SafeGetStaticFieldVector3(void* fieldHandle, UT::Vector3& outValue)
         {
             void* vTable = UR::Invoke<void*, void*, void*>("mono_class_vtable", UR::pDomain,
                 UR::Invoke<void*, void*>("mono_field_get_parent", fieldHandle));
-            UR::Invoke<void, void*, void*, UT::Vector3*>("mono_field_static_get_value", vTable, fieldHandle, &outValue);
+            UR::Invoke<void, void*, void*, Vec3*>("mono_field_static_get_value", vTable, fieldHandle, &outValue);
         }
         else
         {
-            UR::Invoke<void, void*, UT::Vector3*>("il2cpp_field_static_get_value", fieldHandle, &outValue);
+            UR::Invoke<void, void*, Vec3*>("il2cpp_field_static_get_value", fieldHandle, &outValue);
         }
         return true;
     }
     catch (...) { return false; }
 }
 
-bool Helper::SafeSetStaticFieldVector3(void* fieldHandle, const UT::Vector3& value)
+bool Helper::SafeSetStaticFieldVector3(void* fieldHandle, const Vec3& value)
 {
     if (!fieldHandle) return false;
     try
     {
-        UT::Vector3 v = value;
+        Vec3 v = value;
         if (Core::config->gameMode == UnityResolve::Mode::Mono)
         {
             void* vTable = UR::Invoke<void*, void*, void*>("mono_class_vtable", UR::pDomain,
             UR::Invoke<void*, void*>("mono_field_get_parent", fieldHandle));
-            UR::Invoke<void, void*, void*, UT::Vector3*>("mono_field_static_set_value", vTable, fieldHandle, &v);
+            UR::Invoke<void, void*, void*, Vec3*>("mono_field_static_set_value", vTable, fieldHandle, &v);
         }
         else
         {
-            UR::Invoke<void, void*, UT::Vector3*>("il2cpp_field_static_set_value", fieldHandle, &v);
+            UR::Invoke<void, void*, Vec3*>("il2cpp_field_static_set_value", fieldHandle, &v);
         }
         return true;
     }
@@ -563,7 +563,7 @@ void* Helper::SafeInvokeMethod(void* obj, void* methodHandle, void** params, boo
     }
 }
 
-bool Helper::SafeGetGameObject(UT::Transform* transform, UT::GameObject*& outGameObject)
+bool Helper::SafeGetGameObject(Transform* transform, GameObject*& outGameObject)
 {
     if (!transform) return false;
     __try
@@ -578,7 +578,37 @@ bool Helper::SafeGetGameObject(UT::Transform* transform, UT::GameObject*& outGam
     }
 }
 
-bool Helper::SafeGetTransform(UT::GameObject* gameObject, UT::Transform*& outTransform)
+bool Helper::SafeGetGameObject(MonoBehaviour* mb, GameObject*& outGameObject)
+{
+    if (!mb) return false;
+    __try
+    {
+        outGameObject = mb->GetGameObject();
+        return outGameObject != nullptr;
+    }
+    __except (EXCEPTION_EXECUTE_HANDLER)
+    {
+        outGameObject = nullptr;
+        return false;
+    }
+}
+
+bool Helper::SafeGetGameObject(Rigidbody* rb, GameObject*& outGameObject)
+{
+    if (!rb) return false;
+    __try
+    {
+        outGameObject = rb->GetGameObject();
+        return outGameObject != nullptr;
+    }
+    __except (EXCEPTION_EXECUTE_HANDLER)
+    {
+        outGameObject = nullptr;
+        return false;
+    }
+}
+
+bool Helper::SafeGetTransform(GameObject* gameObject, Transform*& outTransform)
 {
     if (!gameObject) return false;
     __try
@@ -593,7 +623,22 @@ bool Helper::SafeGetTransform(UT::GameObject* gameObject, UT::Transform*& outTra
     }
 }
 
-bool Helper::SafeGetParent(UT::Transform* transform, UT::Transform*& outParent)
+bool Helper::SafeGetTransform(Rigidbody* gameObject, Transform*& outTransform)
+{
+    if (!gameObject) return false;
+    __try
+    {
+        outTransform = gameObject->GetTransform();
+        return outTransform != nullptr;
+    }
+    __except (EXCEPTION_EXECUTE_HANDLER)
+    {
+        outTransform = nullptr;
+        return false;
+    }
+}
+
+bool Helper::SafeGetParent(Transform* transform, Transform*& outParent)
 {
     if (!transform) return false;
     __try
@@ -608,7 +653,7 @@ bool Helper::SafeGetParent(UT::Transform* transform, UT::Transform*& outParent)
     }
 }
 
-bool Helper::SafeGetName(UT::UnityObject* obj, UT::String*& outName)
+bool Helper::SafeGetName(UnityObject* obj, UT::String*& outName)
 {
     if (!obj) return false;
     __try
@@ -623,7 +668,7 @@ bool Helper::SafeGetName(UT::UnityObject* obj, UT::String*& outName)
     }
 }
 
-bool Helper::SafeGetChildCount(UT::Transform* transform, int& outCount)
+bool Helper::SafeGetChildCount(Transform* transform, int& outCount)
 {
     if (!transform) return false;
     __try
@@ -638,7 +683,7 @@ bool Helper::SafeGetChildCount(UT::Transform* transform, int& outCount)
     }
 }
 
-bool Helper::SafeGetChild(UT::Transform* transform, int index, UT::Transform*& outChild)
+bool Helper::SafeGetChild(Transform* transform, int index, Transform*& outChild)
 {
     if (!transform) return false;
     __try
@@ -653,11 +698,12 @@ bool Helper::SafeGetChild(UT::Transform* transform, int index, UT::Transform*& o
     }
 }
 
-Vec3 Helper::TryGetPosition(Transform* go)
+bool Helper::TryGetPosition(Transform* go, Vec3& pos)
 {
     __try
     {
-        return go->GetPosition();
+        pos = go->GetPosition();
+        return true;
     }
     __except (EXCEPTION_EXECUTE_HANDLER)
     {
diff --git a/UnityInspector/src/game/helper/helper.h b/UnityInspector/src/game/helper/helper.h

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`#include "game/core/core.h"`
`4`	`4`
`5`	`5`
`6`		`-bool Helper::SafeIsAlive(UT::UnityObject* obj)`
	`6`	`+bool Helper::SafeIsAlive(UnityObject* obj)`
`7`	`7`	`{`
`8`	`8`	`if (!obj) return false;`
`9`	`9`
`@@ -17,7 +17,7 @@ bool Helper::SafeIsAlive(UT::UnityObject* obj)`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`		`-bool Helper::SafeGetTag(UT::GameObject* obj, UT::String*& outTag)`
	`20`	`+bool Helper::SafeGetTag(GameObject* obj, UT::String*& outTag)`
`21`	`21`	`{`
`22`	`22`	`if (!obj) return false;`
`23`	`23`
`@@ -32,7 +32,7 @@ bool Helper::SafeGetTag(UT::GameObject* obj, UT::String*& outTag)`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`		`-bool Helper::SafeGetActiveSelf(UT::GameObject* obj, bool& outActive)`
	`35`	`+bool Helper::SafeGetActiveSelf(GameObject* obj, bool& outActive)`
`36`	`36`	`{`
`37`	`37`	`if (!obj) return false;`
`38`	`38`
`@@ -47,7 +47,7 @@ bool Helper::SafeGetActiveSelf(UT::GameObject* obj, bool& outActive)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-bool Helper::SafeSetActive(UT::GameObject* obj, bool value)`
	`50`	`+bool Helper::SafeSetActive(GameObject* obj, bool value)`
`51`	`51`	`{`
`52`	`52`	`if (!obj) return false;`
`53`	`53`
`@@ -62,7 +62,7 @@ bool Helper::SafeSetActive(UT::GameObject* obj, bool value)`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`		`-bool Helper::SafeGetIsStatic(UT::GameObject* obj, bool& outStatic)`
	`65`	`+bool Helper::SafeGetIsStatic(GameObject* obj, bool& outStatic)`
`66`	`66`	`{`
`67`	`67`	`if (!obj) return false;`
`68`	`68`
`@@ -165,111 +165,111 @@ bool Helper::SafeWriteBool(void* ptr, const int offset, const bool value)`
`165`	`165`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`166`	`166`	`}`
`167`	`167`
`168`		`-bool Helper::SafeReadVector2(void* ptr, const int offset, UT::Vector2& outValue)`
	`168`	`+bool Helper::SafeReadVector2(void* ptr, const int offset, Vec2& outValue)`
`169`	`169`	`{`
`170`	`170`	`if (!ptr \|\| offset < 0) return false;`
`171`	`171`	`__try`
`172`	`172`	`{`
`173`		`- outValue = reinterpret_cast<UT::Vector2>(reinterpret_cast<uintptr_t>(ptr) + offset);`
	`173`	`+ outValue = reinterpret_cast<Vec2>(reinterpret_cast<uintptr_t>(ptr) + offset);`
`174`	`174`	`return true;`
`175`	`175`	`}`
`176`	`176`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`177`	`177`	`}`
`178`	`178`
`179`		`-bool Helper::SafeWriteVector2(void* ptr, const int offset, const UT::Vector2& value)`
	`179`	`+bool Helper::SafeWriteVector2(void* ptr, const int offset, const Vec2& value)`
`180`	`180`	`{`
`181`	`181`	`if (!ptr \|\| offset < 0) return false;`
`182`	`182`	`__try`
`183`	`183`	`{`
`184`		`- reinterpret_cast<UT::Vector2>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
	`184`	`+ reinterpret_cast<Vec2>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
`185`	`185`	`return true;`
`186`	`186`	`}`
`187`	`187`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`188`	`188`	`}`
`189`	`189`
`190`		`-bool Helper::SafeReadVector3(void* ptr, const int offset, UT::Vector3& outValue)`
	`190`	`+bool Helper::SafeReadVector3(void* ptr, const int offset, Vec3& outValue)`
`191`	`191`	`{`
`192`	`192`	`if (!ptr \|\| offset < 0) return false;`
`193`	`193`	`__try`
`194`	`194`	`{`
`195`		`- outValue = reinterpret_cast<UT::Vector3>(reinterpret_cast<uintptr_t>(ptr) + offset);`
	`195`	`+ outValue = reinterpret_cast<Vec3>(reinterpret_cast<uintptr_t>(ptr) + offset);`
`196`	`196`	`return true;`
`197`	`197`	`}`
`198`	`198`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`199`	`199`	`}`
`200`	`200`
`201`		`-bool Helper::SafeWriteVector3(void* ptr, const int offset, const UT::Vector3& value)`
	`201`	`+bool Helper::SafeWriteVector3(void* ptr, const int offset, const Vec3& value)`
`202`	`202`	`{`
`203`	`203`	`if (!ptr \|\| offset < 0) return false;`
`204`	`204`	`__try`
`205`	`205`	`{`
`206`		`- reinterpret_cast<UT::Vector3>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
	`206`	`+ reinterpret_cast<Vec3>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
`207`	`207`	`return true;`
`208`	`208`	`}`
`209`	`209`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`210`	`210`	`}`
`211`	`211`
`212`		`-bool Helper::SafeReadVector4(void* ptr, const int offset, UT::Vector4& outValue)`
	`212`	`+bool Helper::SafeReadVector4(void* ptr, const int offset, Vec4& outValue)`
`213`	`213`	`{`
`214`	`214`	`if (!ptr \|\| offset < 0) return false;`
`215`	`215`	`__try`
`216`	`216`	`{`
`217`		`- outValue = reinterpret_cast<UT::Vector4>(reinterpret_cast<uintptr_t>(ptr) + offset);`
	`217`	`+ outValue = reinterpret_cast<Vec4>(reinterpret_cast<uintptr_t>(ptr) + offset);`
`218`	`218`	`return true;`
`219`	`219`	`}`
`220`	`220`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`221`	`221`	`}`
`222`	`222`
`223`		`-bool Helper::SafeWriteVector4(void* ptr, const int offset, const UT::Vector4& value)`
	`223`	`+bool Helper::SafeWriteVector4(void* ptr, const int offset, const Vec4& value)`
`224`	`224`	`{`
`225`	`225`	`if (!ptr \|\| offset < 0) return false;`
`226`	`226`	`__try`
`227`	`227`	`{`
`228`		`- reinterpret_cast<UT::Vector4>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
	`228`	`+ reinterpret_cast<Vec4>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
`229`	`229`	`return true;`
`230`	`230`	`}`
`231`	`231`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`232`	`232`	`}`
`233`	`233`
`234`		`-bool Helper::SafeReadQuaternion(void* ptr, const int offset, UT::Quaternion& outValue)`
	`234`	`+bool Helper::SafeReadQuaternion(void* ptr, const int offset, Quat& outValue)`
`235`	`235`	`{`
`236`	`236`	`if (!ptr \|\| offset < 0) return false;`
`237`	`237`	`__try`
`238`	`238`	`{`
`239`		`- outValue = reinterpret_cast<UT::Quaternion>(reinterpret_cast<uintptr_t>(ptr) + offset);`
	`239`	`+ outValue = reinterpret_cast<Quat>(reinterpret_cast<uintptr_t>(ptr) + offset);`
`240`	`240`	`return true;`
`241`	`241`	`}`
`242`	`242`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`243`	`243`	`}`
`244`	`244`
`245`		`-bool Helper::SafeWriteQuaternion(void* ptr, const int offset, const UT::Quaternion& value)`
	`245`	`+bool Helper::SafeWriteQuaternion(void* ptr, const int offset, const Quat& value)`
`246`	`246`	`{`
`247`	`247`	`if (!ptr \|\| offset < 0) return false;`
`248`	`248`	`__try`
`249`	`249`	`{`
`250`		`- reinterpret_cast<UT::Quaternion>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
	`250`	`+ reinterpret_cast<Quat>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
`251`	`251`	`return true;`
`252`	`252`	`}`
`253`	`253`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`254`	`254`	`}`
`255`	`255`
`256`		`-bool Helper::SafeReadColor(void* ptr, const int offset, UT::Color& outValue)`
	`256`	`+bool Helper::SafeReadColor(void* ptr, const int offset, Color& outValue)`
`257`	`257`	`{`
`258`	`258`	`if (!ptr \|\| offset < 0) return false;`
`259`	`259`	`__try`
`260`	`260`	`{`
`261`		`- outValue = reinterpret_cast<UT::Color>(reinterpret_cast<uintptr_t>(ptr) + offset);`
	`261`	`+ outValue = reinterpret_cast<Color>(reinterpret_cast<uintptr_t>(ptr) + offset);`
`262`	`262`	`return true;`
`263`	`263`	`}`
`264`	`264`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`265`	`265`	`}`
`266`	`266`
`267`		`-bool Helper::SafeWriteColor(void* ptr, const int offset, const UT::Color& value)`
	`267`	`+bool Helper::SafeWriteColor(void* ptr, const int offset, const Color& value)`
`268`	`268`	`{`
`269`	`269`	`if (!ptr \|\| offset < 0) return false;`
`270`	`270`	`__try`
`271`	`271`	`{`
`272`		`- reinterpret_cast<UT::Color>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
	`272`	`+ reinterpret_cast<Color>(reinterpret_cast<uintptr_t>(ptr) + offset) = value;`
`273`	`273`	`return true;`
`274`	`274`	`}`
`275`	`275`	`__except (EXCEPTION_EXECUTE_HANDLER) { return false; }`
`@@ -450,7 +450,7 @@ bool Helper::SafeSetStaticFieldDouble(void* fieldHandle, double value)`
`450`	`450`	`catch (...) { return false; }`
`451`	`451`	`}`
`452`	`452`
`453`		`-bool Helper::SafeGetStaticFieldVector3(void* fieldHandle, UT::Vector3& outValue)`
	`453`	`+bool Helper::SafeGetStaticFieldVector3(void* fieldHandle, Vec3& outValue)`
`454`	`454`	`{`
`455`	`455`	`if (!fieldHandle) return false;`
`456`	`456`	`try`
`@@ -459,32 +459,32 @@ bool Helper::SafeGetStaticFieldVector3(void* fieldHandle, UT::Vector3& outValue)`
`459`	`459`	`{`
`460`	`460`	`void* vTable = UR::Invoke<void, void, void*>("mono_class_vtable", UR::pDomain,`
`461`	`461`	`UR::Invoke<void, void>("mono_field_get_parent", fieldHandle));`
`462`		`- UR::Invoke<void, void, void, UT::Vector3*>("mono_field_static_get_value", vTable, fieldHandle, &outValue);`
	`462`	`+ UR::Invoke<void, void, void, Vec3*>("mono_field_static_get_value", vTable, fieldHandle, &outValue);`
`463`	`463`	`}`
`464`	`464`	`else`
`465`	`465`	`{`
`466`		`- UR::Invoke<void, void, UT::Vector3>("il2cpp_field_static_get_value", fieldHandle, &outValue);`
	`466`	`+ UR::Invoke<void, void, Vec3>("il2cpp_field_static_get_value", fieldHandle, &outValue);`
`467`	`467`	`}`
`468`	`468`	`return true;`
`469`	`469`	`}`
`470`	`470`	`catch (...) { return false; }`
`471`	`471`	`}`
`472`	`472`
`473`		`-bool Helper::SafeSetStaticFieldVector3(void* fieldHandle, const UT::Vector3& value)`
	`473`	`+bool Helper::SafeSetStaticFieldVector3(void* fieldHandle, const Vec3& value)`
`474`	`474`	`{`
`475`	`475`	`if (!fieldHandle) return false;`
`476`	`476`	`try`
`477`	`477`	`{`
`478`		`- UT::Vector3 v = value;`
	`478`	`+ Vec3 v = value;`
`479`	`479`	`if (Core::config->gameMode == UnityResolve::Mode::Mono)`
`480`	`480`	`{`
`481`	`481`	`void* vTable = UR::Invoke<void, void, void*>("mono_class_vtable", UR::pDomain,`
`482`	`482`	`UR::Invoke<void, void>("mono_field_get_parent", fieldHandle));`
`483`		`- UR::Invoke<void, void, void, UT::Vector3*>("mono_field_static_set_value", vTable, fieldHandle, &v);`
	`483`	`+ UR::Invoke<void, void, void, Vec3*>("mono_field_static_set_value", vTable, fieldHandle, &v);`
`484`	`484`	`}`
`485`	`485`	`else`
`486`	`486`	`{`
`487`		`- UR::Invoke<void, void, UT::Vector3>("il2cpp_field_static_set_value", fieldHandle, &v);`
	`487`	`+ UR::Invoke<void, void, Vec3>("il2cpp_field_static_set_value", fieldHandle, &v);`
`488`	`488`	`}`
`489`	`489`	`return true;`
`490`	`490`	`}`
`@@ -563,7 +563,7 @@ void* Helper::SafeInvokeMethod(void* obj, void* methodHandle, void** params, boo`
`563`	`563`	`}`
`564`	`564`	`}`
`565`	`565`
`566`		`-bool Helper::SafeGetGameObject(UT::Transform* transform, UT::GameObject*& outGameObject)`
	`566`	`+bool Helper::SafeGetGameObject(Transform* transform, GameObject*& outGameObject)`
`567`	`567`	`{`
`568`	`568`	`if (!transform) return false;`
`569`	`569`	`__try`
`@@ -578,7 +578,37 @@ bool Helper::SafeGetGameObject(UT::Transform* transform, UT::GameObject*& outGam`
`578`	`578`	`}`
`579`	`579`	`}`
`580`	`580`
`581`		`-bool Helper::SafeGetTransform(UT::GameObject* gameObject, UT::Transform*& outTransform)`
	`581`	`+bool Helper::SafeGetGameObject(MonoBehaviour* mb, GameObject*& outGameObject)`
	`582`	`+{`
	`583`	`+ if (!mb) return false;`
	`584`	`+ __try`
	`585`	`+ {`
	`586`	`+ outGameObject = mb->GetGameObject();`
	`587`	`+ return outGameObject != nullptr;`
	`588`	`+ }`
	`589`	`+ __except (EXCEPTION_EXECUTE_HANDLER)`
	`590`	`+ {`
	`591`	`+ outGameObject = nullptr;`
	`592`	`+ return false;`
	`593`	`+ }`
	`594`	`+}`
	`595`	`+`
	`596`	`+bool Helper::SafeGetGameObject(Rigidbody* rb, GameObject*& outGameObject)`
	`597`	`+{`
	`598`	`+ if (!rb) return false;`
	`599`	`+ __try`
	`600`	`+ {`
	`601`	`+ outGameObject = rb->GetGameObject();`
	`602`	`+ return outGameObject != nullptr;`
	`603`	`+ }`
	`604`	`+ __except (EXCEPTION_EXECUTE_HANDLER)`
	`605`	`+ {`
	`606`	`+ outGameObject = nullptr;`
	`607`	`+ return false;`
	`608`	`+ }`
	`609`	`+}`
	`610`	`+`
	`611`	`+bool Helper::SafeGetTransform(GameObject* gameObject, Transform*& outTransform)`
`582`	`612`	`{`
`583`	`613`	`if (!gameObject) return false;`
`584`	`614`	`__try`
`@@ -593,7 +623,22 @@ bool Helper::SafeGetTransform(UT::GameObject* gameObject, UT::Transform*& outTra`
`593`	`623`	`}`
`594`	`624`	`}`
`595`	`625`
`596`		`-bool Helper::SafeGetParent(UT::Transform* transform, UT::Transform*& outParent)`
	`626`	`+bool Helper::SafeGetTransform(Rigidbody* gameObject, Transform*& outTransform)`
	`627`	`+{`
	`628`	`+ if (!gameObject) return false;`
	`629`	`+ __try`
	`630`	`+ {`
	`631`	`+ outTransform = gameObject->GetTransform();`
	`632`	`+ return outTransform != nullptr;`
	`633`	`+ }`
	`634`	`+ __except (EXCEPTION_EXECUTE_HANDLER)`
	`635`	`+ {`
	`636`	`+ outTransform = nullptr;`
	`637`	`+ return false;`
	`638`	`+ }`
	`639`	`+}`
	`640`	`+`
	`641`	`+bool Helper::SafeGetParent(Transform* transform, Transform*& outParent)`
`597`	`642`	`{`
`598`	`643`	`if (!transform) return false;`
`599`	`644`	`__try`
`@@ -608,7 +653,7 @@ bool Helper::SafeGetParent(UT::Transform* transform, UT::Transform*& outParent)`
`608`	`653`	`}`
`609`	`654`	`}`
`610`	`655`
`611`		`-bool Helper::SafeGetName(UT::UnityObject* obj, UT::String*& outName)`
	`656`	`+bool Helper::SafeGetName(UnityObject* obj, UT::String*& outName)`
`612`	`657`	`{`
`613`	`658`	`if (!obj) return false;`
`614`	`659`	`__try`
`@@ -623,7 +668,7 @@ bool Helper::SafeGetName(UT::UnityObject* obj, UT::String*& outName)`
`623`	`668`	`}`
`624`	`669`	`}`
`625`	`670`
`626`		`-bool Helper::SafeGetChildCount(UT::Transform* transform, int& outCount)`
	`671`	`+bool Helper::SafeGetChildCount(Transform* transform, int& outCount)`
`627`	`672`	`{`
`628`	`673`	`if (!transform) return false;`
`629`	`674`	`__try`
`@@ -638,7 +683,7 @@ bool Helper::SafeGetChildCount(UT::Transform* transform, int& outCount)`
`638`	`683`	`}`
`639`	`684`	`}`
`640`	`685`
`641`		`-bool Helper::SafeGetChild(UT::Transform* transform, int index, UT::Transform*& outChild)`
	`686`	`+bool Helper::SafeGetChild(Transform* transform, int index, Transform*& outChild)`
`642`	`687`	`{`
`643`	`688`	`if (!transform) return false;`
`644`	`689`	`__try`
`@@ -653,11 +698,12 @@ bool Helper::SafeGetChild(UT::Transform* transform, int index, UT::Transform*& o`
`653`	`698`	`}`
`654`	`699`	`}`
`655`	`700`
`656`		`-Vec3 Helper::TryGetPosition(Transform* go)`
	`701`	`+bool Helper::TryGetPosition(Transform* go, Vec3& pos)`
`657`	`702`	`{`
`658`	`703`	`__try`
`659`	`704`	`{`
`660`		`- return go->GetPosition();`
	`705`	`+ pos = go->GetPosition();`
	`706`	`+ return true;`
`661`	`707`	`}`
`662`	`708`	`__except (EXCEPTION_EXECUTE_HANDLER)`
`663`	`709`	`{`