www

www

IDA/project/helpers.cpp

@@ -0,0 +1,598 @@
+#include "helpers.h"
+
+#include <algorithm>
+#include <array>
+#include <cctype>
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <cwctype>
+
+#include "nlohmann/json.hpp"
+
+RuntimeConfig g_Runtime;
+
+namespace {
+
+std::mutex g_il2cpp_mutex;
+std::unordered_map<uintptr_t, void*> g_il2cpp_slots;
+
+void* g_il2cpp_domain_cached = nullptr;
+void* (*g_il2cpp_domain_get_fn)() = nullptr;
+void* (*g_il2cpp_thread_attach_fn)(void*) = nullptr;
+void* (*g_il2cpp_thread_current_fn)() = nullptr;
+void (*g_il2cpp_thread_detach_fn)(void*) = nullptr;
+
+thread_local void* g_tls_il2cpp_thread = nullptr;
+thread_local bool g_tls_il2cpp_attached_by_us = false;
+thread_local bool g_tls_game_thread_context = false;
+
+std::mutex g_i18n_mutex;
+bool g_i18n_initialized = false;
+std::unordered_map<std::string, std::string> g_en;
+std::unordered_map<std::string, std::string> g_zh_cn;
+
+constexpr const char* kI18nBlob = R"json(
+{
+  "NoClip": {"en":"NoClip", "zh_cn":"NoClip"},
+  "FreeCam": {"en":"FreeCam", "zh_cn":"????"},
+  "Free Camera": {"en":"Free Camera", "zh_cn":"????"},
+  "Fps Unlocker": {"en":"Fps Unlocker", "zh_cn":"????"},
+  "FPSModule": {"en":"FPSModule", "zh_cn":"FPS??"},
+  "SetDither": {"en":"SetDither", "zh_cn":"????"},
+  "Set Dither": {"en":"Set Dither", "zh_cn":"????"},
+  "PlayerProfile": {"en":"PlayerProfile", "zh_cn":"????"},
+  "Vacuum": {"en":"Vacuum", "zh_cn":"??"},
+  "SkillHack": {"en":"SkillHack", "zh_cn":"????"},
+  "Free Skill": {"en":"Free Skill", "zh_cn":"????"},
+  "ESPModule": {"en":"ESPModule", "zh_cn":"ESP??"},
+  "ESP Features": {"en":"ESP Features", "zh_cn":"ESP??"},
+  "Prevent Screenshot": {"en":"Prevent Screenshot", "zh_cn":"???"},
+  "Unity Explorer": {"en":"Unity Explorer", "zh_cn":"Unity???"},
+  "Unity Explorer Window": {"en":"Unity Explorer Window", "zh_cn":"Unity?????"},
+  "ON / OFF": {"en":"ON / OFF", "zh_cn":"? / ?"},
+  "Move Speed": {"en":"Move Speed", "zh_cn":"????"},
+  "Look Sensitivity": {"en":"Look Sensitivity", "zh_cn":"?????"},
+  "Roll Speed": {"en":"Roll Speed", "zh_cn":"????"},
+  "FOV Speed": {"en":"FOV Speed", "zh_cn":"????"},
+  "FOV": {"en":"FOV", "zh_cn":"??"},
+  "Fps Value": {"en":"Fps Value", "zh_cn":"???"},
+  "UID text": {"en":"UID text", "zh_cn":"UID??"},
+  "Name text": {"en":"Name text", "zh_cn":"????"},
+  "Name changer": {"en":"Name changer", "zh_cn":"??"},
+  "Monster": {"en":"Monster", "zh_cn":"??"},
+  "Show Monsters": {"en":"Show Monsters", "zh_cn":"????"},
+  "Show NPC": {"en":"Show NPC", "zh_cn":"??NPC"},
+  "Show Friendly": {"en":"Show Friendly", "zh_cn":"????"},
+  "Show Puzzles": {"en":"Show Puzzles", "zh_cn":"??????"},
+  "Show All": {"en":"Show All", "zh_cn":"????"},
+  "Show Distance": {"en":"Show Distance", "zh_cn":"????"},
+  "Show Name": {"en":"Show Name", "zh_cn":"????"},
+  "Show Type": {"en":"Show Type", "zh_cn":"????"},
+  "Theme": {"en":"Theme", "zh_cn":"??"},
+  "Toggle Console": {"en":"Toggle Console", "zh_cn":"?????"},
+  "About": {"en":"About", "zh_cn":"??"},
+  "Player": {"en":"Player", "zh_cn":"??"},
+  "ESP": {"en":"ESP", "zh_cn":"ESP"},
+  "World": {"en":"World", "zh_cn":"??"},
+  "Visual": {"en":"Visual", "zh_cn":"??"},
+  "Settings": {"en":"Settings", "zh_cn":"??"},
+  "Damagehack Toggle": {"en":"Damagehack Toggle", "zh_cn":"????"},
+  "Damage Multiplier": {"en":"Damage Multiplier", "zh_cn":"????"},
+  "Multiplier Value": {"en":"Multiplier Value", "zh_cn":"???"},
+  "Random Damage Type": {"en":"Random Damage Type", "zh_cn":"??????"},
+  "This is free, if you spend money, then you have been deceived": {
+    "en":"This is free, if you spend money, then you have been deceived",
+    "zh_cn":"?????,??????,?????"
+  }
+}
+)json";
+
+ImVec4 ParseHexColor(const char* rrggbbaa) {
+    unsigned int rgba = 0u;
+    sscanf_s(rrggbbaa, "%x", &rgba);
+    const float r = static_cast<float>((rgba >> 24) & 0xFF) / 255.0f;
+    const float g = static_cast<float>((rgba >> 16) & 0xFF) / 255.0f;
+    const float b = static_cast<float>((rgba >> 8) & 0xFF) / 255.0f;
+    const float a = static_cast<float>(rgba & 0xFF) / 255.0f;
+    return ImVec4(r, g, b, a);
+}
+
+void ApplyThemePalette(const std::array<const char*, 11>& colors) {
+    ImGuiStyle& style = ImGui::GetStyle();
+    style.Colors[ImGuiCol_Text] = ParseHexColor(colors[0]);
+    style.Colors[ImGuiCol_WindowBg] = ParseHexColor(colors[1]);
+    style.Colors[ImGuiCol_ChildBg] = ParseHexColor(colors[2]);
+    style.Colors[ImGuiCol_PopupBg] = ParseHexColor(colors[3]);
+    style.Colors[ImGuiCol_Border] = ParseHexColor(colors[4]);
+    style.Colors[ImGuiCol_FrameBg] = ParseHexColor(colors[5]);
+    style.Colors[ImGuiCol_FrameBgHovered] = ParseHexColor(colors[6]);
+    style.Colors[ImGuiCol_FrameBgActive] = ParseHexColor(colors[7]);
+    style.Colors[ImGuiCol_Button] = ParseHexColor(colors[8]);
+    style.Colors[ImGuiCol_ButtonHovered] = ParseHexColor(colors[9]);
+    style.Colors[ImGuiCol_ButtonActive] = ParseHexColor(colors[10]);
+}
+
+uintptr_t FindGameAssemblyBaseNow() {
+    HMODULE h = GetModuleHandleW(L"GameAssembly.dll");
+    if (!h) {
+        h = GetModuleHandleW(L"gameassembly.dll");
+    }
+    if (h) {
+        return reinterpret_cast<uintptr_t>(h);
+    }
+
+    HMODULE modules[2048] = {};
+    DWORD needed = 0;
+    if (!K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &needed)) {
+        return 0;
+    }
+
+    const size_t count = needed / sizeof(HMODULE);
+    for (size_t i = 0; i < count; ++i) {
+        wchar_t path[MAX_PATH] = {};
+        if (K32GetModuleFileNameExW(GetCurrentProcess(), modules[i], path, MAX_PATH) == 0) {
+            continue;
+        }
+        std::wstring name = path;
+        std::transform(name.begin(), name.end(), name.begin(), [](wchar_t c) {
+            return static_cast<wchar_t>(::towlower(c));
+        });
+        if (name.find(L"gameassembly.dll") != std::wstring::npos) {
+            return reinterpret_cast<uintptr_t>(modules[i]);
+        }
+    }
+    return 0;
+}
+
+void ResolveIl2CppThreadApisOnce() {
+    HMODULE ga = GetModuleHandleW(L"GameAssembly.dll");
+    if (!ga) {
+        ga = GetModuleHandleW(L"gameassembly.dll");
+    }
+    if (!ga) {
+        return;
+    }
+
+    g_il2cpp_domain_get_fn =
+        reinterpret_cast<void* (*)()>(GetProcAddress(ga, "il2cpp_domain_get"));
+    g_il2cpp_thread_attach_fn =
+        reinterpret_cast<void* (*)(void*)>(GetProcAddress(ga, "il2cpp_thread_attach"));
+    g_il2cpp_thread_current_fn =
+        reinterpret_cast<void* (*)()>(GetProcAddress(ga, "il2cpp_thread_current"));
+    g_il2cpp_thread_detach_fn =
+        reinterpret_cast<void (*)(void*)>(GetProcAddress(ga, "il2cpp_thread_detach"));
+}
+
+}  // namespace
+
+const std::array<Il2cppSlotDefinition, 71> kIl2cppSlotMap = {{
+    {0x1C48, 0x09DC0120, "GameObject.GetComponentByIndex"},
+    {0x1C50, 0x0018CEC0, "il2cpp_domain_get_assemblies_A"},
+    {0x1C58, 0x0B390700, "Component.GetComponent<Transform>"},
+    {0x1C60, 0x0B3A2D20, "Transform.get_localScale"},
+    {0x1C68, 0x0B3A2CB0, "Transform.get_rotation"},
+    {0x1C70, 0x0018AD80, "il2cpp_object_get_class"},
+    {0x1C78, 0x00007480, "il2cpp_class_get_method_from_name"},
+    {0x1C80, 0x0B3A1AE0, "Transform.get_localPosition"},
+    {0x1C88, 0x0B3A1A70, "Transform.get_position"},
+    {0x1C90, 0x0B3A51D0, "Transform.set_localPosition"},
+    {0x1C98, 0x0B398830, "GameObject.SetActive"},
+    {0x1CA0, 0x0B3911F0, "GameObject.get_transform"},
+    {0x1CA8, 0x0B3A59D0, "Transform.set_rotation"},
+    {0x1CB0, 0x0B391D90, "GameObject.get_activeInHierarchy"},
+    {0x1CB8, 0x0B3B2410, "GameObject.get_tag"},
+    {0x1CC0, 0x0B3B2120, "GameObject.get_name"},
+    {0x1CC8, 0x0B3B40B0, "GameObject.get_layer"},
+    {0x1CD0, 0x0B397980, "GameObject.get_scene"},
+    {0x1CD8, 0x02F3DA80, "Game_SkillBuff_A"},
+    {0x1CE0, 0x00F27E10, "GetEntityName"},
+    {0x1CE8, 0x0B329000, "Component.GetComponents"},
+    {0x1CF0, 0x0B329D80, "Component.GetComponentsInChildren"},
+    {0x1CF8, 0x03E9BB50, "Game_SkillSlot_A"},
+    {0x1D00, 0x0B383F60, "Object.get_name"},
+    {0x1D08, 0x0B33CAB0, "Component.GetType_A"},
+    {0x1D10, 0x0B33CB00, "Component.GetType_B"},
+    {0x1D18, 0x039D1AA0, "Game_SkillSlot_B"},
+    {0x1D20, 0x026DE9F0, "Game_Combat_HitA"},
+    {0x1D28, 0x0478E860, "GetEntityManager"},
+    {0x1D30, 0x025E2D40, "Game_Combat_HitB"},
+    {0x1D38, 0x087C2CD0, "Game_Movement_PhysA"},
+    {0x1D40, 0x03419AF0, "Game_Movement_PhysB"},
+    {0x1D48, 0x0B322FB0, "Scene.get_name / Application.set_targetFrameRate ref"},
+    {0x1D50, 0x0B396A20, "SceneManager.GetActiveScene"},
+    {0x1D58, 0x0B397700, "CinemachineBrain.get_ActiveVirtualCamera"},
+    {0x1D60, 0x03766810, "Game_EntityState_A"},
+    {0x1D68, 0x0B3A2A60, "Transform.set_localScale"},
+    {0x1D70, 0x0B326660, "Rigidbody.get_velocity"},
+    {0x1D78, 0x0B3266B0, "Rigidbody.set_velocity"},
+    {0x1D80, 0x0B383200, "Object.Destroy"},
+    {0x1D88, 0x0B3A1A10, "Transform.set_position"},
+    {0x1D90, 0x0B3A2340, "Game_EntityState_B"},
+    {0x1D98, 0x0B421800, "Input.GetAxis(Mouse X)"},
+    {0x1DA0, 0x0B3A26D0, "Game_PlayerState_A"},
+    {0x1DA8, 0x0B3A1FB0, "Game_PlayerState_B"},
+    {0x1DB0, 0x0B32B030, "Game_PlayerHealthStat"},
+    {0x1DB8, 0x0B391240, "GameObject.SetActive (second ref)"},
+    {0x1DC0, 0x0B390440, "Camera.get_main"},
+    {0x1DC8, 0x0B390F80, "GameObject.FindObjectOfType"},
+    {0x1DD0, 0x0B3A19A0, "Transform.get_position (second ref)"},
+    {0x1DD8, 0x03F85430, "Game_SkillAction_C"},
+    {0x1DE0, 0x0B3A1D30, "Transform.set_rotation (second ref)"},
+    {0x1DE8, 0x0B3A1C90, "Camera.get_fieldOfView"},
+    {0x1DF0, 0x00E92CF0, "Game_EntityState_C"},
+    {0x1E00, 0x03DC14C0, "Game_SkillAction_D"},
+    {0x1E08, 0x03E0D2C0, "Game_SkillAction_E"},
+    {0x1E10, 0x03D9DF30, "Game_SkillAction_F"},
+    {0x1E18, 0x00E9E9F0, "Game_SkillAction_G"},
+    {0x1E20, 0x03EA53C0, "Game_SkillAction_H"},
+    {0x1E28, 0x0ACA0EC0, "TMPro.set_text"},
+    {0x1E30, 0x0B391D40, "UnityUI.Text.set_text"},
+    {0x1E38, 0x036AA8F0, "Game_SkillAction_I"},
+    {0x1E40, 0x03EC31C0, "Game_SkillAction_J"},
+    {0x1E48, 0x037F8CD0, "Game_EntityActor_D"},
+    {0x1E50, 0x036EA640, "Game_SkillAction_K"},
+    {0x1E58, 0x03EC30E0, "Game_SkillAction_L"},
+    {0x1E60, 0x037F2A40, "Game_EntityActor_E"},
+    {0x1E68, 0x037FD7E0, "Game_EntityActor_F"},
+    {0x1E70, 0x00D94C10, "il2cpp_domain_get"},
+    {0x1E78, 0x00D94DA0, "il2cpp_assembly_get_image"},
+    {0x1E80, 0x00D93A60, "il2cpp_domain_get_assemblies_B"},
+}};
+
+void Log(const char* fmt, ...) {
+    char buffer[2048] = {};
+    va_list args;
+    va_start(args, fmt);
+    std::vsnprintf(buffer, sizeof(buffer), fmt, args);
+    va_end(args);
+
+    OutputDebugStringA(buffer);
+    OutputDebugStringA("\n");
+
+    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (h != nullptr && h != INVALID_HANDLE_VALUE) {
+        DWORD written = 0;
+        WriteConsoleA(h, buffer, static_cast<DWORD>(std::strlen(buffer)), &written, nullptr);
+        WriteConsoleA(h, "\n", 1, &written, nullptr);
+    }
+}
+
+std::wstring Utf8ToWide(const std::string& value) {
+    if (value.empty()) {
+        return {};
+    }
+    const int size = MultiByteToWideChar(65001, 0, value.c_str(), -1, nullptr, 0);
+    if (size <= 0) {
+        return {};
+    }
+    std::wstring result(static_cast<size_t>(size), L'\0');
+    MultiByteToWideChar(65001, 0, value.c_str(), -1, result.data(), size);
+    if (!result.empty() && result.back() == L'\0') {
+        result.pop_back();
+    }
+    return result;
+}
+
+std::string WideToUtf8(const std::wstring& value) {
+    if (value.empty()) {
+        return {};
+    }
+    const int size = WideCharToMultiByte(65001, 0, value.c_str(), -1, nullptr, 0, nullptr, nullptr);
+    if (size <= 0) {
+        return {};
+    }
+    std::string result(static_cast<size_t>(size), '\0');
+    WideCharToMultiByte(65001, 0, value.c_str(), -1, result.data(), size, nullptr, nullptr);
+    if (!result.empty() && result.back() == '\0') {
+        result.pop_back();
+    }
+    return result;
+}
+
+uintptr_t GetGameAssemblyBase() {
+    if (g_Runtime.game_assembly_base != 0) {
+        return g_Runtime.game_assembly_base;
+    }
+    g_Runtime.game_assembly_base = FindGameAssemblyBaseNow();
+    return g_Runtime.game_assembly_base;
+}
+
+bool WaitForGameAssembly(uint32_t timeout_ms, uint32_t poll_ms) {
+    const ULONGLONG start = GetTickCount64();
+    while (g_Runtime.running.load(std::memory_order_relaxed) || timeout_ms == 0) {
+        const uintptr_t base = FindGameAssemblyBaseNow();
+        if (base != 0) {
+            g_Runtime.game_assembly_base = base;
+            return true;
+        }
+
+        if (timeout_ms != 0) {
+            const ULONGLONG elapsed = GetTickCount64() - start;
+            if (elapsed >= timeout_ms) {
+                break;
+            }
+        }
+        Sleep(poll_ms);
+    }
+    return false;
+}
+
+void ResolveGABypassSlots() {
+    std::scoped_lock lock(g_il2cpp_mutex);
+    g_il2cpp_slots.clear();
+
+    const uintptr_t base = GetGameAssemblyBase();
+    if (base == 0) {
+        Log("IL2CPP Domain Not Found!");
+        return;
+    }
+
+    for (const auto& slot : kIl2cppSlotMap) {
+        g_il2cpp_slots[slot.slot_offset] = reinterpret_cast<void*>(base + slot.gameassembly_offset);
+    }
+    Log("IL2CPP Domain Found: 0x%p", reinterpret_cast<void*>(base));
+}
+
+void* GetIl2cppSlot(uintptr_t slot_offset) {
+    std::scoped_lock lock(g_il2cpp_mutex);
+    const auto it = g_il2cpp_slots.find(slot_offset);
+    if (it == g_il2cpp_slots.end()) {
+        return nullptr;
+    }
+    return it->second;
+}
+
+bool EnsureIl2CppThreadAttached() {
+    if (!g_il2cpp_thread_attach_fn || !g_il2cpp_domain_get_fn) {
+        ResolveIl2CppThreadApisOnce();
+    }
+
+    if (!g_il2cpp_thread_attach_fn || !g_il2cpp_domain_get_fn) {
+        g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
+        return false;
+    }
+
+    void* domain = g_il2cpp_domain_cached;
+    if (!domain) {
+        domain = g_il2cpp_domain_get_fn();
+        g_il2cpp_domain_cached = domain;
+    }
+
+    if (!domain) {
+        g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
+        return false;
+    }
+
+    if (g_il2cpp_thread_current_fn) {
+        void* current = g_il2cpp_thread_current_fn();
+        if (current) {
+            g_tls_il2cpp_thread = current;
+            g_tls_il2cpp_attached_by_us = false;
+            g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed);
+            return true;
+        }
+    } else if (g_tls_il2cpp_thread) {
+        g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed);
+        return true;
+    }
+
+    void* attached = g_il2cpp_thread_attach_fn(domain);
+    if (!attached) {
+        g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
+        return false;
+    }
+
+    g_tls_il2cpp_thread = attached;
+    g_tls_il2cpp_attached_by_us = true;
+    g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed);
+    return true;
+}
+
+bool WaitForIl2CppThreadAttach(uint32_t timeout_ms, uint32_t poll_ms) {
+    const ULONGLONG start = GetTickCount64();
+    for (;;) {
+        if (EnsureIl2CppThreadAttached()) {
+            return true;
+        }
+        if (timeout_ms != 0) {
+            const ULONGLONG elapsed = GetTickCount64() - start;
+            if (elapsed >= timeout_ms) {
+                return false;
+            }
+        }
+        Sleep(poll_ms);
+    }
+}
+
+void DetachIl2CppThreadIfAttached() {
+    if (!g_tls_il2cpp_thread || !g_tls_il2cpp_attached_by_us) {
+        return;
+    }
+
+    if (!g_il2cpp_thread_detach_fn) {
+        ResolveIl2CppThreadApisOnce();
+    }
+    if (g_il2cpp_thread_detach_fn) {
+        g_il2cpp_thread_detach_fn(g_tls_il2cpp_thread);
+    }
+
+    g_tls_il2cpp_thread = nullptr;
+    g_tls_il2cpp_attached_by_us = false;
+    g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed);
+}
+
+void SetGameThreadContext(bool enabled) {
+    g_tls_game_thread_context = enabled;
+    if (enabled) {
+        const DWORD tid = GetCurrentThreadId();
+        DWORD known = g_Runtime.game_thread_id.load(std::memory_order_relaxed);
+        if (known == 0) {
+            g_Runtime.game_thread_id.store(tid, std::memory_order_relaxed);
+        }
+    }
+}
+
+bool IsGameThreadContext() {
+    if (g_tls_game_thread_context) {
+        return true;
+    }
+    const DWORD known = g_Runtime.game_thread_id.load(std::memory_order_relaxed);
+    return known != 0 && known == GetCurrentThreadId();
+}
+
+bool IsWindowsBuildAtLeast(uint32_t build_number) {
+    using RtlGetVersionFn = LONG(WINAPI*)(PRTL_OSVERSIONINFOW);
+
+    static std::atomic<uint32_t> cached_build{0};
+    uint32_t value = cached_build.load(std::memory_order_acquire);
+    if (value == 0) {
+        HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
+        if (!ntdll) {
+            ntdll = LoadLibraryW(L"ntdll.dll");
+        }
+        if (!ntdll) {
+            return false;
+        }
+
+        auto* rtl_get_version = reinterpret_cast<RtlGetVersionFn>(
+            GetProcAddress(ntdll, "RtlGetVersion"));
+        if (!rtl_get_version) {
+            return false;
+        }
+
+        RTL_OSVERSIONINFOW info{};
+        info.dwOSVersionInfoSize = sizeof(info);
+        if (rtl_get_version(&info) == 0) {
+            value = info.dwBuildNumber;
+            cached_build.store(value, std::memory_order_release);
+        }
+    }
+
+    return value >= build_number;
+}
+
+void ToggleConsole(bool enabled) {
+    if (enabled) {
+        if (GetConsoleWindow() == nullptr) {
+            AllocConsole();
+            FILE* stream = nullptr;
+            freopen_s(&stream, "CONOUT$", "w", stdout);
+            freopen_s(&stream, "CONOUT$", "w", stderr);
+            SetConsoleOutputCP(65001);
+            SetConsoleTitleA("il2cpp Game Console");
+        }
+    } else {
+        if (GetConsoleWindow() != nullptr) {
+            ShowWindow(GetConsoleWindow(), SW_HIDE);
+        }
+    }
+}
+
+bool ScanLoadedModulesForInjectionMarkers() {
+    static const std::wstring kMarkerA = L"testyip";
+    static const std::wstring kMarkerB = L"gatmp.tmp";
+    static const std::wstring kMarkerC = L"ef-cheeto.dll";
+
+    HMODULE modules[2048] = {};
+    DWORD needed = 0;
+    if (!K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &needed)) {
+        return false;
+    }
+
+    const size_t count = needed / sizeof(HMODULE);
+    for (size_t i = 0; i < count; ++i) {
+        wchar_t path[MAX_PATH] = {};
+        if (K32GetModuleFileNameExW(GetCurrentProcess(), modules[i], path, MAX_PATH) == 0) {
+            continue;
+        }
+        std::wstring lower = path;
+        std::transform(lower.begin(), lower.end(), lower.begin(), [](wchar_t c) {
+            return static_cast<wchar_t>(::towlower(c));
+        });
+        if (lower.find(kMarkerA) != std::wstring::npos ||
+            lower.find(kMarkerB) != std::wstring::npos ||
+            lower.find(kMarkerC) != std::wstring::npos) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void InitializeI18N() {
+    std::scoped_lock lock(g_i18n_mutex);
+    if (g_i18n_initialized) {
+        return;
+    }
+
+    const nlohmann::json parsed = nlohmann::json::parse(kI18nBlob, nullptr, false);
+    if (!parsed.is_object()) {
+        g_i18n_initialized = true;
+        return;
+    }
+
+    for (auto it = parsed.begin(); it != parsed.end(); ++it) {
+        const std::string key = it.key();
+        const nlohmann::json& item = it.value();
+        if (!item.is_object()) {
+            continue;
+        }
+        g_en[key] = item.value("en", key);
+        g_zh_cn[key] = item.value("zh_cn", key);
+    }
+    g_i18n_initialized = true;
+}
+
+const char* Tr(const char* key) {
+    InitializeI18N();
+
+    std::scoped_lock lock(g_i18n_mutex);
+    const std::string k = key ? key : "";
+    const Language lang = g_Runtime.language.load(std::memory_order_relaxed);
+
+    const auto fallback_it = g_en.find(k);
+    if (lang == Language::ZhCN) {
+        const auto it = g_zh_cn.find(k);
+        if (it != g_zh_cn.end()) {
+            return it->second.c_str();
+        }
+    }
+
+    if (fallback_it != g_en.end()) {
+        return fallback_it->second.c_str();
+    }
+    return key ? key : "";
+}
+
+void SetLanguage(Language language) {
+    g_Runtime.language.store(language, std::memory_order_relaxed);
+}
+
+void ApplyThemeDefault() {
+    ImGui::StyleColorsDark();
+}
+
+void ApplyThemeEvangelionUnit01() {
+    static constexpr std::array<const char*, 11> kColors = {{
+        "FFFFFFFF", "7857A7FF", "19171CFF", "2A282EFF", "2A282EE6", "4DE6A5FF",
+        "00000000", "4A455240", "A38CCF80", "7857A780", "4A4552FF"}};
+    ApplyThemePalette(kColors);
+}
+
+void ApplyThemeEvangelionUnit02() {
+    static constexpr std::array<const char*, 11> kColors = {{
+        "FFFFFFFF", "D9293BFF", "1E1E1EFF", "3A3A3AFF", "3A3A3AE6", "F7B302FF",
+        "00000000", "4A455240", "F7465880", "D9293B80", "4A4552FF"}};
+    ApplyThemePalette(kColors);
+}
+
+void ApplyThemeMatrix() {
+    static constexpr std::array<const char*, 11> kColors = {{
+        "00FF41FF", "00AA2CFF", "000000FF", "0A0A0AFF", "0A0A0AE6", "004400FF",
+        "00000000", "00440040", "00881EFF", "00FF4180", "00FF4180"}};
+    ApplyThemePalette(kColors);
+}
+
+bool IsKeyPressedOnce(int vk) {
+    return (GetAsyncKeyState(vk) & 0x1) != 0;
+}