├── src ├── Utils │ ├── Hooking.cpp │ ├── detours.lib │ ├── Singleton.h │ ├── ProjectGlobals.h │ ├── ResourceLoader.h │ ├── ResourceLoader.cpp │ └── Hooking.h ├── Resources │ ├── Images │ │ ├── Cursor.png │ │ ├── MenuKlee.png │ │ └── MenuLogo.png │ └── Fonts │ │ ├── Kodchasan-Bold.ttf │ │ ├── Kodchasan-Regular.ttf │ │ └── Montserrat-SemiBold.ttf ├── Bypass │ ├── Bypass.cpp │ └── Bypass.h ├── Frameworks │ └── ImGui │ │ ├── freetype.lib │ │ ├── ImGuiInclude.h │ │ ├── ft2build.h │ │ ├── imgui_stdlib.h │ │ ├── freetype │ │ ├── internal │ │ │ ├── services │ │ │ │ ├── svwinfnt.h │ │ │ │ ├── svtteng.h │ │ │ │ ├── svkern.h │ │ │ │ ├── svotval.h │ │ │ │ ├── svttglyf.h │ │ │ │ ├── svfntfmt.h │ │ │ │ ├── svpfr.h │ │ │ │ ├── svpostnm.h │ │ │ │ ├── svprop.h │ │ │ │ ├── svbdf.h │ │ │ │ ├── svgxval.h │ │ │ │ ├── svgldict.h │ │ │ │ ├── svcid.h │ │ │ │ ├── svsfnt.h │ │ │ │ ├── svttcmap.h │ │ │ │ ├── svpsinfo.h │ │ │ │ └── svcfftl.h │ │ │ ├── svginterface.h │ │ │ ├── ftpsprop.h │ │ │ ├── cffotypes.h │ │ │ ├── ftmmtypes.h │ │ │ └── fthash.h │ │ ├── config │ │ │ ├── ftmodule.h │ │ │ ├── mac-support.h │ │ │ └── ftconfig.h │ │ ├── ftfntfmt.h │ │ ├── ftbbox.h │ │ ├── ftlzw.h │ │ ├── ftbzip2.h │ │ └── ftchapters.h │ │ ├── imgui_impl_dx11.h │ │ ├── imgui_impl_dx12.h │ │ ├── imgui_stdlib.cpp │ │ ├── imgui_impl_win32.h │ │ └── imgui_freetype.h ├── Engine │ ├── SDK.h │ ├── SDK_utils.h │ └── SDK.cpp ├── GUI │ ├── Menu │ │ ├── InitGUI.h │ │ ├── Hotkey.h │ │ ├── MainGUI.h │ │ └── Hotkey.cpp │ ├── Images │ │ ├── ImageLoader.h │ │ └── ImageLoader.cpp │ ├── Fonts │ │ ├── FontsLoader.cpp │ │ └── FontsLoader.h │ └── DirectX │ │ └── DirectXHook.h ├── Functions │ ├── Teleports │ │ ├── TeleportBase.cpp │ │ ├── TeleportBase.h │ │ ├── MapTP.h │ │ ├── QuestTP.h │ │ ├── OculiTP.h │ │ ├── ChestTP.h │ │ ├── QuestTP.cpp │ │ ├── ChestTP.cpp │ │ ├── OculiTP.cpp │ │ └── MapTP.cpp │ ├── Visuals │ │ ├── Uncensor.h │ │ ├── HideDamage.h │ │ ├── SkipCutscene.h │ │ ├── InstantBowCharge.h │ │ ├── FpsUnlock.h │ │ ├── OpenTeamImmediately.h │ │ ├── FovChanger.h │ │ ├── ResinCrafter.h │ │ ├── ConstChanger.h │ │ ├── FakeTime.h │ │ ├── ObjectSpawner.h │ │ ├── GraphicsChanger.h │ │ ├── Uncensor.cpp │ │ ├── ResinCrafter.cpp │ │ ├── SkipCutscene.cpp │ │ ├── HideDamage.cpp │ │ ├── FovChanger.cpp │ │ ├── InstantBowCharge.cpp │ │ ├── OpenTeamImmediately.cpp │ │ ├── FakeWeather.h │ │ ├── FpsUnlock.cpp │ │ ├── FlycloakChanger.h │ │ ├── ObjectSpawner.cpp │ │ ├── FakeWeather.cpp │ │ ├── FlycloakChanger.cpp │ │ ├── ConstChanger.cpp │ │ ├── FakeTime.cpp │ │ └── GraphicsChanger.cpp │ ├── Player │ │ ├── Godmode.h │ │ ├── WalkOnWater.h │ │ ├── InfinityUltimate.h │ │ ├── AOEAttack.h │ │ ├── MultiHit.h │ │ ├── NoSkillCd.h │ │ ├── PlayerSpeed.h │ │ ├── InfinityStamina.h │ │ ├── Noclip.h │ │ ├── WalkOnWater.cpp │ │ ├── PlayerSpeed.cpp │ │ ├── InfinityUltimate.cpp │ │ ├── MultiHit.cpp │ │ ├── NoSkillCd.cpp │ │ ├── Godmode.cpp │ │ ├── InfinityStamina.cpp │ │ ├── AOEAttack.cpp │ │ └── Noclip.cpp │ ├── World │ │ ├── DumbEnemies.h │ │ ├── AutoActivateTP.h │ │ ├── Autotalk.h │ │ ├── AutoSeelie.h │ │ ├── AutoLoot.h │ │ ├── AutoDestroy.h │ │ ├── AutoActivateTP.cpp │ │ ├── DumbEnemies.cpp │ │ ├── ESP.h │ │ ├── ESPBase.h │ │ ├── AutoSeelie.cpp │ │ ├── Autotalk.cpp │ │ ├── KillAura.cpp │ │ ├── KillAura.h │ │ └── AutoDestroy.cpp │ ├── Settings │ │ └── Settings.h │ ├── Feature.h │ └── FeatureManager.h ├── Bootstrap │ ├── threads.h │ └── dllmain.cpp └── Config │ └── ConfigManager.cpp ├── Minty-GI.rc ├── resource.h ├── Minty-GI.aps ├── Minty-GI.vcxproj.user ├── Minty-GI.sln └── README.md /src/Utils/Hooking.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Minty-GI.rc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/Minty-GI.rc -------------------------------------------------------------------------------- /resource.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/resource.h -------------------------------------------------------------------------------- /Minty-GI.aps: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/Minty-GI.aps -------------------------------------------------------------------------------- /src/Utils/detours.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Utils/detours.lib -------------------------------------------------------------------------------- /src/Resources/Images/Cursor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Resources/Images/Cursor.png -------------------------------------------------------------------------------- /src/Bypass/Bypass.cpp: -------------------------------------------------------------------------------- 1 | #include "Bypass.h" 2 | 3 | namespace Bypass { 4 | void Init() 5 | { 6 | // ¯\_(ツ)_/¯ 7 | } 8 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Frameworks/ImGui/freetype.lib -------------------------------------------------------------------------------- /src/Resources/Images/MenuKlee.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Resources/Images/MenuKlee.png -------------------------------------------------------------------------------- /src/Resources/Images/MenuLogo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Resources/Images/MenuLogo.png -------------------------------------------------------------------------------- /src/Bypass/Bypass.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace Bypass { 7 | void Init(); 8 | } -------------------------------------------------------------------------------- /src/Resources/Fonts/Kodchasan-Bold.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Resources/Fonts/Kodchasan-Bold.ttf -------------------------------------------------------------------------------- /src/Resources/Fonts/Kodchasan-Regular.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Resources/Fonts/Kodchasan-Regular.ttf -------------------------------------------------------------------------------- /src/Resources/Fonts/Montserrat-SemiBold.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kindawindytoday/Minty-GI/HEAD/src/Resources/Fonts/Montserrat-SemiBold.ttf -------------------------------------------------------------------------------- /src/Engine/SDK.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "SDK_utils.h" 3 | #include "SDK_types.h" 4 | #include "SDK_offsets.h" 5 | #include 6 | #include 7 | -------------------------------------------------------------------------------- /src/Utils/Singleton.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | template 4 | class Singleton { 5 | public: 6 | static T& Instance() { 7 | static T instance; 8 | return instance; 9 | } 10 | }; -------------------------------------------------------------------------------- /src/GUI/Menu/InitGUI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MainGUI.h" 3 | 4 | namespace GUI { 5 | const void Init(HWND window, ID3D11Device* device, ID3D11DeviceContext* context); 6 | const void Render(); 7 | } -------------------------------------------------------------------------------- /src/Utils/ProjectGlobals.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | 4 | class ProjectGlobals : public Singleton { 5 | public: 6 | std::wstring loadingBar = L"[ ]"; 7 | }; -------------------------------------------------------------------------------- /src/Functions/Teleports/TeleportBase.cpp: -------------------------------------------------------------------------------- 1 | #include "TeleportBase.h" 2 | #include "../../GUI/Menu/MainGUI.h" 3 | 4 | void TeleportBase::TeleportTo(Unity::Vector3 pos, uint32_t sceneId) 5 | { 6 | // ¯\_(ツ)_/¯ 7 | } 8 | -------------------------------------------------------------------------------- /src/Bootstrap/threads.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace Threads { 5 | DWORD MainThread(LPVOID reserved); 6 | DWORD BypassThread(LPVOID reserved); 7 | DWORD LoadingBarThread(LPVOID reserved); 8 | } -------------------------------------------------------------------------------- /Minty-GI.vcxproj.user: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | true 5 | 6 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/ImGuiInclude.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // File to include all ImGui files at once 3 | #include "imgui_internal.h" 4 | #include "imconfig.h" 5 | #include "imgui.h" 6 | #include "imgui_impl_dx11.h" 7 | #include "imgui_impl_dx12.h" 8 | #include "imgui_impl_win32.h" 9 | #include "imgui_stdlib.h" 10 | #include "imstb_textedit.h" -------------------------------------------------------------------------------- /src/Functions/Teleports/TeleportBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | class TeleportBase 10 | { 11 | public: 12 | static void TeleportTo(Unity::Vector3 pos, uint32_t sceneId = 0); 13 | }; -------------------------------------------------------------------------------- /src/Utils/ResourceLoader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Singleton.h" 4 | #include 5 | #include 6 | 7 | class ResourceLoader : public Singleton { 8 | public: 9 | bool LoadResourceToMemory(const char* resourceName, const char* resourceType, void*& dataOut, DWORD& sizeOut); 10 | void SetHandle(HMODULE handle); 11 | private: 12 | HMODULE handle; 13 | }; -------------------------------------------------------------------------------- /src/Functions/Visuals/Uncensor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class Uncensor : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | Uncensor(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/GUI/Images/ImageLoader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Utils/ResourceLoader.h" 4 | #include "../../Utils/Singleton.h" 5 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 6 | #include "../DirectX/DirectXHook.h" 7 | #include 8 | 9 | struct Image { 10 | void* data = 0; 11 | DWORD dataSize = 0; 12 | void* srv = 0; 13 | int width = 0, height = 0; 14 | }; 15 | 16 | class ImageLoader : public Singleton { 17 | public: 18 | bool LoadImageFromResources(int resourceNum); 19 | std::map ImagesMap; 20 | }; -------------------------------------------------------------------------------- /src/Functions/Player/Godmode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../FeatureManager.h" 7 | 8 | namespace Player { 9 | class Invincibility : public Feature, public Singleton { 10 | public: 11 | void Options(); 12 | void Status(); 13 | void OnUpdate(); 14 | void ProcessHotkeys(); 15 | 16 | void InitConfig(); 17 | void InitHooks(); 18 | void DetachHooks(); 19 | 20 | Invincibility(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/Player/WalkOnWater.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class WalkOnWater : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | WalkOnWater(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/HideDamage.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class HideDamage : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | HideDamage(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/World/DumbEnemies.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class DumbEnemies : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | DumbEnemies(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/SkipCutscene.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class SkipCutscene : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | SkipCutscene(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/World/AutoActivateTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class AutoActivateTP : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | AutoActivateTP(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/Player/InfinityUltimate.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class InfinityUltimate : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | InfinityUltimate(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/World/Autotalk.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class Autotalk : public Feature, public Singleton { 11 | public: 12 | bool b_AutoChoose; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | Autotalk(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/InstantBowCharge.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class InstantBowCharge : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | InstantBowCharge(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/Player/AOEAttack.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../FeatureManager.h" 7 | 8 | namespace Player { 9 | class AOEAttack : public Feature, public Singleton { 10 | public: 11 | ConfigField f_Range; 12 | 13 | void Options(); 14 | void Status(); 15 | void OnUpdate(); 16 | void ProcessHotkeys(); 17 | 18 | void InitConfig(); 19 | void InitHooks(); 20 | void DetachHooks(); 21 | 22 | AOEAttack(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/FpsUnlock.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class FpsUnlock : public Feature, public Singleton { 11 | public: 12 | ConfigField i_Limit; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | FpsUnlock(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/OpenTeamImmediately.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class OpenTeamImmediately : public Feature, public Singleton { 11 | public: 12 | void Options(); 13 | void Status(); 14 | void OnUpdate(); 15 | void ProcessHotkeys(); 16 | 17 | void InitConfig(); 18 | void InitHooks(); 19 | 20 | OpenTeamImmediately(); 21 | }; 22 | } -------------------------------------------------------------------------------- /src/Functions/Player/MultiHit.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class HitMultiplier : public Feature, public Singleton { 11 | public: 12 | ConfigField i_Hits; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | HitMultiplier(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Player/NoSkillCd.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class NoSkillCd : public Feature, public Singleton { 11 | public: 12 | ConfigField b_NoSprintCd; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | NoSkillCd(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Player/PlayerSpeed.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class PlayerSpeed : public Feature, public Singleton { 11 | public: 12 | ConfigField f_Speed; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | PlayerSpeed(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/FovChanger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class FovChanger : public Feature, public Singleton { 11 | public: 12 | ConfigField f_Fov; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | FovChanger(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/World/AutoSeelie.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class AutoSeelie : public Feature, public Singleton { 11 | public: 12 | ConfigField b_SpeedupSeelies; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | AutoSeelie(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/ResinCrafter.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class ResinCrafter : public Feature, public Singleton { 11 | public: 12 | ConfigField i_ResinPieces; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | ResinCrafter(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Teleports/MapTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | #include "TeleportBase.h" 9 | #include 10 | 11 | namespace Teleports { 12 | class MapTP : public Feature, public Singleton { 13 | public: 14 | Hotkey h_TP; 15 | 16 | void Options(); 17 | void Status(); 18 | void OnUpdate(); 19 | void ProcessHotkeys(); 20 | 21 | void InitConfig(); 22 | void InitHooks(); 23 | 24 | MapTP(); 25 | }; 26 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/ConstChanger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class ConstChanger : public Feature, public Singleton { 11 | public: 12 | ConfigField i_ConstellationLevel; 13 | 14 | void Options(); 15 | void Status(); 16 | void OnUpdate(); 17 | void ProcessHotkeys(); 18 | 19 | void InitConfig(); 20 | void InitHooks(); 21 | 22 | ConstChanger(); 23 | }; 24 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/FakeTime.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class FakeTime : public Feature, public Singleton { 11 | public: 12 | ConfigField i_Hours; 13 | ConfigField i_Minutes; 14 | 15 | void Options(); 16 | void Status(); 17 | void OnUpdate(); 18 | void ProcessHotkeys(); 19 | 20 | void InitConfig(); 21 | void InitHooks(); 22 | 23 | FakeTime(); 24 | }; 25 | } -------------------------------------------------------------------------------- /src/Bootstrap/dllmain.cpp: -------------------------------------------------------------------------------- 1 | #include "threads.h" 2 | 3 | BOOL APIENTRY DllMain( HMODULE hModule, 4 | DWORD ul_reason_for_call, 5 | LPVOID lpReserved 6 | ) 7 | { 8 | switch (ul_reason_for_call) 9 | { 10 | case DLL_PROCESS_ATTACH: 11 | CreateThread(0, 0, Threads::BypassThread, 0, 0, 0); 12 | CreateThread(0, 0, Threads::MainThread, hModule, 0, 0); 13 | break; 14 | case DLL_THREAD_ATTACH: 15 | case DLL_THREAD_DETACH: 16 | case DLL_PROCESS_DETACH: 17 | break; 18 | } 19 | return TRUE; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /src/Functions/World/AutoLoot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class AutoLoot : public Feature, public Singleton { 11 | public: 12 | ConfigField b_AutoChests; 13 | 14 | ConfigField f_LootRange; 15 | 16 | void Options(); 17 | void Status(); 18 | void OnUpdate(); 19 | void ProcessHotkeys(); 20 | 21 | void InitConfig(); 22 | void InitHooks(); 23 | 24 | AutoLoot(); 25 | }; 26 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/ObjectSpawner.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class ObjectSpawner : public Feature, public Singleton { 11 | public: 12 | Hotkey h_Alchemist; 13 | Hotkey h_Forging; 14 | Hotkey h_Katheryne; 15 | 16 | void Options(); 17 | void Status(); 18 | void OnUpdate(); 19 | void ProcessHotkeys(); 20 | 21 | void InitConfig(); 22 | void InitHooks(); 23 | 24 | ObjectSpawner(); 25 | }; 26 | } -------------------------------------------------------------------------------- /src/Functions/Settings/Settings.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../FeatureManager.h" 7 | 8 | namespace Settings { 9 | class Configs : public Feature, public Singleton { 10 | public: 11 | ConfigField b_ShowFps; 12 | ConfigField b_ShowStatus; 13 | ConfigField b_TpScreen; 14 | Hotkey h_OpenMenu; 15 | 16 | void Options(); 17 | void Status(); 18 | void OnUpdate(); 19 | void ProcessHotkeys(); 20 | 21 | void InitConfig(); 22 | void InitHooks(); 23 | 24 | Configs(); 25 | }; 26 | } -------------------------------------------------------------------------------- /src/Functions/Teleports/QuestTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | #include "TeleportBase.h" 9 | #include 10 | 11 | namespace Teleports { 12 | class QuestTP : public Feature, public Singleton { 13 | public: 14 | Hotkey h_TP; 15 | 16 | void* targetMark; 17 | 18 | void Options(); 19 | void Status(); 20 | void OnUpdate(); 21 | void ProcessHotkeys(); 22 | 23 | void InitConfig(); 24 | void InitHooks(); 25 | 26 | QuestTP(); 27 | }; 28 | } -------------------------------------------------------------------------------- /src/Functions/World/AutoDestroy.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class AutoDestroy : public Feature, public Singleton { 11 | public: 12 | ConfigField b_Ores; 13 | ConfigField b_Props; 14 | ConfigField b_Shields; 15 | 16 | ConfigField f_Range; 17 | 18 | void Options(); 19 | void Status(); 20 | void OnUpdate(); 21 | void ProcessHotkeys(); 22 | 23 | void InitConfig(); 24 | void InitHooks(); 25 | 26 | AutoDestroy(); 27 | }; 28 | } -------------------------------------------------------------------------------- /src/GUI/Menu/Hotkey.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Config/ConfigManager.h" 6 | 7 | class Hotkey { 8 | public: 9 | ConfigField key; 10 | 11 | bool IsDown(); 12 | bool IsPressed(); 13 | 14 | void Draw(std::string text = ""); 15 | 16 | Hotkey() {} 17 | 18 | Hotkey(std::string _path, std::string _name) { 19 | key = Config::GetValue(_path, _name, ImGuiKey_None); 20 | } 21 | 22 | Hotkey(std::string _path, std::string _name, ImGuiKey _key) { 23 | key = Config::GetValue(_path, _name, _key); 24 | } 25 | 26 | private: 27 | void UpdateKey(); 28 | std::string GetDrawText(); 29 | bool IsUpdating = false; 30 | }; -------------------------------------------------------------------------------- /src/GUI/Menu/MainGUI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 4 | #include "../../Frameworks/ImGui/ImGuiNotify.hpp" 5 | #include "../../Utils/Singleton.h" 6 | #include "../../Functions/FeatureManager.h" 7 | #include "../Images/ImageLoader.h" 8 | #include "../Fonts/FontsLoader.h" 9 | #include 10 | #include 11 | 12 | class Menu : public Singleton { 13 | public: 14 | bool b_Opened = true; 15 | 16 | bool b_Teleporting = false; 17 | float f_TeleportingAlpha = 0.f; 18 | 19 | const void DrawFrame(); 20 | const void DrawStatus(); 21 | const void DrawFPS(); 22 | void DrawTeleportingScreen(); 23 | 24 | const void ExecuteHotkeys(); 25 | const void ExecuteOuter(); 26 | }; -------------------------------------------------------------------------------- /src/Functions/Player/InfinityStamina.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class InfinityStamina : public Feature, public Singleton { 11 | public: 12 | ConfigField b_NightSoul; 13 | ConfigField b_Wanderer; 14 | ConfigField b_Mavuika; 15 | ConfigField b_Yelan; 16 | ConfigField b_Sayu; 17 | 18 | void Options(); 19 | void Status(); 20 | void OnUpdate(); 21 | void ProcessHotkeys(); 22 | 23 | void InitConfig(); 24 | void InitHooks(); 25 | 26 | InfinityStamina(); 27 | }; 28 | } -------------------------------------------------------------------------------- /src/GUI/Fonts/FontsLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "FontsLoader.h" 2 | #include 3 | 4 | bool FontsLoader::LoadFont(int resourceNum, float fontSize, ImFontConfig* fontConfig, int fontId, const ImWchar* fontRanges) 5 | { 6 | void* fontData = 0; 7 | DWORD fontDataSize = 0; 8 | 9 | if (!ResourceLoader::Instance().LoadResourceToMemory(MAKEINTRESOURCEA(resourceNum), MAKEINTRESOURCEA(10), fontData, fontDataSize)) { 10 | printf("LOAD FONT ERROR! FONT #%i (%i)\n", resourceNum, GetLastError()); 11 | return false; 12 | } 13 | //printf("Adding...\n"); 14 | auto font = ImGui::GetIO().Fonts->AddFontFromMemoryTTF(fontData, fontDataSize, fontSize, fontConfig, fontRanges); 15 | 16 | this->FontsMap[fontId] = font; 17 | 18 | return true; 19 | } 20 | -------------------------------------------------------------------------------- /src/Functions/Player/Noclip.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Player { 10 | class Noclip : public Feature, public Singleton { 11 | public: 12 | ConfigField f_Speed; 13 | 14 | ConfigField b_UseAltSpeed; 15 | ConfigField f_AltSpeed; 16 | 17 | void* cachedMgr = 0; 18 | void* cachedAvatar = 0; 19 | void* cachedCamera = 0; 20 | void* cachedRelativeTransform = 0; 21 | 22 | void Options(); 23 | void Status(); 24 | void OnUpdate(); 25 | void ProcessHotkeys(); 26 | 27 | void InitConfig(); 28 | void InitHooks(); 29 | 30 | Noclip(); 31 | }; 32 | } -------------------------------------------------------------------------------- /src/GUI/Images/ImageLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "ImageLoader.h" 2 | 3 | bool ImageLoader::LoadImageFromResources(int resourceNum) 4 | { 5 | Image image; 6 | 7 | image.srv = 0; 8 | image.dataSize = 0; 9 | image.data = 0; 10 | image.width = 0; 11 | image.height = 0; 12 | 13 | if (!ResourceLoader::Instance().LoadResourceToMemory(MAKEINTRESOURCEA(resourceNum), "PNG", image.data, image.dataSize)) { 14 | printf("LoadResourceToMemory ERR! Image #%i\n", resourceNum); 15 | return false; 16 | } 17 | 18 | if (!DxHook::LoadTextureFromMemory(image.data, image.dataSize, &image.srv, &image.width, &image.height)) { 19 | printf("LoadTextureFromMemory ERR! (image #%i)\n", resourceNum); 20 | return false; 21 | } 22 | 23 | this->ImagesMap[resourceNum] = image; 24 | 25 | return true; 26 | } 27 | -------------------------------------------------------------------------------- /src/Utils/ResourceLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "ResourceLoader.h" 2 | 3 | bool ResourceLoader::LoadResourceToMemory(const char* resourceName, const char* resourceType, void*& dataOut, DWORD& sizeOut) 4 | { 5 | if (!this->handle) return false; 6 | HRSRC resource = FindResourceA(this->handle, resourceName, resourceType); 7 | //printf("1: %i\n", GetLastError()); 8 | if (!resource) return false; 9 | HGLOBAL hglobal = LoadResource(this->handle, resource); 10 | //printf("2: %i\n", GetLastError()); 11 | if (!hglobal) return false; 12 | dataOut = LockResource(hglobal); 13 | sizeOut = SizeofResource(this->handle, resource); 14 | if (dataOut && (sizeOut > 0)) return true; 15 | return false; 16 | } 17 | 18 | void ResourceLoader::SetHandle(HMODULE handle) 19 | { 20 | this->handle = handle; 21 | } 22 | -------------------------------------------------------------------------------- /src/Functions/World/AutoActivateTP.cpp: -------------------------------------------------------------------------------- 1 | #include "AutoActivateTP.h" 2 | 3 | namespace World { 4 | void hook_LCScenePoint_Tick(void* this_, float tick); 5 | 6 | void AutoActivateTP::InitConfig() {} 7 | 8 | void AutoActivateTP::InitHooks() 9 | { 10 | Hooks::Attach(Offsets::LCScenePoint::Tick, hook_LCScenePoint_Tick); 11 | } 12 | 13 | AutoActivateTP::AutoActivateTP() : Feature( 14 | "Auto Activate TP", 15 | "Automatically unlocks TP points near you") 16 | { 17 | InitConfig(); 18 | InitHooks(); 19 | } 20 | 21 | void AutoActivateTP::Options() {} 22 | 23 | void AutoActivateTP::Status() {} 24 | 25 | void AutoActivateTP::OnUpdate() {} 26 | 27 | void AutoActivateTP::ProcessHotkeys() {} 28 | 29 | void hook_LCScenePoint_Tick(void* this_, float tick) 30 | { 31 | // ¯\_(ツ)_/¯ 32 | } 33 | } -------------------------------------------------------------------------------- /src/GUI/Fonts/FontsLoader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Utils/ResourceLoader.h" 4 | #include "../../Utils/Singleton.h" 5 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 6 | #include 7 | #include 8 | 9 | namespace { 10 | namespace Fonts { 11 | namespace Kodchasan { 12 | namespace Regular { 13 | constexpr int a16 = 16; 14 | constexpr int a20 = 20; 15 | constexpr int a24 = 24; 16 | } 17 | namespace Bold { 18 | constexpr int a16 = 116; 19 | constexpr int a20 = 120; 20 | constexpr int a24 = 124; 21 | } 22 | } 23 | } 24 | } 25 | 26 | class FontsLoader : public Singleton { 27 | public: 28 | bool LoadFont(int resourceNum, float fontSize, ImFontConfig* fontConfig, int fontId, const ImWchar* fontRanges); 29 | std::map FontsMap; 30 | }; -------------------------------------------------------------------------------- /src/Functions/Feature.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../GUI/Menu/Hotkey.h" 4 | #include "../Config/ConfigManager.h" 5 | 6 | class Feature 7 | { 8 | public: 9 | std::string m_Name; 10 | std::string m_Description; 11 | 12 | Hotkey h_Enable; 13 | 14 | ConfigField m_Enabled; 15 | 16 | virtual void Options() {}; 17 | virtual void Status() {}; 18 | virtual void OnUpdate() {}; 19 | virtual void ProcessHotkeys() {}; 20 | 21 | virtual void InitConfig() {}; 22 | virtual void InitHooks() {}; 23 | 24 | Feature(const char* name, const char* description) 25 | { 26 | m_Name = std::string(name); 27 | m_Description = std::string(description); 28 | 29 | m_Enabled = Config::GetValue(name, ("enabled"), false); 30 | h_Enable = Hotkey(name, ("enable")); 31 | } 32 | }; -------------------------------------------------------------------------------- /src/Functions/Visuals/GraphicsChanger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class GraphicsChanger : public Feature, public Singleton { 11 | public: 12 | ConfigField b_Gamma; 13 | ConfigField f_GammaValue; 14 | 15 | ConfigField b_Outline; 16 | ConfigField f_OutlineValue; 17 | 18 | ConfigField b_ResolutionScale; 19 | ConfigField f_ResolutionScaleValue; 20 | 21 | void Options(); 22 | void Status(); 23 | void OnUpdate(); 24 | void ProcessHotkeys(); 25 | 26 | void InitConfig(); 27 | void InitHooks(); 28 | 29 | GraphicsChanger(); 30 | }; 31 | } -------------------------------------------------------------------------------- /src/Functions/FeatureManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Feature.h" 3 | #include "../Utils/Singleton.h" 4 | #include 5 | 6 | class Module 7 | { 8 | public: 9 | std::string GetName() { return m_Name; }; 10 | std::vector GetFeatures() { return m_Features; }; 11 | 12 | Module(std::string name, std::vector features) : m_Name(name), m_Features(features) {}; 13 | Module(std::string name, Feature* feature) : m_Name(name) { m_Features.push_back(feature); }; 14 | 15 | private: 16 | std::string m_Name; 17 | std::vector m_Features; 18 | }; 19 | 20 | class FeatureManager : public Singleton { 21 | public: 22 | std::vector GetModules() { return m_Modules; }; 23 | void AddModule(Module module) { m_Modules.push_back(module); }; 24 | 25 | private: 26 | std::vector m_Modules; 27 | }; -------------------------------------------------------------------------------- /src/Functions/World/DumbEnemies.cpp: -------------------------------------------------------------------------------- 1 | #include "DumbEnemies.h" 2 | 3 | namespace World { 4 | void hook_TryDoSkill(void* this_, uint32_t skillId); 5 | 6 | void DumbEnemies::InitConfig() { 7 | } 8 | 9 | void DumbEnemies::InitHooks() { 10 | Hooks::Attach(Offsets::VCMonsterAIController::TryDoSkill, hook_TryDoSkill); 11 | } 12 | 13 | DumbEnemies::DumbEnemies() : Feature( 14 | "Dumb Enemies", 15 | "Enemies won't attack you") 16 | { 17 | InitConfig(); 18 | InitHooks(); 19 | } 20 | 21 | void DumbEnemies::Options() {} 22 | 23 | void DumbEnemies::Status() {} 24 | 25 | void DumbEnemies::OnUpdate() {} 26 | 27 | void DumbEnemies::ProcessHotkeys() {} 28 | 29 | void hook_TryDoSkill(void* this_, uint32_t skillId) { 30 | auto& instance = DumbEnemies::Instance(); 31 | if (instance.m_Enabled) 32 | return; 33 | 34 | Hooks::Call(hook_TryDoSkill, this_, skillId); 35 | } 36 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/Uncensor.cpp: -------------------------------------------------------------------------------- 1 | #include "Uncensor.h" 2 | 3 | namespace Visuals { 4 | void hook_UnknownPeeking(void* this_, void* a1, void* a2, void* a3); 5 | 6 | void Uncensor::InitConfig() {} 7 | 8 | void Uncensor::InitHooks() { 9 | Hooks::Attach(Offsets::Unknown::UnknownPeeking, hook_UnknownPeeking); 10 | } 11 | 12 | Uncensor::Uncensor() : Feature( 13 | "Remove censorship", 14 | "Removes camera censorship at certain angles") 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void Uncensor::Options() {} 21 | 22 | void Uncensor::Status() {} 23 | 24 | void Uncensor::OnUpdate() {} 25 | 26 | void Uncensor::ProcessHotkeys() {} 27 | 28 | void hook_UnknownPeeking(void* this_, void* a1, void* a2, void* a3) { 29 | auto& instance = Uncensor::Instance(); 30 | if (instance.m_Enabled) return; 31 | 32 | Hooks::Call(hook_UnknownPeeking, this_, a1, a2, a3); 33 | } 34 | } -------------------------------------------------------------------------------- /src/Functions/Player/WalkOnWater.cpp: -------------------------------------------------------------------------------- 1 | #include "WalkOnWater.h" 2 | 3 | namespace Player { 4 | bool hook_VCBaseMove_CanWalkOnWater(void* this_); 5 | 6 | void WalkOnWater::InitConfig() {} 7 | 8 | void WalkOnWater::InitHooks() { 9 | Hooks::Attach(Offsets::VCBaseMove::CanWalkOnWater, hook_VCBaseMove_CanWalkOnWater); 10 | } 11 | 12 | WalkOnWater::WalkOnWater() : Feature( 13 | ("Walk on water"), 14 | ("Lets you walk on the water")) 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void WalkOnWater::Options() {} 21 | 22 | void WalkOnWater::Status() {} 23 | 24 | void WalkOnWater::OnUpdate() {} 25 | 26 | void WalkOnWater::ProcessHotkeys() {} 27 | 28 | bool hook_VCBaseMove_CanWalkOnWater(void* this_) { 29 | auto& instance = WalkOnWater::Instance(); 30 | if (instance.m_Enabled) 31 | return true; 32 | 33 | return Hooks::Call(hook_VCBaseMove_CanWalkOnWater, this_); 34 | } 35 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/ResinCrafter.cpp: -------------------------------------------------------------------------------- 1 | #include "ResinCrafter.h" 2 | 3 | namespace Visuals { 4 | void RequestCraftResin(int count); 5 | 6 | void ResinCrafter::InitConfig() { 7 | i_ResinPieces = Config::GetValue(this->m_Name, "resin", 5); 8 | } 9 | 10 | void ResinCrafter::InitHooks() {} 11 | 12 | ResinCrafter::ResinCrafter() : Feature( 13 | "Resin crafter", 14 | "Remotely crafts X pcs. of 'Condensed Resin'.\nNote: you must have enough resources") 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void ResinCrafter::Options() { 21 | ConfigSliderInt("Resin pieces", i_ResinPieces, 1, 5); 22 | if (ImGui::Button("Craft")) { 23 | RequestCraftResin(i_ResinPieces); 24 | } 25 | } 26 | 27 | void ResinCrafter::Status() {} 28 | 29 | void ResinCrafter::OnUpdate() {} 30 | 31 | void ResinCrafter::ProcessHotkeys() {} 32 | 33 | void RequestCraftResin(int count) { 34 | // ¯\_(ツ)_/¯ 35 | } 36 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/SkipCutscene.cpp: -------------------------------------------------------------------------------- 1 | #include "SkipCutscene.h" 2 | 3 | namespace Visuals { 4 | void hook_CriwareMediaPlayer_Update(void* this_); 5 | 6 | void SkipCutscene::InitConfig() {} 7 | 8 | void SkipCutscene::InitHooks() { 9 | //Hooks::Attach(Offsets::CriwareMediaPlayer::Update, hook_CriwareMediaPlayer_Update); 10 | } 11 | 12 | SkipCutscene::SkipCutscene() : Feature( 13 | "Skip cutscenes", 14 | "Automatically skips cutscenes") 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void SkipCutscene::Options() {} 21 | 22 | void SkipCutscene::Status() {} 23 | 24 | void SkipCutscene::OnUpdate() {} 25 | 26 | void SkipCutscene::ProcessHotkeys() {} 27 | 28 | void hook_CriwareMediaPlayer_Update(void* this_) { 29 | auto& instance = SkipCutscene::Instance(); 30 | //if (instance.m_Enabled) Offsets::CriwareMediaPlayer::Skip(this_); 31 | 32 | Hooks::Call(hook_CriwareMediaPlayer_Update, this_); 33 | } 34 | } -------------------------------------------------------------------------------- /src/Functions/Teleports/OculiTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | #include "TeleportBase.h" 9 | #include 10 | 11 | namespace Teleports { 12 | class OculiTP : public Feature, public Singleton { 13 | public: 14 | Hotkey h_TP; 15 | 16 | MoleMole::BaseEntity* ClosestEntity; 17 | int Distance; 18 | 19 | MoleMole::BaseEntity* cachedAvatar = 0; 20 | Unity::Camera* cachedCamera = 0; 21 | 22 | std::vector cachedEntities; 23 | std::map chestMap; 24 | size_t cachedSize = 0; 25 | #define DIRTY_CACHE() cachedEntities.clear() 26 | 27 | void Options(); 28 | void Status(); 29 | void OnUpdate(); 30 | void ProcessHotkeys(); 31 | 32 | void InitConfig(); 33 | void InitHooks(); 34 | 35 | OculiTP(); 36 | }; 37 | } -------------------------------------------------------------------------------- /src/Functions/Player/PlayerSpeed.cpp: -------------------------------------------------------------------------------- 1 | #include "PlayerSpeed.h" 2 | 3 | namespace Player { 4 | void OnUpdate_PlayerSpeed(); 5 | 6 | void PlayerSpeed::InitConfig() { 7 | f_Speed = Config::GetValue(this->m_Name, ("speed"), 1.5f); 8 | } 9 | 10 | void PlayerSpeed::InitHooks() {} 11 | 12 | PlayerSpeed::PlayerSpeed() : Feature( 13 | ("Player speed"), 14 | ("Speeds up player animations")) 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void PlayerSpeed::Options() { 21 | ConfigSliderFloat(("Speed"), f_Speed, 0.1f, 2.f); 22 | } 23 | 24 | void PlayerSpeed::Status() {} 25 | 26 | void PlayerSpeed::OnUpdate() {} 27 | 28 | void PlayerSpeed::ProcessHotkeys() {} 29 | 30 | void OnUpdate_PlayerSpeed() { 31 | if (!MoleMole::LoadingManager::get_LoadingManager()->IsLoaded()) return; 32 | 33 | auto& instance = PlayerSpeed::Instance(); 34 | 35 | Offsets::Animator::set_Speed(MoleMole::EntityManager::get_EntityManager()->avatar()->animator(), instance.m_Enabled ? instance.f_Speed : 1.00f); 36 | } 37 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/HideDamage.cpp: -------------------------------------------------------------------------------- 1 | #include "HideDamage.h" 2 | 3 | namespace Visuals { 4 | void hook_MonoParticleDamageTextContainer_ShowDamegeText(void* this_, void* a1, void* a2); 5 | 6 | void HideDamage::InitConfig() {} 7 | 8 | void HideDamage::InitHooks() { 9 | Hooks::Attach(Offsets::MonoParticleDamageTextContainer::ShowDamegeText, hook_MonoParticleDamageTextContainer_ShowDamegeText); 10 | } 11 | 12 | HideDamage::HideDamage() : Feature( 13 | "Hide damage text", 14 | "Hides damage text") 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void HideDamage::Options() {} 21 | 22 | void HideDamage::Status() {} 23 | 24 | void HideDamage::OnUpdate() {} 25 | 26 | void HideDamage::ProcessHotkeys() {} 27 | 28 | void hook_MonoParticleDamageTextContainer_ShowDamegeText(void* this_, void* a1, void* a2) { 29 | auto& instance = HideDamage::Instance(); 30 | if (instance.m_Enabled) 31 | return; 32 | Hooks::Call(hook_MonoParticleDamageTextContainer_ShowDamegeText, this_, a1, a2); 33 | } 34 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/FovChanger.cpp: -------------------------------------------------------------------------------- 1 | #include "FovChanger.h" 2 | 3 | namespace Visuals { 4 | void hook_set_fieldOfView(Unity::Camera* this_, float value); 5 | 6 | void FovChanger::InitConfig() { 7 | f_Fov = Config::GetValue(this->m_Name, "fov", 75.f); 8 | } 9 | 10 | void FovChanger::InitHooks() { 11 | Hooks::Attach(Offsets::Camera::set_fieldOfView, hook_set_fieldOfView); 12 | } 13 | 14 | FovChanger::FovChanger() : Feature( 15 | "FOV changer", 16 | "Changes camera field of view") 17 | { 18 | InitConfig(); 19 | InitHooks(); 20 | } 21 | 22 | void FovChanger::Options() { 23 | ConfigSliderFloat("Target FOV", f_Fov, 10, 150); 24 | } 25 | 26 | void FovChanger::Status() {} 27 | 28 | void FovChanger::OnUpdate() {} 29 | 30 | void FovChanger::ProcessHotkeys() {} 31 | 32 | void hook_set_fieldOfView(Unity::Camera* this_, float value) { 33 | auto& instance = FovChanger::Instance(); 34 | 35 | if (instance.m_Enabled) 36 | value = instance.f_Fov; 37 | 38 | Hooks::Call(hook_set_fieldOfView, this_, value); 39 | } 40 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/InstantBowCharge.cpp: -------------------------------------------------------------------------------- 1 | #include "InstantBowCharge.h" 2 | 3 | namespace Visuals { 4 | bool hook_SetDynamicFloat(void* this_, Unity::String* a1, float a2, bool a3); 5 | 6 | void InstantBowCharge::InitConfig() {} 7 | 8 | void InstantBowCharge::InitHooks() { 9 | Hooks::Attach(Offsets::ActorAbilityPlugin::SetDynamicFloat, hook_SetDynamicFloat); 10 | } 11 | 12 | InstantBowCharge::InstantBowCharge() : Feature( 13 | "Instant bow charge", 14 | "Fully charges bow instantly") 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void InstantBowCharge::Options() {} 21 | 22 | void InstantBowCharge::Status() {} 23 | 24 | void InstantBowCharge::OnUpdate() {} 25 | 26 | void InstantBowCharge::ProcessHotkeys() {} 27 | 28 | bool hook_SetDynamicFloat(void* this_, Unity::String* a1, float a2, bool a3) { 29 | auto& instance = InstantBowCharge::Instance(); 30 | 31 | if (instance.m_Enabled && (a1->ToCString().find("Enchanted_Time") != std::string::npos)) { 32 | a2 = 10.00f; 33 | } 34 | 35 | return Hooks::Call(hook_SetDynamicFloat, this_, a1, a2, a3); 36 | } 37 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/OpenTeamImmediately.cpp: -------------------------------------------------------------------------------- 1 | #include "OpenTeamImmediately.h" 2 | 3 | namespace Visuals { 4 | void InLevelPageContext_UpdateView(void* this_); 5 | 6 | void OpenTeamImmediately::InitConfig() { 7 | 8 | } 9 | 10 | void OpenTeamImmediately::InitHooks() 11 | { 12 | Hooks::Attach(Offsets::InLevelPageContext::UpdateView, InLevelPageContext_UpdateView); 13 | } 14 | 15 | OpenTeamImmediately::OpenTeamImmediately() : Feature( 16 | "Open team immediately", 17 | "Allows you to open team setup immediately") 18 | { 19 | InitConfig(); 20 | InitHooks(); 21 | } 22 | 23 | void OpenTeamImmediately::Options() {} 24 | 25 | void OpenTeamImmediately::Status() {} 26 | 27 | void OpenTeamImmediately::OnUpdate() {} 28 | 29 | void OpenTeamImmediately::ProcessHotkeys() {} 30 | 31 | void InLevelPageContext_UpdateView(void* this_) 32 | { 33 | auto& instance = OpenTeamImmediately::Instance(); 34 | 35 | if (instance.m_Enabled) 36 | { 37 | *reinterpret_cast((uintptr_t)this_ + 0x0) = 2.f; 38 | } 39 | 40 | Hooks::Call(InLevelPageContext_UpdateView, this_); 41 | } 42 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/ft2build.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ft2build.h 4 | * 5 | * FreeType 2 build and setup macros. 6 | * 7 | * Copyright (C) 1996-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | /************************************************************************** 20 | * 21 | * This is the 'entry point' for FreeType header file inclusions, to be 22 | * loaded before all other header files. 23 | * 24 | * A typical example is 25 | * 26 | * ``` 27 | * #include 28 | * #include 29 | * ``` 30 | * 31 | */ 32 | 33 | 34 | #ifndef FT2BUILD_H_ 35 | #define FT2BUILD_H_ 36 | 37 | #include 38 | 39 | #endif /* FT2BUILD_H_ */ 40 | 41 | 42 | /* END */ 43 | -------------------------------------------------------------------------------- /src/Functions/Visuals/FakeWeather.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | #include 9 | 10 | static std::map weatherMap = { 11 | {"Clear", "Data/Environment/Weather/BigWorld/Weather_ClearSky"}, 12 | {"Cloudy", "Data/Environment/Weather/BigWorld/Weather_Cloudy"}, 13 | {"Foggy", "Data/Environment/Weather/BigWorld/Weather_Foggy"}, 14 | {"Storm", "Data/Environment/Weather/BigWorld/Weather_Storm"}, 15 | {"Rain", "Data/Environment/Weather/BigWorld/Weather_Dq_Tabeisha_Rain_Heavy"}, 16 | {"Snow", "Data/Environment/Weather/BigWorld/Weather_Snowmountain_Snow_Light"}, 17 | {"East Coast", "Data/Environment/Weather/BigWorld/Weather_Snowmountain_EastCoast"}, 18 | }; 19 | 20 | namespace Visuals { 21 | class FakeWeather : public Feature, public Singleton { 22 | public: 23 | ConfigField s_Weather; 24 | 25 | void Options(); 26 | void Status(); 27 | void OnUpdate(); 28 | void ProcessHotkeys(); 29 | 30 | void InitConfig(); 31 | void InitHooks(); 32 | 33 | FakeWeather(); 34 | }; 35 | } -------------------------------------------------------------------------------- /src/Engine/SDK_utils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "../Utils/Singleton.h" 5 | #include 6 | #include 7 | 8 | #pragma warning( disable : 4789 ) 9 | 10 | inline static uintptr_t BaseAddress = 0; 11 | 12 | template 13 | class Function 14 | { 15 | public: 16 | uintptr_t OS_offset; 17 | uintptr_t CN_offset; 18 | 19 | TReturn(*Functor)(Args...) = nullptr; 20 | 21 | void Setup() 22 | { 23 | while (BaseAddress == 0) { 24 | BaseAddress = (uintptr_t)GetModuleHandleA(0); 25 | } 26 | 27 | // This should have a game build check which would decide offset to use: OS or CN 28 | Functor = (TReturn(*)(Args...))(BaseAddress + OS_offset); 29 | } 30 | 31 | TReturn operator()(Args... args) 32 | { 33 | if ((uintptr_t)Functor > BaseAddress) { 34 | return Functor(args...); 35 | } 36 | else { 37 | Setup(); 38 | return Functor(args...); 39 | } 40 | } 41 | 42 | Function(uintptr_t os, uintptr_t cn) : OS_offset(os), CN_offset(cn) {} 43 | }; 44 | 45 | #define REMOTE_FUNC(ret, name, ...) inline static Function name 46 | -------------------------------------------------------------------------------- /src/Functions/Visuals/FpsUnlock.cpp: -------------------------------------------------------------------------------- 1 | #include "FpsUnlock.h" 2 | 3 | namespace Visuals { 4 | void hook_GameManager_Update(void* this_); 5 | void OnUpdate_FPSUnlock(); 6 | 7 | void FpsUnlock::InitConfig() { 8 | i_Limit = Config::GetValue(this->m_Name, "limit", 120); 9 | } 10 | 11 | void FpsUnlock::InitHooks() { 12 | Hooks::Attach(Offsets::GameManager::Update, hook_GameManager_Update); 13 | } 14 | 15 | FpsUnlock::FpsUnlock() : Feature( 16 | "FPS unlock", 17 | "Unlocks max. framerate") 18 | { 19 | InitConfig(); 20 | InitHooks(); 21 | } 22 | 23 | void FpsUnlock::Options() { 24 | ConfigSliderInt("Target FPS", i_Limit, 10, 240); 25 | } 26 | 27 | void FpsUnlock::Status() {} 28 | 29 | void FpsUnlock::OnUpdate() {} 30 | 31 | void FpsUnlock::ProcessHotkeys() {} 32 | 33 | void OnUpdate_FPSUnlock() { 34 | auto& instance = FpsUnlock::Instance(); 35 | 36 | //if (!MoleMole::LoadingManager::get_LoadingManager()->IsLoaded()) return; 37 | 38 | if (Offsets::Application::get_targetFramerate() != instance.i_Limit || !instance.m_Enabled) { 39 | Offsets::Application::set_targetFramerate(instance.m_Enabled ? instance.i_Limit : 60.f); 40 | Offsets::QualitySettings::set_vsyncCount(instance.m_Enabled ? 0 : 1); 41 | } 42 | } 43 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/imgui_stdlib.h: -------------------------------------------------------------------------------- 1 | // dear imgui: wrappers for C++ standard library (STL) types (std::string, etc.) 2 | // This is also an example of how you may wrap your own similar types. 3 | 4 | // Changelog: 5 | // - v0.10: Initial version. Added InputText() / InputTextMultiline() calls with std::string 6 | 7 | // See more C++ related extension (fmt, RAII, syntaxis sugar) on Wiki: 8 | // https://github.com/ocornut/imgui/wiki/Useful-Extensions#cness 9 | 10 | #pragma once 11 | 12 | #include 13 | 14 | namespace ImGui 15 | { 16 | // ImGui::InputText() with std::string 17 | // Because text input needs dynamic resizing, we need to setup a callback to grow the capacity 18 | IMGUI_API bool InputText(const char* label, std::string* str, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr); 19 | IMGUI_API bool InputTextMultiline(const char* label, std::string* str, const ImVec2& size = ImVec2(0, 0), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr); 20 | IMGUI_API bool InputTextWithHint(const char* label, const char* hint, std::string* str, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr); 21 | } 22 | -------------------------------------------------------------------------------- /src/Functions/Player/InfinityUltimate.cpp: -------------------------------------------------------------------------------- 1 | #include "InfinityUltimate.h" 2 | 3 | namespace Player { 4 | float hook_GetEnergy(void* this_); 5 | bool hook_IsEnergySkillAvailable(void* this_); 6 | 7 | void InfinityUltimate::InitConfig() {} 8 | 9 | void InfinityUltimate::InitHooks() { 10 | Hooks::Attach(Offsets::LCAvatarCombat::get_Energy, hook_GetEnergy); 11 | Hooks::Attach(Offsets::LCAvatarCombat::IsEnergySkillAvailable, hook_IsEnergySkillAvailable); 12 | } 13 | 14 | InfinityUltimate::InfinityUltimate() : Feature( 15 | ("Infinite Burst"), 16 | ("Charges burst energy")) 17 | { 18 | InitConfig(); 19 | InitHooks(); 20 | } 21 | 22 | void InfinityUltimate::Options() {} 23 | 24 | void InfinityUltimate::Status() {} 25 | 26 | void InfinityUltimate::OnUpdate() {} 27 | 28 | void InfinityUltimate::ProcessHotkeys() {} 29 | 30 | float hook_GetEnergy(void* this_) { 31 | auto& instance = InfinityUltimate::Instance(); 32 | if (instance.m_Enabled) 33 | return 1.0f; 34 | 35 | return Hooks::Call(hook_GetEnergy, this_); 36 | } 37 | 38 | bool hook_IsEnergySkillAvailable(void* this_) { 39 | auto& instance = InfinityUltimate::Instance(); 40 | if (instance.m_Enabled) 41 | return true; 42 | 43 | return Hooks::Call(hook_IsEnergySkillAvailable, this_); 44 | } 45 | } -------------------------------------------------------------------------------- /src/Functions/World/ESP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ESPBase.h" 3 | 4 | namespace World { 5 | class ESP : public Feature, public Singleton { 6 | public: 7 | 8 | /*ConfigField b_TpEnabled; 9 | ConfigField i_TpMode; 10 | Hotkey h_ClosestTP; 11 | std::map mapActors; 12 | 13 | float f_ClosestActor; 14 | RPG::GameEntity closestActor;*/ 15 | 16 | MoleMole::BaseEntity* cachedAvatar = 0; 17 | Unity::Camera* cachedCamera = 0; 18 | 19 | float f_BoxColor[4] = { 100 / 255.f, 150 / 255.f, 100 / 255.f, 200 / 255.f }; 20 | float f_OutlineColor[4] = { 200 / 255.f, 200 / 255.f, 200 / 255.f, 255 / 255.f }; 21 | bool b_DrawLines; 22 | 23 | bool b_Monsters; 24 | bool b_NPCs; 25 | bool b_Animals; 26 | bool b_Chests; 27 | bool b_Oculi; 28 | bool b_Collectibles; 29 | bool b_Puzzles; 30 | bool b_Challenges; 31 | bool b_Destroyables; 32 | bool b_Ores; 33 | 34 | float f_Range; 35 | 36 | #define DIRTY_CACHE() cachedEntities.clear() 37 | std::map cachedEntities; 38 | size_t cachedSize; 39 | 40 | void Options(); 41 | void Status(); 42 | void OnUpdate(); 43 | void ProcessHotkeys(); 44 | 45 | void InitConfig(); 46 | void InitHooks(); 47 | 48 | ESP(); 49 | }; 50 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svwinfnt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svwinfnt.h 4 | * 5 | * The FreeType Windows FNT/FONT service (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVWINFNT_H_ 20 | #define SVWINFNT_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_WINFNT "winfonts" 30 | 31 | typedef FT_Error 32 | (*FT_WinFnt_GetHeaderFunc)( FT_Face face, 33 | FT_WinFNT_HeaderRec *aheader ); 34 | 35 | 36 | FT_DEFINE_SERVICE( WinFnt ) 37 | { 38 | FT_WinFnt_GetHeaderFunc get_header; 39 | }; 40 | 41 | /* */ 42 | 43 | 44 | FT_END_HEADER 45 | 46 | 47 | #endif /* SVWINFNT_H_ */ 48 | 49 | 50 | /* END */ 51 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/svginterface.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svginterface.h 4 | * 5 | * Interface of ot-svg module (specification only). 6 | * 7 | * Copyright (C) 2022-2024 by 8 | * David Turner, Robert Wilhelm, Werner Lemberg, and Moazin Khatti. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVGINTERFACE_H_ 20 | #define SVGINTERFACE_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | typedef FT_Error 29 | (*Preset_Bitmap_Func)( FT_Module module, 30 | FT_GlyphSlot slot, 31 | FT_Bool cache ); 32 | 33 | typedef struct SVG_Interface_ 34 | { 35 | Preset_Bitmap_Func preset_slot; 36 | 37 | } SVG_Interface; 38 | 39 | typedef SVG_Interface* SVG_Service; 40 | 41 | FT_END_HEADER 42 | 43 | #endif /* SVGINTERFACE_H_ */ 44 | 45 | 46 | /* END */ 47 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svtteng.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svtteng.h 4 | * 5 | * The FreeType TrueType engine query service (specification). 6 | * 7 | * Copyright (C) 2006-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVTTENG_H_ 20 | #define SVTTENG_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | /* 30 | * SFNT table loading service. 31 | */ 32 | 33 | #define FT_SERVICE_ID_TRUETYPE_ENGINE "truetype-engine" 34 | 35 | /* 36 | * Used to implement FT_Get_TrueType_Engine_Type 37 | */ 38 | 39 | FT_DEFINE_SERVICE( TrueTypeEngine ) 40 | { 41 | FT_TrueTypeEngineType engine_type; 42 | }; 43 | 44 | /* */ 45 | 46 | 47 | FT_END_HEADER 48 | 49 | 50 | #endif /* SVTTENG_H_ */ 51 | 52 | 53 | /* END */ 54 | -------------------------------------------------------------------------------- /src/Functions/Teleports/ChestTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | #include "TeleportBase.h" 9 | #include 10 | 11 | namespace Teleports { 12 | struct VectorHasher 13 | { 14 | std::size_t operator()(const Unity::Vector3& k) const 15 | { 16 | using std::size_t; 17 | using std::hash; 18 | using std::string; 19 | 20 | return ((hash()(std::to_string(k.x)) 21 | ^ (hash()(std::to_string(k.y)) << 1)) >> 1) 22 | ^ (hash()(k.z) << 1); 23 | } 24 | }; 25 | 26 | class ChestTP : public Feature, public Singleton { 27 | public: 28 | Hotkey h_TP; 29 | 30 | MoleMole::BaseEntity* ClosestEntity; 31 | int Distance; 32 | 33 | MoleMole::BaseEntity* cachedAvatar = 0; 34 | Unity::Camera* cachedCamera = 0; 35 | std::vector cachedEntities; 36 | std::map chestMap; 37 | size_t cachedSize = 0; 38 | #define DIRTY_CACHE() cachedEntities.clear() 39 | 40 | void Options(); 41 | void Status(); 42 | void OnUpdate(); 43 | void ProcessHotkeys(); 44 | 45 | void InitConfig(); 46 | void InitHooks(); 47 | 48 | ChestTP(); 49 | }; 50 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svkern.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svkern.h 4 | * 5 | * The FreeType Kerning service (specification). 6 | * 7 | * Copyright (C) 2006-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVKERN_H_ 20 | #define SVKERN_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | #define FT_SERVICE_ID_KERNING "kerning" 29 | 30 | 31 | typedef FT_Error 32 | (*FT_Kerning_TrackGetFunc)( FT_Face face, 33 | FT_Fixed point_size, 34 | FT_Int degree, 35 | FT_Fixed* akerning ); 36 | 37 | FT_DEFINE_SERVICE( Kerning ) 38 | { 39 | FT_Kerning_TrackGetFunc get_track; 40 | }; 41 | 42 | /* */ 43 | 44 | 45 | FT_END_HEADER 46 | 47 | 48 | #endif /* SVKERN_H_ */ 49 | 50 | 51 | /* END */ 52 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/ftpsprop.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftpsprop.h 4 | * 5 | * Get and set properties of PostScript drivers (specification). 6 | * 7 | * Copyright (C) 2017-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef FTPSPROP_H_ 20 | #define FTPSPROP_H_ 21 | 22 | 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | FT_BASE_CALLBACK( FT_Error ) 30 | ps_property_set( FT_Module module, /* PS_Driver */ 31 | const char* property_name, 32 | const void* value, 33 | FT_Bool value_is_string ); 34 | 35 | FT_BASE_CALLBACK( FT_Error ) 36 | ps_property_get( FT_Module module, /* PS_Driver */ 37 | const char* property_name, 38 | void* value ); 39 | 40 | 41 | FT_END_HEADER 42 | 43 | 44 | #endif /* FTPSPROP_H_ */ 45 | 46 | 47 | /* END */ 48 | -------------------------------------------------------------------------------- /src/Functions/Visuals/FlycloakChanger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace Visuals { 10 | class FlycloakChanger : public Feature, public Singleton { 11 | public: 12 | std::map v_FlycloakList = { 13 | {140004, "Wings of Azure Wind"}, 14 | {140002, "Wings of Companionship"}, 15 | {140006, "Wings of Concealing Snow"}, 16 | {140014, "Wings of Delicacies"}, 17 | {140003, "Wings of Descension"}, 18 | {140016, "Wings of Fate's Course Intertwined"}, 19 | {140007, "Wings of Feasting"}, 20 | {140001, "Wings of First Flight"}, 21 | {140005, "Wings of Golden Flight"}, 22 | {140012, "Wings of Merciful, Wrathful Waters"}, 23 | {140009, "Wings of Shimmering Galaxy"}, 24 | {140015, "Wings of Soaring Flame"}, 25 | {140010, "Wings of the Forest"}, 26 | {140011, "Wings of the Starlit Feast"}, 27 | {140008, "Wings of the Stormstrider"}, 28 | {140013, "Wings of Transient Dreams"} 29 | }; 30 | 31 | ConfigField i_CurrentFlycloak; 32 | 33 | void Options(); 34 | void Status(); 35 | void OnUpdate(); 36 | void ProcessHotkeys(); 37 | 38 | void InitConfig(); 39 | void InitHooks(); 40 | 41 | FlycloakChanger(); 42 | }; 43 | } -------------------------------------------------------------------------------- /src/Functions/Player/MultiHit.cpp: -------------------------------------------------------------------------------- 1 | #include "MultiHit.h" 2 | 3 | namespace Player { 4 | void Hook_MultiHit_FireBeingHitEvent(void* this_, uint32_t attackeeId, void* attackResult); 5 | 6 | void HitMultiplier::InitConfig() { 7 | i_Hits = Config::GetValue(this->m_Name, ("hits"), 2); 8 | } 9 | 10 | void HitMultiplier::InitHooks() { 11 | Hooks::Attach(Offsets::LCBaseCombat::FireBeingHitEvent, Hook_MultiHit_FireBeingHitEvent); 12 | } 13 | 14 | HitMultiplier::HitMultiplier() : Feature( 15 | ("Hit Multiplier"), 16 | ("Multiplies your attacks")) 17 | { 18 | InitConfig(); 19 | InitHooks(); 20 | } 21 | 22 | void HitMultiplier::Options() 23 | { 24 | ConfigSliderInt("Hits", i_Hits, 1, 5); 25 | } 26 | 27 | void HitMultiplier::Status() {} 28 | 29 | void HitMultiplier::OnUpdate() {} 30 | 31 | void HitMultiplier::ProcessHotkeys() {} 32 | 33 | void Hook_MultiHit_FireBeingHitEvent(void* this_, uint32_t attackeeId, void* attackResult) { 34 | auto& instance = HitMultiplier::Instance(); 35 | 36 | if (instance.m_Enabled && attackeeId != MoleMole::EntityManager::get_EntityManager()->avatar()->runtimeId()) { 37 | for (int i = 0; i < instance.i_Hits; ++i) { 38 | Hooks::Call(Hook_MultiHit_FireBeingHitEvent, this_, attackeeId, attackResult); 39 | } 40 | return; 41 | } 42 | 43 | Hooks::Call(Hook_MultiHit_FireBeingHitEvent, this_, attackeeId, attackResult); 44 | } 45 | } -------------------------------------------------------------------------------- /src/Functions/Player/NoSkillCd.cpp: -------------------------------------------------------------------------------- 1 | #include "NoSkillCd.h" 2 | #include 3 | namespace Player { 4 | void hook_TickSkillCd(void* this_, float a1); 5 | void hook_UpdateSprintCooldown(void* this_, float tick); 6 | 7 | void NoSkillCd::InitConfig() { 8 | b_NoSprintCd = Config::GetValue(this->m_Name, ("noSprintCd"), false); 9 | } 10 | 11 | void NoSkillCd::InitHooks() { 12 | Hooks::Attach(Offsets::LCAvatarCombat::TickSkillCd, hook_TickSkillCd); 13 | Hooks::Attach(Offsets::HumanoidMoveFSM::UpdateSprintCooldown, hook_UpdateSprintCooldown); 14 | } 15 | 16 | NoSkillCd::NoSkillCd() : Feature( 17 | ("No skill cooldown"), 18 | ("Removes skill cooldown")) 19 | { 20 | InitConfig(); 21 | InitHooks(); 22 | } 23 | 24 | void NoSkillCd::Options() { 25 | ConfigCheckbox(("No sprint CD"), b_NoSprintCd); 26 | } 27 | 28 | void NoSkillCd::Status() {} 29 | 30 | void NoSkillCd::OnUpdate() {} 31 | 32 | void NoSkillCd::ProcessHotkeys() {} 33 | 34 | void hook_TickSkillCd(void* this_, float a1) { 35 | auto& instance = NoSkillCd::Instance(); 36 | if (instance.m_Enabled) 37 | a1 = 0.9f; 38 | Hooks::Call(hook_TickSkillCd, this_, a1); 39 | } 40 | 41 | void hook_UpdateSprintCooldown(void* this_, float tick) { 42 | auto& instance = NoSkillCd::Instance(); 43 | if (instance.m_Enabled) 44 | tick = 0.5f; 45 | Hooks::Call(hook_UpdateSprintCooldown, this_, tick); 46 | } 47 | } -------------------------------------------------------------------------------- /src/Functions/World/ESPBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define IMGUI_DEFINE_MATH_OPERATORS 4 | #include "../../Engine/SDK.h" 5 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 6 | #include "../../Utils/Hooking.h" 7 | #include "../../Utils/Singleton.h" 8 | #include "../Feature.h" 9 | #include 10 | 11 | class ESPBase { 12 | public: 13 | // Structs 14 | enum class DrawMode { 15 | Box = 1, 16 | Chams = 2 17 | }; 18 | 19 | enum class PointMode { 20 | Line = 1, 21 | Arrows = 2, 22 | None = 3 23 | }; 24 | 25 | enum class TpMode : int { 26 | Closest = 0, 27 | OnClick = 1 28 | }; 29 | static inline const char* TpModeNames[2] = { "Closest", "On Click" }; 30 | 31 | struct Bounds { 32 | Unity::Vector3 center; 33 | Unity::Vector3 extent; 34 | 35 | Unity::Vector3 p_min(); 36 | Unity::Vector3 p_max(); 37 | }; 38 | 39 | // Utils 40 | static inline ImVec4 ColorVecToImVec(std::vector color); 41 | static inline Bounds GetBoundsFromActor(MoleMole::BaseEntity* actor); 42 | static ImVec2 WorldToScreen(Unity::Vector3 world, Unity::Camera* camera); 43 | 44 | // Drawing 45 | static void DrawActor(MoleMole::BaseEntity* actor, MoleMole::BaseEntity* avatar, Unity::Camera* camera, ESPBase::DrawMode drawmode, ESPBase::PointMode pointmode, std::vector borderColor, std::vector boxColor, std::function onClickCallback = 0); // RGBA 46 | }; -------------------------------------------------------------------------------- /Minty-GI.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 17 4 | VisualStudioVersion = 17.9.34728.123 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Minty-GI", "Minty-GI.vcxproj", "{CFBD676B-748D-46CC-A658-BF65FC23AAB4}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Debug|x64.ActiveCfg = Debug|x64 17 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Debug|x64.Build.0 = Debug|x64 18 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Debug|x86.ActiveCfg = Debug|Win32 19 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Debug|x86.Build.0 = Debug|Win32 20 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Release|x64.ActiveCfg = Release|x64 21 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Release|x64.Build.0 = Release|x64 22 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Release|x86.ActiveCfg = Release|Win32 23 | {CFBD676B-748D-46CC-A658-BF65FC23AAB4}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {A02F08C4-BA0B-425A-B332-6A3357339C3F} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svotval.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svotval.h 4 | * 5 | * The FreeType OpenType validation service (specification). 6 | * 7 | * Copyright (C) 2004-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVOTVAL_H_ 20 | #define SVOTVAL_H_ 21 | 22 | #include 23 | #include 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | #define FT_SERVICE_ID_OPENTYPE_VALIDATE "opentype-validate" 29 | 30 | 31 | typedef FT_Error 32 | (*otv_validate_func)( FT_Face volatile face, 33 | FT_UInt ot_flags, 34 | FT_Bytes *base, 35 | FT_Bytes *gdef, 36 | FT_Bytes *gpos, 37 | FT_Bytes *gsub, 38 | FT_Bytes *jstf ); 39 | 40 | 41 | FT_DEFINE_SERVICE( OTvalidate ) 42 | { 43 | otv_validate_func validate; 44 | }; 45 | 46 | /* */ 47 | 48 | 49 | FT_END_HEADER 50 | 51 | 52 | #endif /* SVOTVAL_H_ */ 53 | 54 | 55 | /* END */ 56 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svttglyf.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svttglyf.h 4 | * 5 | * The FreeType TrueType glyph service. 6 | * 7 | * Copyright (C) 2007-2024 by 8 | * David Turner. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | #ifndef SVTTGLYF_H_ 19 | #define SVTTGLYF_H_ 20 | 21 | #include 22 | #include 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | #define FT_SERVICE_ID_TT_GLYF "tt-glyf" 29 | 30 | 31 | typedef FT_ULong 32 | (*TT_Glyf_GetLocationFunc)( FT_Face face, 33 | FT_UInt gindex, 34 | FT_ULong *psize ); 35 | 36 | FT_DEFINE_SERVICE( TTGlyf ) 37 | { 38 | TT_Glyf_GetLocationFunc get_location; 39 | }; 40 | 41 | 42 | #define FT_DEFINE_SERVICE_TTGLYFREC( class_, get_location_ ) \ 43 | static const FT_Service_TTGlyfRec class_ = \ 44 | { \ 45 | get_location_ \ 46 | }; 47 | 48 | /* */ 49 | 50 | 51 | FT_END_HEADER 52 | 53 | #endif /* SVTTGLYF_H_ */ 54 | 55 | 56 | /* END */ 57 | -------------------------------------------------------------------------------- /src/Functions/Visuals/ObjectSpawner.cpp: -------------------------------------------------------------------------------- 1 | #include "ObjectSpawner.h" 2 | 3 | namespace Visuals { 4 | void Spawn_Alchem(); 5 | void Spawn_Forging(); 6 | void Spawn_Katheryne(); 7 | 8 | void ObjectSpawner::InitConfig() { 9 | h_Alchemist = Hotkey(this->m_Name, "alchemist", ImGuiKey_F9); 10 | h_Forging = Hotkey(this->m_Name, "forging", ImGuiKey_F10); 11 | h_Katheryne = Hotkey(this->m_Name, "katheryne", ImGuiKey_F11); 12 | } 13 | 14 | void ObjectSpawner::InitHooks() {} 15 | 16 | ObjectSpawner::ObjectSpawner() : Feature( 17 | "Object spawner", 18 | "Spawns some useful objects") 19 | { 20 | InitConfig(); 21 | InitHooks(); 22 | } 23 | 24 | void ObjectSpawner::Options() { 25 | if (ImGui::Button("Alchemists' Bench")) { 26 | Spawn_Alchem(); 27 | } ImGui::SameLine(); h_Alchemist.Draw(); 28 | 29 | if (ImGui::Button("Forging Bench")) { 30 | Spawn_Forging(); 31 | } ImGui::SameLine(); h_Forging.Draw(); 32 | 33 | if (ImGui::Button("Katheryne")) { 34 | Spawn_Katheryne(); 35 | } ImGui::SameLine(); h_Katheryne.Draw(); 36 | } 37 | 38 | void ObjectSpawner::Status() {} 39 | 40 | void ObjectSpawner::OnUpdate() {} 41 | 42 | void ObjectSpawner::ProcessHotkeys() { 43 | if (m_Enabled && h_Alchemist.IsPressed()) Spawn_Alchem(); 44 | if (m_Enabled && h_Forging.IsPressed()) Spawn_Forging(); 45 | if (m_Enabled && h_Katheryne.IsPressed()) Spawn_Katheryne(); 46 | } 47 | 48 | void Spawn_Alchem() { 49 | // ¯\_(ツ)_/¯ 50 | } 51 | 52 | void Spawn_Forging() { 53 | // ¯\_(ツ)_/¯ 54 | } 55 | 56 | void Spawn_Katheryne() { 57 | // ¯\_(ツ)_/¯ 58 | } 59 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/FakeWeather.cpp: -------------------------------------------------------------------------------- 1 | #include "FakeWeather.h" 2 | 3 | namespace Visuals { 4 | void hook_FakeWeather_OnUpdate(void* this_); 5 | 6 | void FakeWeather::InitConfig() 7 | { 8 | s_Weather = Config::GetValue(this->m_Name, "weather", "Clear"); 9 | } 10 | 11 | void FakeWeather::InitHooks() { 12 | Hooks::Attach(Offsets::GameManager::Update, hook_FakeWeather_OnUpdate); 13 | } 14 | 15 | FakeWeather::FakeWeather() : Feature( 16 | "Fake Weather", 17 | "Changes weather in the world") 18 | { 19 | InitConfig(); 20 | InitHooks(); 21 | } 22 | 23 | void FakeWeather::Options() 24 | { 25 | if (ImGui::BeginCombo("Weather type", s_Weather.getValue().c_str())) 26 | { 27 | for (auto& [name, path] : weatherMap) 28 | { 29 | if (ImGui::Selectable(name.c_str())) 30 | { 31 | s_Weather.setValue(name); 32 | Config::SetValue(s_Weather, name); 33 | } 34 | } 35 | ImGui::EndCombo(); 36 | } 37 | } 38 | 39 | void FakeWeather::Status() {} 40 | 41 | void FakeWeather::OnUpdate() {} 42 | 43 | void FakeWeather::ProcessHotkeys() {} 44 | 45 | void hook_FakeWeather_OnUpdate(void* this_) 46 | { 47 | auto& instance = FakeWeather::Instance(); 48 | 49 | if (instance.m_Enabled) 50 | { 51 | auto enviroSky = Offsets::EnviroSky::get_Instance(); 52 | if (enviroSky) 53 | { 54 | auto path = weatherMap[instance.s_Weather.getValue()]; 55 | Offsets::EnviroSky::ChangeWeather(enviroSky, Unity::String::FromCString(path), 1, 1, false); 56 | } 57 | } 58 | 59 | Hooks::Call(hook_FakeWeather_OnUpdate, this_); 60 | } 61 | } -------------------------------------------------------------------------------- /src/Functions/Player/Godmode.cpp: -------------------------------------------------------------------------------- 1 | #include "Godmode.h" 2 | 3 | namespace Player { 4 | void hook_VCHumanoidMove_NotifyLandVelocity(void* this_, Unity::Vector3 a1, float a2); 5 | void Hook_Godmode_FireBeingHitEvent(void* this_, uint32_t attackeeId, void* attackResult); 6 | 7 | void Invincibility::InitConfig() {} 8 | 9 | void Invincibility::InitHooks() { 10 | Hooks::Attach(Offsets::LCBaseCombat::FireBeingHitEvent, Hook_Godmode_FireBeingHitEvent); 11 | Hooks::Attach(Offsets::VCHumanoidMove::NotifyLandVelocity, hook_VCHumanoidMove_NotifyLandVelocity); 12 | } 13 | 14 | Invincibility::Invincibility() : Feature( 15 | ("Invincibility"), 16 | ("Makes your character invincible")) 17 | { 18 | InitConfig(); 19 | InitHooks(); 20 | } 21 | 22 | void Invincibility::Options() {} 23 | 24 | void Invincibility::Status() {}; 25 | 26 | void Invincibility::OnUpdate() {}; 27 | 28 | void Invincibility::ProcessHotkeys() {} 29 | 30 | void Hook_Godmode_FireBeingHitEvent(void* this_, uint32_t attackeeId, void* attackResult) { 31 | auto& instance = Invincibility::Instance(); 32 | if (instance.m_Enabled && attackeeId == MoleMole::EntityManager::get_EntityManager()->avatar()->runtimeId()) 33 | return; 34 | Hooks::Call(Hook_Godmode_FireBeingHitEvent, this_, attackeeId, attackResult); 35 | } 36 | 37 | void hook_VCHumanoidMove_NotifyLandVelocity(void* this_, Unity::Vector3 a1, float a2) 38 | { 39 | auto& instance = Invincibility::Instance(); 40 | if (instance.m_Enabled) 41 | return; 42 | 43 | Hooks::Call(hook_VCHumanoidMove_NotifyLandVelocity, this_, a1, a2); 44 | } 45 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/config/ftmodule.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file registers the FreeType modules compiled into the library. 3 | * 4 | * If you use GNU make, this file IS NOT USED! Instead, it is created in 5 | * the objects directory (normally `/objs/`) based on information 6 | * from `/modules.cfg`. 7 | * 8 | * Please read `docs/INSTALL.ANY` and `docs/CUSTOMIZE` how to compile 9 | * FreeType without GNU make. 10 | * 11 | */ 12 | 13 | FT_USE_MODULE( FT_Module_Class, autofit_module_class ) 14 | FT_USE_MODULE( FT_Driver_ClassRec, tt_driver_class ) 15 | FT_USE_MODULE( FT_Driver_ClassRec, t1_driver_class ) 16 | FT_USE_MODULE( FT_Driver_ClassRec, cff_driver_class ) 17 | FT_USE_MODULE( FT_Driver_ClassRec, t1cid_driver_class ) 18 | FT_USE_MODULE( FT_Driver_ClassRec, pfr_driver_class ) 19 | FT_USE_MODULE( FT_Driver_ClassRec, t42_driver_class ) 20 | FT_USE_MODULE( FT_Driver_ClassRec, winfnt_driver_class ) 21 | FT_USE_MODULE( FT_Driver_ClassRec, pcf_driver_class ) 22 | FT_USE_MODULE( FT_Driver_ClassRec, bdf_driver_class ) 23 | FT_USE_MODULE( FT_Module_Class, psaux_module_class ) 24 | FT_USE_MODULE( FT_Module_Class, psnames_module_class ) 25 | FT_USE_MODULE( FT_Module_Class, pshinter_module_class ) 26 | FT_USE_MODULE( FT_Module_Class, sfnt_module_class ) 27 | FT_USE_MODULE( FT_Renderer_Class, ft_smooth_renderer_class ) 28 | FT_USE_MODULE( FT_Renderer_Class, ft_raster1_renderer_class ) 29 | FT_USE_MODULE( FT_Renderer_Class, ft_sdf_renderer_class ) 30 | FT_USE_MODULE( FT_Renderer_Class, ft_bitmap_sdf_renderer_class ) 31 | FT_USE_MODULE( FT_Renderer_Class, ft_svg_renderer_class ) 32 | 33 | /* EOF */ 34 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svfntfmt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svfntfmt.h 4 | * 5 | * The FreeType font format service (specification only). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVFNTFMT_H_ 20 | #define SVFNTFMT_H_ 21 | 22 | #include 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | /* 29 | * A trivial service used to return the name of a face's font driver, 30 | * according to the XFree86 nomenclature. Note that the service data is a 31 | * simple constant string pointer. 32 | */ 33 | 34 | #define FT_SERVICE_ID_FONT_FORMAT "font-format" 35 | 36 | #define FT_FONT_FORMAT_TRUETYPE "TrueType" 37 | #define FT_FONT_FORMAT_TYPE_1 "Type 1" 38 | #define FT_FONT_FORMAT_BDF "BDF" 39 | #define FT_FONT_FORMAT_PCF "PCF" 40 | #define FT_FONT_FORMAT_TYPE_42 "Type 42" 41 | #define FT_FONT_FORMAT_CID "CID Type 1" 42 | #define FT_FONT_FORMAT_CFF "CFF" 43 | #define FT_FONT_FORMAT_PFR "PFR" 44 | #define FT_FONT_FORMAT_WINFNT "Windows FNT" 45 | 46 | /* */ 47 | 48 | 49 | FT_END_HEADER 50 | 51 | 52 | #endif /* SVFNTFMT_H_ */ 53 | 54 | 55 | /* END */ 56 | -------------------------------------------------------------------------------- /src/GUI/DirectX/DirectXHook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 4 | #include "../../Utils/detours.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../../Utils/obfusheader.h" 8 | #include "../Menu/InitGUI.h" 9 | #include "../Menu/MainGUI.h" 10 | #include 11 | #include 12 | 13 | #pragma comment(lib, "d3d11.lib") 14 | #pragma comment(lib, "detours.lib") 15 | 16 | namespace { 17 | typedef HRESULT(__stdcall* ResizeBuffers)(IDXGISwapChain* pSwapChain, UINT BufferCount, UINT Width, UINT Height, DXGI_FORMAT NewFormat, UINT SwapChainFlags); 18 | typedef HRESULT(__fastcall* IDXGISwapChainPresent)(IDXGISwapChain* pSwapChain, UINT SyncInterval, UINT Flags); 19 | 20 | LRESULT CALLBACK DXGIMsgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { return DefWindowProc(hwnd, uMsg, wParam, lParam); } 21 | 22 | static WNDPROC OriginalWndProcHandler = nullptr; 23 | ID3D11RenderTargetView* MainRenderTargetView = nullptr; 24 | ID3D11DeviceContext* pContext = nullptr; 25 | ID3D11Device* pDevice = nullptr; 26 | static IDXGISwapChain* pSwapChain = nullptr; 27 | ResizeBuffers oResizeBuffers = nullptr; 28 | HWND window = nullptr; 29 | IDXGISwapChainPresent fnIDXGISwapChainPresent = nullptr; 30 | } 31 | 32 | namespace DxHook { 33 | IDXGISwapChainPresent findDirect11Present(); 34 | void HookPresent(); 35 | void HookResizeBuffers(); 36 | bool LoadTextureFromMemory(const void* data, size_t data_size, void** out_srv, int* out_width, int* out_height); 37 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/FlycloakChanger.cpp: -------------------------------------------------------------------------------- 1 | #include "FlycloakChanger.h" 2 | 3 | namespace Visuals { 4 | void hook_HandleAvatarAppear2(void* this_, MoleMole::SceneEntityInfo* info, void* a1, uint32_t a2); 5 | 6 | void FlycloakChanger::InitConfig() { 7 | i_CurrentFlycloak = Config::GetValue(this->m_Name, "flycloak", 140014); 8 | } 9 | 10 | void FlycloakChanger::InitHooks() { 11 | Hooks::Attach(Offsets::PlayerModule::HandleAvatarAppear2, hook_HandleAvatarAppear2); 12 | } 13 | 14 | FlycloakChanger::FlycloakChanger() : Feature( 15 | "Change Glider", 16 | "Changes your Glider. Change avatar to apply.") 17 | { 18 | InitConfig(); 19 | InitHooks(); 20 | } 21 | 22 | void FlycloakChanger::Options() { 23 | if (ImGui::BeginCombo("Flycloak", v_FlycloakList[i_CurrentFlycloak].c_str())) { 24 | for (auto& [id, name] : v_FlycloakList) { 25 | if (ImGui::Selectable(name.c_str())) { 26 | i_CurrentFlycloak.setValue(id); 27 | Config::SetValue(i_CurrentFlycloak, id); 28 | } 29 | } 30 | ImGui::EndCombo(); 31 | } 32 | } 33 | 34 | void FlycloakChanger::Status() {} 35 | 36 | void FlycloakChanger::OnUpdate() {} 37 | 38 | void FlycloakChanger::ProcessHotkeys() {} 39 | 40 | void hook_HandleAvatarAppear2(void* this_, MoleMole::SceneEntityInfo* info, void* a1, uint32_t a2) { 41 | auto& instance = FlycloakChanger::Instance(); 42 | 43 | void* sceneAvatarInfo = *reinterpret_cast((uintptr_t)info + 0x0); 44 | 45 | if (instance.m_Enabled) 46 | *reinterpret_cast((uintptr_t)sceneAvatarInfo + 0x0) = instance.i_CurrentFlycloak; 47 | 48 | Hooks::Call(hook_HandleAvatarAppear2, this_, info, a1, a2); 49 | } 50 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/imgui_impl_dx11.h: -------------------------------------------------------------------------------- 1 | // dear imgui: Renderer Backend for DirectX11 2 | // This needs to be used along with a Platform Backend (e.g. Win32) 3 | 4 | // Implemented features: 5 | // [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID! 6 | // [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices. 7 | 8 | // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. 9 | // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. 10 | // Learn about Dear ImGui: 11 | // - FAQ https://dearimgui.com/faq 12 | // - Getting Started https://dearimgui.com/getting-started 13 | // - Documentation https://dearimgui.com/docs (same as your local docs/ folder). 14 | // - Introduction, links and more at the top of imgui.cpp 15 | 16 | #pragma once 17 | #include "imgui.h" // IMGUI_IMPL_API 18 | #ifndef IMGUI_DISABLE 19 | 20 | struct ID3D11Device; 21 | struct ID3D11DeviceContext; 22 | 23 | IMGUI_IMPL_API bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context); 24 | IMGUI_IMPL_API void ImGui_ImplDX11_Shutdown(); 25 | IMGUI_IMPL_API void ImGui_ImplDX11_NewFrame(); 26 | IMGUI_IMPL_API void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data); 27 | 28 | // Use if you want to reset your rendering device without losing Dear ImGui state. 29 | IMGUI_IMPL_API void ImGui_ImplDX11_InvalidateDeviceObjects(); 30 | IMGUI_IMPL_API bool ImGui_ImplDX11_CreateDeviceObjects(); 31 | 32 | #endif // #ifndef IMGUI_DISABLE 33 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/config/mac-support.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * config/mac-support.h 4 | * 5 | * Mac/OS X support configuration header. 6 | * 7 | * Copyright (C) 1996-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | #ifndef FREETYPE_CONFIG_MAC_SUPPORT_H_ 18 | #define FREETYPE_CONFIG_MAC_SUPPORT_H_ 19 | 20 | /************************************************************************** 21 | * 22 | * Mac support 23 | * 24 | * This is the only necessary change, so it is defined here instead 25 | * providing a new configuration file. 26 | */ 27 | #if defined( __APPLE__ ) || ( defined( __MWERKS__ ) && defined( macintosh ) ) 28 | /* No Carbon frameworks for 64bit 10.4.x. */ 29 | /* `AvailabilityMacros.h` is available since Mac OS X 10.2, */ 30 | /* so guess the system version by maximum errno before inclusion. */ 31 | #include 32 | #ifdef ECANCELED /* defined since 10.2 */ 33 | #include "AvailabilityMacros.h" 34 | #endif 35 | #if defined( __LP64__ ) && \ 36 | ( MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4 ) 37 | #undef FT_MACINTOSH 38 | #endif 39 | 40 | #elif defined( __SC__ ) || defined( __MRC__ ) 41 | /* Classic MacOS compilers */ 42 | #include "ConditionalMacros.h" 43 | #if TARGET_OS_MAC 44 | #define FT_MACINTOSH 1 45 | #endif 46 | 47 | #endif /* Mac support */ 48 | 49 | #endif /* FREETYPE_CONFIG_MAC_SUPPORT_H_ */ 50 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/config/ftconfig.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftconfig.h 4 | * 5 | * ANSI-specific configuration file (specification only). 6 | * 7 | * Copyright (C) 1996-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | /************************************************************************** 20 | * 21 | * This header file contains a number of macro definitions that are used by 22 | * the rest of the engine. Most of the macros here are automatically 23 | * determined at compile time, and you should not need to change it to port 24 | * FreeType, except to compile the library with a non-ANSI compiler. 25 | * 26 | * Note however that if some specific modifications are needed, we advise 27 | * you to place a modified copy in your build directory. 28 | * 29 | * The build directory is usually `builds/`, and contains 30 | * system-specific files that are always included first when building the 31 | * library. 32 | * 33 | * This ANSI version should stay in `include/config/`. 34 | * 35 | */ 36 | 37 | #ifndef FTCONFIG_H_ 38 | #define FTCONFIG_H_ 39 | 40 | #include 41 | #include FT_CONFIG_OPTIONS_H 42 | #include FT_CONFIG_STANDARD_LIBRARY_H 43 | 44 | #include 45 | #include 46 | #include 47 | 48 | #endif /* FTCONFIG_H_ */ 49 | 50 | 51 | /* END */ 52 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svpfr.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svpfr.h 4 | * 5 | * Internal PFR service functions (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPFR_H_ 20 | #define SVPFR_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_PFR_METRICS "pfr-metrics" 30 | 31 | 32 | typedef FT_Error 33 | (*FT_PFR_GetMetricsFunc)( FT_Face face, 34 | FT_UInt *aoutline, 35 | FT_UInt *ametrics, 36 | FT_Fixed *ax_scale, 37 | FT_Fixed *ay_scale ); 38 | 39 | typedef FT_Error 40 | (*FT_PFR_GetKerningFunc)( FT_Face face, 41 | FT_UInt left, 42 | FT_UInt right, 43 | FT_Vector *avector ); 44 | 45 | typedef FT_Error 46 | (*FT_PFR_GetAdvanceFunc)( FT_Face face, 47 | FT_UInt gindex, 48 | FT_Pos *aadvance ); 49 | 50 | 51 | FT_DEFINE_SERVICE( PfrMetrics ) 52 | { 53 | FT_PFR_GetMetricsFunc get_metrics; 54 | FT_PFR_GetKerningFunc get_kerning; 55 | FT_PFR_GetAdvanceFunc get_advance; 56 | 57 | }; 58 | 59 | 60 | FT_END_HEADER 61 | 62 | #endif /* SVPFR_H_ */ 63 | 64 | 65 | /* END */ 66 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svpostnm.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svpostnm.h 4 | * 5 | * The FreeType PostScript name services (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPOSTNM_H_ 20 | #define SVPOSTNM_H_ 21 | 22 | #include 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | /* 28 | * A trivial service used to retrieve the PostScript name of a given font 29 | * when available. The `get_name' field should never be `NULL`. 30 | * 31 | * The corresponding function can return `NULL` to indicate that the 32 | * PostScript name is not available. 33 | * 34 | * The name is owned by the face and will be destroyed with it. 35 | */ 36 | 37 | #define FT_SERVICE_ID_POSTSCRIPT_FONT_NAME "postscript-font-name" 38 | 39 | 40 | typedef const char* 41 | (*FT_PsName_GetFunc)( FT_Face face ); 42 | 43 | 44 | FT_DEFINE_SERVICE( PsFontName ) 45 | { 46 | FT_PsName_GetFunc get_ps_font_name; 47 | }; 48 | 49 | 50 | #define FT_DEFINE_SERVICE_PSFONTNAMEREC( class_, get_ps_font_name_ ) \ 51 | static const FT_Service_PsFontNameRec class_ = \ 52 | { \ 53 | get_ps_font_name_ \ 54 | }; 55 | 56 | /* */ 57 | 58 | 59 | FT_END_HEADER 60 | 61 | 62 | #endif /* SVPOSTNM_H_ */ 63 | 64 | 65 | /* END */ 66 | -------------------------------------------------------------------------------- /src/Functions/Visuals/ConstChanger.cpp: -------------------------------------------------------------------------------- 1 | #include "ConstChanger.h" 2 | 3 | namespace Visuals { 4 | void hook_ConstChanger_HandleAvatarAppear2(void* this_, MoleMole::SceneEntityInfo* info, void* a1, uint32_t a2); 5 | 6 | void ConstChanger::InitConfig() { 7 | i_ConstellationLevel = Config::GetValue(this->m_Name, "level", 6); 8 | } 9 | 10 | void ConstChanger::InitHooks() { 11 | Hooks::Attach(Offsets::PlayerModule::HandleAvatarAppear2, hook_ConstChanger_HandleAvatarAppear2); 12 | } 13 | 14 | ConstChanger::ConstChanger() : Feature( 15 | "C6 Unlocker", 16 | "Unlocks C6 on your character. Switch avatar to apply.\nMost constellations will not have actual effect, though some still will. Do not report it as a bug.\nDISABLE BEFORE GOING INTO ABYSS!") 17 | { 18 | InitConfig(); 19 | InitHooks(); 20 | } 21 | 22 | void ConstChanger::Options() {} 23 | 24 | void ConstChanger::Status() {} 25 | 26 | void ConstChanger::OnUpdate() {} 27 | 28 | void ConstChanger::ProcessHotkeys() {} 29 | 30 | void hook_ConstChanger_HandleAvatarAppear2(void* this_, MoleMole::SceneEntityInfo* info, void* a1, uint32_t a2) { 31 | auto& instance = ConstChanger::Instance(); 32 | 33 | if (instance.m_Enabled) 34 | { 35 | void* sceneAvatarInfo = *reinterpret_cast((uintptr_t)info + 0x0); 36 | if (sceneAvatarInfo != nullptr) 37 | { 38 | MoleMole::RepeatedField* talentIdList = *reinterpret_cast((uintptr_t)sceneAvatarInfo + 0x0); 39 | if (talentIdList != nullptr) 40 | { 41 | int avatarId = *reinterpret_cast((uintptr_t)sceneAvatarInfo + 0x0) - 10'000'000; 42 | talentIdList->count = 6; 43 | talentIdList->array->max_length = 6; 44 | for (int i = 1; i <= instance.i_ConstellationLevel; i++) 45 | { 46 | talentIdList->array->vector[i] = (avatarId * 10) + i; 47 | } 48 | } 49 | } 50 | } 51 | 52 | Hooks::Call(hook_ConstChanger_HandleAvatarAppear2, this_, info, a1, a2); 53 | } 54 | } -------------------------------------------------------------------------------- /src/Functions/World/AutoSeelie.cpp: -------------------------------------------------------------------------------- 1 | #include "AutoSeelie.h" 2 | 3 | namespace World { 4 | void hook_AutoSeelie_OnUpdate(void* this_); 5 | 6 | void AutoSeelie::InitConfig() {} 7 | 8 | void AutoSeelie::InitHooks() { 9 | Hooks::Attach(Offsets::GameManager::Update, hook_AutoSeelie_OnUpdate); 10 | } 11 | 12 | AutoSeelie::AutoSeelie() : Feature( 13 | "Auto Seelie", 14 | "Once you first 'activate' the seelie, it will start automatically going to the target.") 15 | { 16 | InitConfig(); 17 | InitHooks(); 18 | } 19 | 20 | void AutoSeelie::Options() 21 | { 22 | ConfigCheckbox("Speedup Seelies", b_SpeedupSeelies); 23 | } 24 | 25 | void AutoSeelie::Status() {} 26 | 27 | void AutoSeelie::OnUpdate() {} 28 | 29 | void AutoSeelie::ProcessHotkeys() {} 30 | 31 | std::map entityMap; 32 | void hook_AutoSeelie_OnUpdate(void* this_) 33 | { 34 | auto& instance = AutoSeelie::Instance(); 35 | 36 | if (instance.m_Enabled) 37 | { 38 | auto entityManager = MoleMole::EntityManager::get_EntityManager(); 39 | if (entityManager) 40 | { 41 | auto avatar = entityManager->avatar(); 42 | if (avatar) 43 | { 44 | auto avatarPos = avatar->getPosition(); 45 | 46 | for (auto& entity : entityManager->entities()) 47 | { 48 | if (entity->type() == MoleMole::EntityType::Platform) 49 | { 50 | if (entity->name().find("Seelie") != std::string::npos) 51 | { 52 | entityMap[entity->runtimeId()] = entity; 53 | entity->setPosition(avatarPos); 54 | } 55 | } 56 | } 57 | } 58 | } 59 | } 60 | 61 | if (instance.b_SpeedupSeelies) 62 | { 63 | for (auto& [id, entity] : entityMap) 64 | { 65 | auto animator = entity->animator(); 66 | if (animator) 67 | Offsets::Animator::set_Speed(animator, instance.m_Enabled ? 5.0f : 1.0f); 68 | } 69 | } 70 | 71 | if (!entityMap.empty()) 72 | entityMap.clear(); 73 | 74 | Hooks::Call(hook_AutoSeelie_OnUpdate, this_); 75 | } 76 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svprop.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svprop.h 4 | * 5 | * The FreeType property service (specification). 6 | * 7 | * Copyright (C) 2012-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPROP_H_ 20 | #define SVPROP_H_ 21 | 22 | 23 | FT_BEGIN_HEADER 24 | 25 | 26 | #define FT_SERVICE_ID_PROPERTIES "properties" 27 | 28 | 29 | typedef FT_Error 30 | (*FT_Properties_SetFunc)( FT_Module module, 31 | const char* property_name, 32 | const void* value, 33 | FT_Bool value_is_string ); 34 | 35 | typedef FT_Error 36 | (*FT_Properties_GetFunc)( FT_Module module, 37 | const char* property_name, 38 | void* value ); 39 | 40 | 41 | FT_DEFINE_SERVICE( Properties ) 42 | { 43 | FT_Properties_SetFunc set_property; 44 | FT_Properties_GetFunc get_property; 45 | }; 46 | 47 | 48 | #define FT_DEFINE_SERVICE_PROPERTIESREC( class_, \ 49 | set_property_, \ 50 | get_property_ ) \ 51 | static const FT_Service_PropertiesRec class_ = \ 52 | { \ 53 | set_property_, \ 54 | get_property_ \ 55 | }; 56 | 57 | /* */ 58 | 59 | 60 | FT_END_HEADER 61 | 62 | 63 | #endif /* SVPROP_H_ */ 64 | 65 | 66 | /* END */ 67 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svbdf.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svbdf.h 4 | * 5 | * The FreeType BDF services (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVBDF_H_ 20 | #define SVBDF_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_BDF "bdf" 30 | 31 | typedef FT_Error 32 | (*FT_BDF_GetCharsetIdFunc)( FT_Face face, 33 | const char* *acharset_encoding, 34 | const char* *acharset_registry ); 35 | 36 | typedef FT_Error 37 | (*FT_BDF_GetPropertyFunc)( FT_Face face, 38 | const char* prop_name, 39 | BDF_PropertyRec *aproperty ); 40 | 41 | 42 | FT_DEFINE_SERVICE( BDF ) 43 | { 44 | FT_BDF_GetCharsetIdFunc get_charset_id; 45 | FT_BDF_GetPropertyFunc get_property; 46 | }; 47 | 48 | 49 | #define FT_DEFINE_SERVICE_BDFRec( class_, \ 50 | get_charset_id_, \ 51 | get_property_ ) \ 52 | static const FT_Service_BDFRec class_ = \ 53 | { \ 54 | get_charset_id_, get_property_ \ 55 | }; 56 | 57 | /* */ 58 | 59 | 60 | FT_END_HEADER 61 | 62 | 63 | #endif /* SVBDF_H_ */ 64 | 65 | 66 | /* END */ 67 | -------------------------------------------------------------------------------- /src/Utils/Hooking.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../Engine/SDK_utils.h" 4 | #include "detours.h" 5 | #include "Singleton.h" 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | namespace FN { 13 | // redefine local Function class here to exclude mutual including 14 | template 15 | class Function { 16 | public: 17 | uintptr_t OS_offset; 18 | uintptr_t CN_offset; 19 | 20 | TReturn(*Functor)(Args...); 21 | 22 | void operator +=(std::function fn) {} 23 | 24 | void Setup() {} 25 | }; 26 | } 27 | 28 | class Hooks { 29 | public: 30 | template 31 | static void Attach(TType1 original, TType2 handler) { 32 | reinterpret_cast&>(original).Setup(); 33 | 34 | DetourTransactionBegin(); 35 | DetourUpdateThread(GetCurrentThread()); 36 | DetourAttach(&(PVOID&)reinterpret_cast&>(original).Functor, handler); 37 | DetourTransactionCommit(); 38 | hooksMap[reinterpret_cast(handler)] = reinterpret_cast(reinterpret_cast&>(original).Functor); 39 | } 40 | 41 | template 42 | static void Detach(TType1 original, TType2 handler) { 43 | reinterpret_cast&>(original).Setup(); 44 | 45 | DetourTransactionBegin(); 46 | DetourUpdateThread(GetCurrentThread()); 47 | DetourDetach(&(PVOID&)reinterpret_cast&>(original).Functor, handler); 48 | DetourTransactionCommit(); 49 | hooksMap.erase(hooksMap.find(reinterpret_cast(handler))); 50 | } 51 | 52 | template 53 | static TType GetOriginal(TType handler) { 54 | return reinterpret_cast(hooksMap[reinterpret_cast(handler)]); 55 | } 56 | 57 | template 58 | static TType Call(TType(*handler)(Args...), Args... args) { 59 | auto org = GetOriginal(handler); 60 | return org(args...); 61 | } 62 | private: 63 | inline static std::map hooksMap; 64 | }; -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svgxval.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svgxval.h 4 | * 5 | * FreeType API for validating TrueTypeGX/AAT tables (specification). 6 | * 7 | * Copyright (C) 2004-2024 by 8 | * Masatake YAMATO, Red Hat K.K., 9 | * David Turner, Robert Wilhelm, and Werner Lemberg. 10 | * 11 | * This file is part of the FreeType project, and may only be used, 12 | * modified, and distributed under the terms of the FreeType project 13 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 14 | * this file you indicate that you have read the license and 15 | * understand and accept it fully. 16 | * 17 | */ 18 | 19 | /**************************************************************************** 20 | * 21 | * gxvalid is derived from both gxlayout module and otvalid module. 22 | * Development of gxlayout is supported by the Information-technology 23 | * Promotion Agency(IPA), Japan. 24 | * 25 | */ 26 | 27 | 28 | #ifndef SVGXVAL_H_ 29 | #define SVGXVAL_H_ 30 | 31 | #include 32 | #include 33 | 34 | FT_BEGIN_HEADER 35 | 36 | 37 | #define FT_SERVICE_ID_GX_VALIDATE "truetypegx-validate" 38 | #define FT_SERVICE_ID_CLASSICKERN_VALIDATE "classickern-validate" 39 | 40 | typedef FT_Error 41 | (*gxv_validate_func)( FT_Face face, 42 | FT_UInt gx_flags, 43 | FT_Bytes tables[FT_VALIDATE_GX_LENGTH], 44 | FT_UInt table_length ); 45 | 46 | 47 | typedef FT_Error 48 | (*ckern_validate_func)( FT_Face face, 49 | FT_UInt ckern_flags, 50 | FT_Bytes *ckern_table ); 51 | 52 | 53 | FT_DEFINE_SERVICE( GXvalidate ) 54 | { 55 | gxv_validate_func validate; 56 | }; 57 | 58 | FT_DEFINE_SERVICE( CKERNvalidate ) 59 | { 60 | ckern_validate_func validate; 61 | }; 62 | 63 | /* */ 64 | 65 | 66 | FT_END_HEADER 67 | 68 | 69 | #endif /* SVGXVAL_H_ */ 70 | 71 | 72 | /* END */ 73 | -------------------------------------------------------------------------------- /src/Config/ConfigManager.cpp: -------------------------------------------------------------------------------- 1 | #include "ConfigManager.h" 2 | 3 | void ConfigManager::InitConfigFilesAtPath(std::filesystem::path path) 4 | { 5 | std::map> ret; 6 | 7 | if (std::filesystem::exists(path) && std::filesystem::is_directory(path)) { 8 | int i = 0; 9 | for (auto& file : std::filesystem::directory_iterator(path)) { 10 | if (file.path().filename().string().ends_with((".json"))) { 11 | ret[i] = { file.path().filename().string(), ConfigFile(file.path().filename().string(), file.path()) }; 12 | i++; 13 | } 14 | } 15 | } 16 | 17 | this->m_ConfigFiles = ret; 18 | } 19 | 20 | std::map> ConfigManager::GetCurrentConfigFiles() 21 | { 22 | return this->m_ConfigFiles; 23 | } 24 | 25 | bool ConfigManager::CreateConfigFile(std::string filename) 26 | { 27 | if (filename == "") return false; 28 | 29 | std::filesystem::path filespath = std::string(getenv(("SystemDrive"))) + "\\"; 30 | filespath = filespath / ("Minty-GI") / ("configs"); 31 | 32 | if (!std::filesystem::is_directory(filespath) || !std::filesystem::exists(filespath)) { 33 | std::filesystem::create_directories(filespath); 34 | } 35 | 36 | auto files = this->m_ConfigFiles; 37 | 38 | for (auto& file : files) { 39 | if (file.second.first == filename) { 40 | return false; 41 | } 42 | } 43 | std::ofstream created(filespath / (filename + (".json"))); 44 | created << this->m_CurrentConfig; 45 | created.close(); 46 | 47 | return true; 48 | } 49 | 50 | nlohmann::json& ConfigManager::GetCurrentConfig() 51 | { 52 | return this->m_CurrentConfig; 53 | } 54 | 55 | void ConfigManager::ResetCurrentConfig() 56 | { 57 | this->m_CurrentConfig.clear(); 58 | } 59 | 60 | void ConfigManager::LoadConfigFile(ConfigFile file) 61 | { 62 | std::ifstream configfile(file.m_filePath); 63 | nlohmann::json configjson; 64 | configfile >> configjson; 65 | this->m_CurrentConfig = configjson; 66 | 67 | configfile.close(); 68 | } 69 | 70 | void ConfigManager::UpdateConfigFile(ConfigFile file) 71 | { 72 | std::ofstream configfile(file.m_filePath, std::ofstream::trunc); 73 | configfile << this->m_CurrentConfig; 74 | 75 | configfile.close(); 76 | } -------------------------------------------------------------------------------- /src/Functions/Player/InfinityStamina.cpp: -------------------------------------------------------------------------------- 1 | #include "InfinityStamina.h" 2 | 3 | namespace Player { 4 | void hook_HandleNormalProp(void* this_, uint32_t a1, long a2, void* a3); 5 | 6 | void hook_Wanderer_Tick(void* this_, float a1); 7 | void hook_Wanderer_SetValue(void* this_, float a1); 8 | 9 | void InfinityStamina::InitConfig() { 10 | this->b_Mavuika = Config::GetValue(this->m_Name, ("mavuika"), false); 11 | this->b_NightSoul = Config::GetValue(this->m_Name, ("nightsoul"), false); 12 | this->b_Wanderer = Config::GetValue(this->m_Name, ("wanderer"), false); 13 | } 14 | 15 | void InfinityStamina::InitHooks() { 16 | Hooks::Attach(Offsets::WandererFlightHandler::Tick, hook_Wanderer_Tick); 17 | Hooks::Attach(Offsets::WandererFlightHandler::SetValue, hook_Wanderer_SetValue); 18 | Hooks::Attach(Offsets::DataItem::HandleNormalProp, hook_HandleNormalProp) 19 | } 20 | 21 | InfinityStamina::InfinityStamina() : Feature( 22 | ("Infinite Stamina"), 23 | ("Makes your stamina infinite")) 24 | { 25 | InitConfig(); 26 | InitHooks(); 27 | } 28 | 29 | void InfinityStamina::Options() { 30 | ConfigCheckbox(("Infinite Wanderer flight"), b_Wanderer); 31 | } 32 | 33 | void InfinityStamina::Status() {} 34 | 35 | void InfinityStamina::OnUpdate() {} 36 | 37 | void InfinityStamina::ProcessHotkeys() {} 38 | 39 | void hook_HandleNormalProp(void* this_, uint32_t a1, long a2, void* a3) { 40 | auto& instance = InfinityStamina::Instance(); 41 | 42 | if (instance.m_Enabled && 43 | a1 == 10010 || 44 | a1 == 10049 || 45 | a1 == 10011 || 46 | a1 == 10050) 47 | { 48 | return; 49 | } 50 | 51 | Hooks::Call(hook_HandleNormalProp, this_, a1, a2, a3); 52 | } 53 | 54 | void hook_Wanderer_Tick(void* this_, float a1) { 55 | auto& instance = InfinityStamina::Instance(); 56 | if (instance.m_Enabled && instance.b_Wanderer) { 57 | a1 = 0.000001; 58 | } 59 | Hooks::Call(hook_Wanderer_Tick, this_, a1); 60 | } 61 | 62 | void hook_Wanderer_SetValue(void* this_, float a1) { 63 | auto& instance = InfinityStamina::Instance(); 64 | if (instance.m_Enabled && instance.b_Wanderer) { 65 | return; 66 | } 67 | Hooks::Call(hook_Wanderer_SetValue, this_, a1); 68 | } 69 | } -------------------------------------------------------------------------------- /src/GUI/Menu/Hotkey.cpp: -------------------------------------------------------------------------------- 1 | #include "Hotkey.h" 2 | 3 | bool Hotkey::IsDown() { 4 | return (this->IsUpdating || this->key.getValue() == ImGuiKey_None) ? false : ImGui::IsKeyDown(this->key.getValue()); 5 | } 6 | 7 | bool Hotkey::IsPressed() { 8 | return (this->IsUpdating || this->key.getValue() == ImGuiKey_None) ? false : ImGui::IsKeyPressed(this->key.getValue(), false); 9 | } 10 | 11 | void Hotkey::Draw(std::string text) { 12 | ImGui::PushID(this); 13 | 14 | float buttonWidth = ImGui::CalcTextSize(GetDrawText().c_str()).x; 15 | if (buttonWidth < 55.f) 16 | buttonWidth = 55.f; 17 | 18 | if (ImGui::Button(GetDrawText().c_str(), {buttonWidth, 25.f})) { 19 | this->IsUpdating = true; 20 | } 21 | ImGui::PopID(); 22 | 23 | ImGui::SameLine(); 24 | 25 | ImGui::PushID(this + 10); 26 | if (ImGui::SmallButton("x")) { 27 | this->IsUpdating = false; 28 | Config::SetValue(this->key, ImGuiKey_None); 29 | this->key.setValue(ImGuiKey_None); 30 | } 31 | ImGui::PopID(); 32 | 33 | ImGui::SameLine(); 34 | if (text == "") { 35 | ImGui::Text("Hotkey"); 36 | } 37 | else { 38 | ImGui::Text(text.c_str()); 39 | } 40 | 41 | if (this->IsUpdating) { 42 | this->UpdateKey(); 43 | } 44 | } 45 | 46 | void Hotkey::UpdateKey() { 47 | for (ImGuiKey key = ImGuiKey_NamedKey_BEGIN; key < ImGuiKey_NamedKey_END; key = (ImGuiKey)(key + 1)) { 48 | if (key == ImGuiKey_MouseLeft || 49 | key == ImGuiKey_MouseRight || 50 | key == ImGuiKey_MouseWheelY || 51 | key == ImGuiKey_MouseWheelX || 52 | key == ImGuiKey_GamepadLStickLeft || 53 | key == ImGuiKey_GamepadLStickRight || 54 | key == ImGuiKey_GamepadLStickUp || 55 | key == ImGuiKey_GamepadLStickDown || 56 | key == ImGuiKey_GamepadRStickLeft || 57 | key == ImGuiKey_GamepadRStickRight || 58 | key == ImGuiKey_GamepadRStickUp || 59 | key == ImGuiKey_GamepadRStickDown) continue; 60 | 61 | if (ImGui::IsKeyReleased(key)) { 62 | this->IsUpdating = false; 63 | Config::SetValue(this->key, key); 64 | this->key.setValue(key); 65 | } 66 | } 67 | } 68 | 69 | std::string Hotkey::GetDrawText() { 70 | if (IsUpdating) 71 | return std::string("..."); 72 | else 73 | return std::string(ImGui::GetKeyName(this->key)); 74 | } 75 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svgldict.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svgldict.h 4 | * 5 | * The FreeType glyph dictionary services (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVGLDICT_H_ 20 | #define SVGLDICT_H_ 21 | 22 | #include 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | /* 29 | * A service used to retrieve glyph names, as well as to find the index of 30 | * a given glyph name in a font. 31 | * 32 | */ 33 | 34 | #define FT_SERVICE_ID_GLYPH_DICT "glyph-dict" 35 | 36 | 37 | typedef FT_Error 38 | (*FT_GlyphDict_GetNameFunc)( FT_Face face, 39 | FT_UInt glyph_index, 40 | FT_Pointer buffer, 41 | FT_UInt buffer_max ); 42 | 43 | typedef FT_UInt 44 | (*FT_GlyphDict_NameIndexFunc)( FT_Face face, 45 | const FT_String* glyph_name ); 46 | 47 | 48 | FT_DEFINE_SERVICE( GlyphDict ) 49 | { 50 | FT_GlyphDict_GetNameFunc get_name; 51 | FT_GlyphDict_NameIndexFunc name_index; /* optional */ 52 | }; 53 | 54 | 55 | #define FT_DEFINE_SERVICE_GLYPHDICTREC( class_, \ 56 | get_name_, \ 57 | name_index_ ) \ 58 | static const FT_Service_GlyphDictRec class_ = \ 59 | { \ 60 | get_name_, name_index_ \ 61 | }; 62 | 63 | /* */ 64 | 65 | 66 | FT_END_HEADER 67 | 68 | 69 | #endif /* SVGLDICT_H_ */ 70 | 71 | 72 | /* END */ 73 | -------------------------------------------------------------------------------- /src/Functions/Player/AOEAttack.cpp: -------------------------------------------------------------------------------- 1 | #include "AOEAttack.h" 2 | 3 | namespace Player 4 | { 5 | void hook_AOE_FireBeingHit(void* this_, uint32_t attackeeId, void* res); 6 | 7 | void AOEAttack::InitConfig() 8 | { 9 | f_Range = Config::GetValue(this->m_Name, "range", 10.f); 10 | } 11 | 12 | void AOEAttack::InitHooks() 13 | { 14 | Hooks::Attach(Offsets::LCBaseCombat::FireBeingHitEvent, hook_AOE_FireBeingHit); 15 | } 16 | 17 | AOEAttack::AOEAttack() : Feature( 18 | ("AOE Attack"), 19 | ("Duplicates your attacks to all enemies in range")) 20 | { 21 | InitConfig(); 22 | InitHooks(); 23 | } 24 | 25 | void AOEAttack::Options() 26 | { 27 | ConfigSliderFloat(QENC("Attack range").c_str(), f_Range, 1.f, 100.f); 28 | } 29 | 30 | void AOEAttack::OnUpdate() {} 31 | 32 | void AOEAttack::Status() {} 33 | 34 | void AOEAttack::ProcessHotkeys() {} 35 | 36 | std::vector GetListOfEnemies() 37 | { 38 | auto& instance = AOEAttack::Instance(); 39 | std::vector result; 40 | 41 | auto entityManager = MoleMole::EntityManager::get_EntityManager(); 42 | if (entityManager == nullptr) 43 | return result; 44 | 45 | auto entityList = entityManager->entities(); 46 | if (entityList.empty()) 47 | return result; 48 | 49 | auto avatar = entityManager->avatar(); 50 | if (avatar == nullptr) 51 | return result; 52 | 53 | auto avatarPosition = avatar->getPosition(); 54 | if (avatarPosition.zero()) 55 | return result; 56 | 57 | for (auto& entity : entityList) 58 | { 59 | if (entity->type() != MoleMole::EntityType::Monster) continue; 60 | 61 | float distance = avatarPosition.distance(entity->getPosition()); 62 | if (distance <= instance.f_Range) 63 | { 64 | result.push_back(entity->runtimeId()); 65 | } 66 | } 67 | 68 | return result; 69 | } 70 | 71 | void hook_AOE_FireBeingHit(void* this_, uint32_t attackeeId, void* res) 72 | { 73 | auto& instance = AOEAttack::Instance(); 74 | 75 | if (instance.m_Enabled && attackeeId != MoleMole::EntityManager::get_EntityManager()->avatar()->runtimeId()) 76 | { 77 | auto list = GetListOfEnemies(); 78 | if (!list.empty()) 79 | { 80 | for (uint32_t id : list) 81 | { 82 | Hooks::Call(hook_AOE_FireBeingHit, this_, id, res); 83 | } 84 | } 85 | } 86 | else 87 | { 88 | Hooks::Call(hook_AOE_FireBeingHit, this_, attackeeId, res); 89 | } 90 | } 91 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svcid.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svcid.h 4 | * 5 | * The FreeType CID font services (specification). 6 | * 7 | * Copyright (C) 2007-2024 by 8 | * Derek Clegg and Michael Toftdal. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVCID_H_ 20 | #define SVCID_H_ 21 | 22 | #include 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | #define FT_SERVICE_ID_CID "CID" 29 | 30 | typedef FT_Error 31 | (*FT_CID_GetRegistryOrderingSupplementFunc)( FT_Face face, 32 | const char* *registry, 33 | const char* *ordering, 34 | FT_Int *supplement ); 35 | typedef FT_Error 36 | (*FT_CID_GetIsInternallyCIDKeyedFunc)( FT_Face face, 37 | FT_Bool *is_cid ); 38 | typedef FT_Error 39 | (*FT_CID_GetCIDFromGlyphIndexFunc)( FT_Face face, 40 | FT_UInt glyph_index, 41 | FT_UInt *cid ); 42 | 43 | FT_DEFINE_SERVICE( CID ) 44 | { 45 | FT_CID_GetRegistryOrderingSupplementFunc get_ros; 46 | FT_CID_GetIsInternallyCIDKeyedFunc get_is_cid; 47 | FT_CID_GetCIDFromGlyphIndexFunc get_cid_from_glyph_index; 48 | }; 49 | 50 | 51 | #define FT_DEFINE_SERVICE_CIDREC( class_, \ 52 | get_ros_, \ 53 | get_is_cid_, \ 54 | get_cid_from_glyph_index_ ) \ 55 | static const FT_Service_CIDRec class_ = \ 56 | { \ 57 | get_ros_, get_is_cid_, get_cid_from_glyph_index_ \ 58 | }; 59 | 60 | /* */ 61 | 62 | 63 | FT_END_HEADER 64 | 65 | 66 | #endif /* SVCID_H_ */ 67 | 68 | 69 | /* END */ 70 | -------------------------------------------------------------------------------- /src/Functions/Teleports/QuestTP.cpp: -------------------------------------------------------------------------------- 1 | #include "QuestTP.h" 2 | 3 | namespace Teleports { 4 | void hook_MonoMapMark_Update(void* this_); 5 | 6 | void QuestTP::InitConfig() 7 | { 8 | targetMark = nullptr; 9 | 10 | h_TP = Hotkey(m_Name, ("TP"), ImGuiKey_I); 11 | } 12 | 13 | void QuestTP::InitHooks() 14 | { 15 | Hooks::Attach(Offsets::MonoMapMark::Update, hook_MonoMapMark_Update); 16 | } 17 | 18 | QuestTP::QuestTP() : Feature( 19 | ("Quest TP"), 20 | ("Teleports you to active tracked quest")) 21 | { 22 | InitConfig(); 23 | InitHooks(); 24 | } 25 | 26 | void QuestTP::Options() 27 | { 28 | h_TP.Draw(("TP key")); 29 | } 30 | 31 | void QuestTP::Status() {} 32 | 33 | void QuestTP::OnUpdate() {} 34 | 35 | void QuestTP::ProcessHotkeys() 36 | { 37 | if (m_Enabled && h_TP.IsPressed()) 38 | { 39 | if (targetMark == nullptr) 40 | return; 41 | 42 | Unity::Vector3 targetPos = {}; 43 | 44 | auto mapPos = Offsets::MonoMapMark::get_levelMapPos(targetMark); 45 | auto worldPos = Offsets::Miscs::GenWorldPos(mapPos); 46 | worldPos.y = Offsets::MonoMapMark::get_height(targetMark) + 3.f; 47 | 48 | targetPos = worldPos; 49 | 50 | targetPos.x += 1; 51 | targetPos.z += 1; 52 | 53 | std::thread(TeleportBase::TeleportTo, targetPos, 0).detach(); 54 | } 55 | } 56 | 57 | void hook_MonoMapMark_Update(void* this_) 58 | { 59 | auto& instance = QuestTP::Instance(); 60 | 61 | if (instance.m_Enabled) 62 | { 63 | void* transform = Offsets::Component::get_transform(this_); 64 | if (transform != nullptr) 65 | { 66 | void* parent = Offsets::Transform::get_parent(transform); 67 | if (parent != nullptr) 68 | { 69 | void* gameObject = Offsets::Component::get_gameObject(parent); 70 | if (gameObject != nullptr) 71 | { 72 | auto name = Offsets::Object::get_name(gameObject); 73 | if (name != nullptr) 74 | { 75 | if (name->ToCString().find(("Layer3")) != std::string::npos) 76 | { 77 | void* generalMarkData = *reinterpret_cast((uintptr_t)this_ + 0x0); 78 | if (generalMarkData != nullptr) 79 | { 80 | int markType = *reinterpret_cast((uintptr_t)generalMarkData + 0x0); 81 | if (markType == 2 || markType == 10) 82 | { 83 | instance.targetMark = this_; 84 | } 85 | } 86 | } 87 | } 88 | } 89 | } 90 | } 91 | } 92 | 93 | Hooks::Call(hook_MonoMapMark_Update, this_); 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svsfnt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svsfnt.h 4 | * 5 | * The FreeType SFNT table loading service (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVSFNT_H_ 20 | #define SVSFNT_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | /* 30 | * SFNT table loading service. 31 | */ 32 | 33 | #define FT_SERVICE_ID_SFNT_TABLE "sfnt-table" 34 | 35 | 36 | /* 37 | * Used to implement FT_Load_Sfnt_Table(). 38 | */ 39 | typedef FT_Error 40 | (*FT_SFNT_TableLoadFunc)( FT_Face face, 41 | FT_ULong tag, 42 | FT_Long offset, 43 | FT_Byte* buffer, 44 | FT_ULong* length ); 45 | 46 | /* 47 | * Used to implement FT_Get_Sfnt_Table(). 48 | */ 49 | typedef void* 50 | (*FT_SFNT_TableGetFunc)( FT_Face face, 51 | FT_Sfnt_Tag tag ); 52 | 53 | 54 | /* 55 | * Used to implement FT_Sfnt_Table_Info(). 56 | */ 57 | typedef FT_Error 58 | (*FT_SFNT_TableInfoFunc)( FT_Face face, 59 | FT_UInt idx, 60 | FT_ULong *tag, 61 | FT_ULong *offset, 62 | FT_ULong *length ); 63 | 64 | 65 | FT_DEFINE_SERVICE( SFNT_Table ) 66 | { 67 | FT_SFNT_TableLoadFunc load_table; 68 | FT_SFNT_TableGetFunc get_table; 69 | FT_SFNT_TableInfoFunc table_info; 70 | }; 71 | 72 | 73 | #define FT_DEFINE_SERVICE_SFNT_TABLEREC( class_, load_, get_, info_ ) \ 74 | static const FT_Service_SFNT_TableRec class_ = \ 75 | { \ 76 | load_, get_, info_ \ 77 | }; 78 | 79 | /* */ 80 | 81 | 82 | FT_END_HEADER 83 | 84 | 85 | #endif /* SVSFNT_H_ */ 86 | 87 | 88 | /* END */ 89 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/ftfntfmt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftfntfmt.h 4 | * 5 | * Support functions for font formats. 6 | * 7 | * Copyright (C) 2002-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef FTFNTFMT_H_ 20 | #define FTFNTFMT_H_ 21 | 22 | #include 23 | 24 | #ifdef FREETYPE_H 25 | #error "freetype.h of FreeType 1 has been loaded!" 26 | #error "Please fix the directory search order for header files" 27 | #error "so that freetype.h of FreeType 2 is found first." 28 | #endif 29 | 30 | 31 | FT_BEGIN_HEADER 32 | 33 | 34 | /************************************************************************** 35 | * 36 | * @section: 37 | * font_formats 38 | * 39 | * @title: 40 | * Font Formats 41 | * 42 | * @abstract: 43 | * Getting the font format. 44 | * 45 | * @description: 46 | * The single function in this section can be used to get the font format. 47 | * Note that this information is not needed normally; however, there are 48 | * special cases (like in PDF devices) where it is important to 49 | * differentiate, in spite of FreeType's uniform API. 50 | * 51 | */ 52 | 53 | 54 | /************************************************************************** 55 | * 56 | * @function: 57 | * FT_Get_Font_Format 58 | * 59 | * @description: 60 | * Return a string describing the format of a given face. Possible values 61 | * are 'TrueType', 'Type~1', 'BDF', 'PCF', 'Type~42', 'CID~Type~1', 'CFF', 62 | * 'PFR', and 'Windows~FNT'. 63 | * 64 | * The return value is suitable to be used as an X11 FONT_PROPERTY. 65 | * 66 | * @input: 67 | * face :: 68 | * Input face handle. 69 | * 70 | * @return: 71 | * Font format string. `NULL` in case of error. 72 | * 73 | * @note: 74 | * A deprecated name for the same function is `FT_Get_X11_Font_Format`. 75 | */ 76 | FT_EXPORT( const char* ) 77 | FT_Get_Font_Format( FT_Face face ); 78 | 79 | 80 | /* deprecated */ 81 | FT_EXPORT( const char* ) 82 | FT_Get_X11_Font_Format( FT_Face face ); 83 | 84 | 85 | /* */ 86 | 87 | 88 | FT_END_HEADER 89 | 90 | #endif /* FTFNTFMT_H_ */ 91 | 92 | 93 | /* END */ 94 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/imgui_impl_dx12.h: -------------------------------------------------------------------------------- 1 | // dear imgui: Renderer Backend for DirectX12 2 | // This needs to be used along with a Platform Backend (e.g. Win32) 3 | 4 | // Implemented features: 5 | // [X] Renderer: User texture binding. Use 'D3D12_GPU_DESCRIPTOR_HANDLE' as ImTextureID. Read the FAQ about ImTextureID! 6 | // [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices. 7 | 8 | // Important: to compile on 32-bit systems, this backend requires code to be compiled with '#define ImTextureID ImU64'. 9 | // See imgui_impl_dx12.cpp file for details. 10 | 11 | // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. 12 | // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. 13 | // Learn about Dear ImGui: 14 | // - FAQ https://dearimgui.com/faq 15 | // - Getting Started https://dearimgui.com/getting-started 16 | // - Documentation https://dearimgui.com/docs (same as your local docs/ folder). 17 | // - Introduction, links and more at the top of imgui.cpp 18 | 19 | #pragma once 20 | #include "imgui.h" // IMGUI_IMPL_API 21 | #ifndef IMGUI_DISABLE 22 | #include // DXGI_FORMAT 23 | 24 | struct ID3D12Device; 25 | struct ID3D12DescriptorHeap; 26 | struct ID3D12GraphicsCommandList; 27 | struct D3D12_CPU_DESCRIPTOR_HANDLE; 28 | struct D3D12_GPU_DESCRIPTOR_HANDLE; 29 | 30 | // cmd_list is the command list that the implementation will use to render imgui draw lists. 31 | // Before calling the render function, caller must prepare cmd_list by resetting it and setting the appropriate 32 | // render target and descriptor heap that contains font_srv_cpu_desc_handle/font_srv_gpu_desc_handle. 33 | // font_srv_cpu_desc_handle and font_srv_gpu_desc_handle are handles to a single SRV descriptor to use for the internal font texture. 34 | IMGUI_IMPL_API bool ImGui_ImplDX12_Init(ID3D12Device* device, int num_frames_in_flight, DXGI_FORMAT rtv_format, ID3D12DescriptorHeap* cbv_srv_heap, 35 | D3D12_CPU_DESCRIPTOR_HANDLE font_srv_cpu_desc_handle, D3D12_GPU_DESCRIPTOR_HANDLE font_srv_gpu_desc_handle); 36 | IMGUI_IMPL_API void ImGui_ImplDX12_Shutdown(); 37 | IMGUI_IMPL_API void ImGui_ImplDX12_NewFrame(); 38 | IMGUI_IMPL_API void ImGui_ImplDX12_RenderDrawData(ImDrawData* draw_data, ID3D12GraphicsCommandList* graphics_command_list); 39 | 40 | // Use if you want to reset your rendering device without losing Dear ImGui state. 41 | IMGUI_IMPL_API void ImGui_ImplDX12_InvalidateDeviceObjects(); 42 | IMGUI_IMPL_API bool ImGui_ImplDX12_CreateDeviceObjects(); 43 | 44 | #endif // #ifndef IMGUI_DISABLE 45 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svttcmap.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svttcmap.h 4 | * 5 | * The FreeType TrueType/sfnt cmap extra information service. 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * Masatake YAMATO, Redhat K.K., 9 | * David Turner, Robert Wilhelm, and Werner Lemberg. 10 | * 11 | * This file is part of the FreeType project, and may only be used, 12 | * modified, and distributed under the terms of the FreeType project 13 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 14 | * this file you indicate that you have read the license and 15 | * understand and accept it fully. 16 | * 17 | */ 18 | 19 | /* Development of this service is support of 20 | Information-technology Promotion Agency, Japan. */ 21 | 22 | #ifndef SVTTCMAP_H_ 23 | #define SVTTCMAP_H_ 24 | 25 | #include 26 | #include 27 | 28 | 29 | FT_BEGIN_HEADER 30 | 31 | 32 | #define FT_SERVICE_ID_TT_CMAP "tt-cmaps" 33 | 34 | 35 | /************************************************************************** 36 | * 37 | * @struct: 38 | * TT_CMapInfo 39 | * 40 | * @description: 41 | * A structure used to store TrueType/sfnt specific cmap information 42 | * which is not covered by the generic @FT_CharMap structure. This 43 | * structure can be accessed with the @FT_Get_TT_CMap_Info function. 44 | * 45 | * @fields: 46 | * language :: 47 | * The language ID used in Mac fonts. Definitions of values are in 48 | * `ttnameid.h`. 49 | * 50 | * format :: 51 | * The cmap format. OpenType 1.6 defines the formats 0 (byte encoding 52 | * table), 2~(high-byte mapping through table), 4~(segment mapping to 53 | * delta values), 6~(trimmed table mapping), 8~(mixed 16-bit and 32-bit 54 | * coverage), 10~(trimmed array), 12~(segmented coverage), 13~(last 55 | * resort font), and 14 (Unicode Variation Sequences). 56 | */ 57 | typedef struct TT_CMapInfo_ 58 | { 59 | FT_ULong language; 60 | FT_Long format; 61 | 62 | } TT_CMapInfo; 63 | 64 | 65 | typedef FT_Error 66 | (*TT_CMap_Info_GetFunc)( FT_CharMap charmap, 67 | TT_CMapInfo *cmap_info ); 68 | 69 | 70 | FT_DEFINE_SERVICE( TTCMaps ) 71 | { 72 | TT_CMap_Info_GetFunc get_cmap_info; 73 | }; 74 | 75 | 76 | #define FT_DEFINE_SERVICE_TTCMAPSREC( class_, get_cmap_info_ ) \ 77 | static const FT_Service_TTCMapsRec class_ = \ 78 | { \ 79 | get_cmap_info_ \ 80 | }; 81 | 82 | /* */ 83 | 84 | 85 | FT_END_HEADER 86 | 87 | #endif /* SVTTCMAP_H_ */ 88 | 89 | 90 | /* END */ 91 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svpsinfo.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svpsinfo.h 4 | * 5 | * The FreeType PostScript info service (specification). 6 | * 7 | * Copyright (C) 2003-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPSINFO_H_ 20 | #define SVPSINFO_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_POSTSCRIPT_INFO "postscript-info" 30 | 31 | 32 | typedef FT_Error 33 | (*PS_GetFontInfoFunc)( FT_Face face, 34 | PS_FontInfoRec* afont_info ); 35 | 36 | typedef FT_Error 37 | (*PS_GetFontExtraFunc)( FT_Face face, 38 | PS_FontExtraRec* afont_extra ); 39 | 40 | typedef FT_Int 41 | (*PS_HasGlyphNamesFunc)( FT_Face face ); 42 | 43 | typedef FT_Error 44 | (*PS_GetFontPrivateFunc)( FT_Face face, 45 | PS_PrivateRec* afont_private ); 46 | 47 | typedef FT_Long 48 | (*PS_GetFontValueFunc)( FT_Face face, 49 | PS_Dict_Keys key, 50 | FT_UInt idx, 51 | void *value, 52 | FT_Long value_len ); 53 | 54 | 55 | FT_DEFINE_SERVICE( PsInfo ) 56 | { 57 | PS_GetFontInfoFunc ps_get_font_info; 58 | PS_GetFontExtraFunc ps_get_font_extra; 59 | PS_HasGlyphNamesFunc ps_has_glyph_names; 60 | PS_GetFontPrivateFunc ps_get_font_private; 61 | PS_GetFontValueFunc ps_get_font_value; 62 | }; 63 | 64 | 65 | #define FT_DEFINE_SERVICE_PSINFOREC( class_, \ 66 | get_font_info_, \ 67 | ps_get_font_extra_, \ 68 | has_glyph_names_, \ 69 | get_font_private_, \ 70 | get_font_value_ ) \ 71 | static const FT_Service_PsInfoRec class_ = \ 72 | { \ 73 | get_font_info_, ps_get_font_extra_, has_glyph_names_, \ 74 | get_font_private_, get_font_value_ \ 75 | }; 76 | 77 | /* */ 78 | 79 | 80 | FT_END_HEADER 81 | 82 | 83 | #endif /* SVPSINFO_H_ */ 84 | 85 | 86 | /* END */ 87 | -------------------------------------------------------------------------------- /src/Functions/World/Autotalk.cpp: -------------------------------------------------------------------------------- 1 | #include "Autotalk.h" 2 | 3 | namespace World { 4 | void hook_MonoInLevelCutScenePageContext_UpdateView(void* this_); 5 | void hook_MonoTypeWriter_Update(void* this_); 6 | 7 | void Autotalk::InitConfig() { 8 | b_AutoChoose = true; 9 | } 10 | 11 | void Autotalk::InitHooks() { 12 | Hooks::Attach(Offsets::InLevelCutScenePageContext::UpdateView, hook_MonoInLevelCutScenePageContext_UpdateView); 13 | Hooks::Attach(Offsets::MonoTypeWriter::Update, hook_MonoTypeWriter_Update); 14 | } 15 | 16 | Autotalk::Autotalk() : Feature( 17 | "Auto Dialogue", 18 | "Automatically goes through dialogues.") 19 | { 20 | InitConfig(); 21 | InitHooks(); 22 | } 23 | 24 | void Autotalk::Options() { 25 | ImGui::Checkbox("Automatically choose reply", &b_AutoChoose); 26 | } 27 | 28 | void Autotalk::Status() {} 29 | 30 | void Autotalk::OnUpdate() {} 31 | 32 | void Autotalk::ProcessHotkeys() {} 33 | 34 | void hook_MonoInLevelCutScenePageContext_UpdateView(void* this_) 35 | { 36 | auto& instance = Autotalk::Instance(); 37 | 38 | void* talkDialogContext = *reinterpret_cast((uintptr_t)this_ + 0x0); 39 | if (talkDialogContext != nullptr) 40 | { 41 | float* protectTime = reinterpret_cast((uintptr_t)talkDialogContext + 0x0); 42 | if (Autotalk::Instance().m_Enabled) 43 | *protectTime = 0.0f; 44 | else 45 | *protectTime = 0.4f; 46 | 47 | void* onFreeClick = *reinterpret_cast((uintptr_t)talkDialogContext + 0x0); 48 | if (onFreeClick != nullptr && instance.m_Enabled) 49 | { 50 | Offsets::Action::Invoke(onFreeClick); 51 | } 52 | 53 | if (instance.b_AutoChoose && instance.m_Enabled) 54 | { 55 | void* monoTalkDialog = *reinterpret_cast((uintptr_t)talkDialogContext + 0x0); 56 | if (monoTalkDialog != nullptr) 57 | { 58 | void* monoselectgrp = *reinterpret_cast((uintptr_t)monoTalkDialog + 0x0); 59 | if (monoselectgrp != nullptr) 60 | { 61 | void* monoReusableList = *reinterpret_cast((uintptr_t)monoselectgrp + 0x0); 62 | if (monoReusableList != nullptr) 63 | { 64 | void* item = Offsets::MonoReusableList::get_item(monoReusableList, 0); 65 | if (item != nullptr) 66 | { 67 | Offsets::MonoSelectItem::OnSelectItem(item); 68 | } 69 | } 70 | } 71 | } 72 | } 73 | } 74 | 75 | return Hooks::Call(hook_MonoInLevelCutScenePageContext_UpdateView, this_); 76 | } 77 | 78 | void hook_MonoTypeWriter_Update(void* this_) 79 | { 80 | auto& instance = Autotalk::Instance(); 81 | float* _secondPerChar = reinterpret_cast((uintptr_t)this_ + 0x0); 82 | 83 | if (instance.m_Enabled) 84 | { 85 | *_secondPerChar = 0.000001f; 86 | } 87 | else 88 | { 89 | *_secondPerChar = 0.03f; 90 | } 91 | 92 | return Hooks::Call(hook_MonoTypeWriter_Update, this_); 93 | } 94 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/cffotypes.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * cffotypes.h 4 | * 5 | * Basic OpenType/CFF object type definitions (specification). 6 | * 7 | * Copyright (C) 2017-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef CFFOTYPES_H_ 20 | #define CFFOTYPES_H_ 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | 28 | 29 | FT_BEGIN_HEADER 30 | 31 | 32 | typedef TT_Face CFF_Face; 33 | 34 | 35 | /************************************************************************** 36 | * 37 | * @type: 38 | * CFF_Size 39 | * 40 | * @description: 41 | * A handle to an OpenType size object. 42 | */ 43 | typedef struct CFF_SizeRec_ 44 | { 45 | FT_SizeRec root; 46 | FT_ULong strike_index; /* 0xFFFFFFFF to indicate invalid */ 47 | 48 | } CFF_SizeRec, *CFF_Size; 49 | 50 | 51 | /************************************************************************** 52 | * 53 | * @type: 54 | * CFF_GlyphSlot 55 | * 56 | * @description: 57 | * A handle to an OpenType glyph slot object. 58 | */ 59 | typedef struct CFF_GlyphSlotRec_ 60 | { 61 | FT_GlyphSlotRec root; 62 | 63 | FT_Bool hint; 64 | FT_Bool scaled; 65 | 66 | FT_Fixed x_scale; 67 | FT_Fixed y_scale; 68 | 69 | } CFF_GlyphSlotRec, *CFF_GlyphSlot; 70 | 71 | 72 | /************************************************************************** 73 | * 74 | * @type: 75 | * CFF_Internal 76 | * 77 | * @description: 78 | * The interface to the 'internal' field of `FT_Size`. 79 | */ 80 | typedef struct CFF_InternalRec_ 81 | { 82 | PSH_Globals topfont; 83 | PSH_Globals subfonts[CFF_MAX_CID_FONTS]; 84 | 85 | } CFF_InternalRec, *CFF_Internal; 86 | 87 | 88 | /************************************************************************** 89 | * 90 | * Subglyph transformation record. 91 | */ 92 | typedef struct CFF_Transform_ 93 | { 94 | FT_Fixed xx, xy; /* transformation matrix coefficients */ 95 | FT_Fixed yx, yy; 96 | FT_F26Dot6 ox, oy; /* offsets */ 97 | 98 | } CFF_Transform; 99 | 100 | 101 | FT_END_HEADER 102 | 103 | 104 | #endif /* CFFOTYPES_H_ */ 105 | 106 | 107 | /* END */ 108 | -------------------------------------------------------------------------------- /src/Functions/Visuals/FakeTime.cpp: -------------------------------------------------------------------------------- 1 | #include "FakeTime.h" 2 | 3 | namespace Visuals { 4 | void hook_FakeTime_OnUpdate(void* this_); 5 | 6 | void FakeTime::InitConfig() 7 | { 8 | i_Hours = Config::GetValue(this->m_Name, "hours", 12); 9 | i_Minutes = Config::GetValue(this->m_Name, "minutes", 00); 10 | } 11 | 12 | void FakeTime::InitHooks() { 13 | Hooks::Attach(Offsets::GameManager::Update, hook_FakeTime_OnUpdate); 14 | } 15 | 16 | FakeTime::FakeTime() : Feature( 17 | "Fake Time", 18 | "Changes time of the day") 19 | { 20 | InitConfig(); 21 | InitHooks(); 22 | } 23 | 24 | void FakeTime::Options() 25 | { 26 | ConfigSliderInt("Hours", i_Hours, 0, 24); 27 | ConfigSliderInt("Minutes", i_Minutes, 0, 60); 28 | 29 | if (ImGui::Button("Set to system time")) 30 | { 31 | SYSTEMTIME st; 32 | GetLocalTime(&st); 33 | 34 | i_Hours.setValue(st.wHour); 35 | Config::SetValue(i_Hours, i_Hours.getValue()); 36 | 37 | i_Minutes.setValue(st.wMinute); 38 | Config::SetValue(i_Minutes, i_Minutes.getValue()); 39 | } 40 | 41 | ImGui::SeparatorText("Presets"); 42 | 43 | if (ImGui::Button("Morning (06:00)")) 44 | { 45 | i_Hours.setValue(6); 46 | Config::SetValue(i_Hours, i_Hours.getValue()); 47 | 48 | i_Minutes.setValue(0); 49 | Config::SetValue(i_Minutes, i_Minutes.getValue()); 50 | } ImGui::SameLine(); 51 | 52 | if (ImGui::Button("Noon (12:00)")) 53 | { 54 | i_Hours.setValue(12); 55 | Config::SetValue(i_Hours, i_Hours.getValue()); 56 | 57 | i_Minutes.setValue(0); 58 | Config::SetValue(i_Minutes, i_Minutes.getValue()); 59 | } ImGui::SameLine(); 60 | 61 | if (ImGui::Button("Evening (18:00)")) 62 | { 63 | i_Hours.setValue(18); 64 | Config::SetValue(i_Hours, i_Hours.getValue()); 65 | 66 | i_Minutes.setValue(0); 67 | Config::SetValue(i_Minutes, i_Minutes.getValue()); 68 | } ImGui::SameLine(); 69 | 70 | if (ImGui::Button("Midnight (24:00)")) 71 | { 72 | i_Hours.setValue(24); 73 | Config::SetValue(i_Hours, i_Hours.getValue()); 74 | 75 | i_Minutes.setValue(0); 76 | Config::SetValue(i_Minutes, i_Minutes.getValue()); 77 | } 78 | } 79 | 80 | void FakeTime::Status() {} 81 | 82 | void FakeTime::OnUpdate() {} 83 | 84 | void FakeTime::ProcessHotkeys() {} 85 | 86 | void hook_FakeTime_OnUpdate(void* this_) 87 | { 88 | auto& instance = FakeTime::Instance(); 89 | 90 | if (instance.m_Enabled) 91 | { 92 | auto mgr = Offsets::SingletonManager::get_Instance(); 93 | if (mgr) 94 | { 95 | auto timeManager = Offsets::SingletonManager::GetSingletonInstance(mgr, Unity::String::FromCString("<...>")); 96 | if (timeManager) 97 | { 98 | float convertedTime = (float)instance.i_Hours + ((float)instance.i_Minutes / 60.f); 99 | Offsets::LevelTimeManager::SetInternalTimeOfDay(timeManager, convertedTime, false, true, false); 100 | } 101 | } 102 | } 103 | 104 | Hooks::Call(hook_FakeTime_OnUpdate, this_); 105 | } 106 | } -------------------------------------------------------------------------------- /src/Functions/Visuals/GraphicsChanger.cpp: -------------------------------------------------------------------------------- 1 | #include "GraphicsChanger.h" 2 | 3 | namespace Visuals { 4 | void hook_PostProcessLayer_Update(void* this_); 5 | 6 | void GraphicsChanger::InitConfig() { 7 | b_Gamma = Config::GetValue(this->m_Name, "gamma", false); 8 | f_GammaValue = Config::GetValue(this->m_Name, "gammaVal", 2.5f); 9 | 10 | b_Outline = Config::GetValue(this->m_Name, "outline", false); 11 | f_OutlineValue = Config::GetValue(this->m_Name, "outlineVal", 0.f); 12 | 13 | b_ResolutionScale = Config::GetValue(this->m_Name, "renderScale", false); 14 | f_ResolutionScaleValue = Config::GetValue(this->m_Name, "renderScaleVal", 0.5f); 15 | } 16 | 17 | void GraphicsChanger::InitHooks() { 18 | Hooks::Attach(Offsets::PostProcessLayer::Update, hook_PostProcessLayer_Update); 19 | } 20 | 21 | GraphicsChanger::GraphicsChanger() : Feature( 22 | "Graphics changer", 23 | "Changes some graphics settings") 24 | { 25 | InitConfig(); 26 | InitHooks(); 27 | } 28 | 29 | void GraphicsChanger::Options() { 30 | ConfigCheckbox("##Gamma", b_Gamma); ImGui::SameLine(); ConfigSliderFloat("Gamma", f_GammaValue, 0.f, 5.f); 31 | ConfigCheckbox("##Outline", b_Outline); ImGui::SameLine(); ConfigSliderFloat("Outline width", f_OutlineValue, 0.f, 5.f); 32 | ConfigCheckbox("##Resolution", b_ResolutionScale); ImGui::SameLine(); ConfigSliderFloat("Resolution scale", f_ResolutionScaleValue, 0.f, 3.f); 33 | if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNone)) { 34 | ImGui::BeginItemTooltip(); 35 | ImGui::SetTooltip("Be careful! Values above 2.0 might crash your game on low-end PCs. Open and close game map to apply."); 36 | ImGui::EndTooltip(); 37 | } 38 | 39 | if (ImGui::Button("Reset")) { 40 | f_GammaValue.setValue(2.0f); Config::SetValue(f_GammaValue, 2.0f); 41 | f_OutlineValue.setValue(1.0f); Config::SetValue(f_OutlineValue, 1.0f); 42 | f_ResolutionScaleValue.setValue(1.0f); Config::SetValue(f_ResolutionScaleValue, 1.0f); 43 | } 44 | } 45 | 46 | void GraphicsChanger::Status() {} 47 | 48 | void GraphicsChanger::OnUpdate() {} 49 | 50 | void GraphicsChanger::ProcessHotkeys() {} 51 | 52 | void hook_PostProcessLayer_Update(void* this_) { 53 | auto& instance = GraphicsChanger::Instance(); 54 | 55 | if (instance.b_Gamma) { 56 | *reinterpret_cast((uintptr_t)this_ + Offsets::PostProcessLayer::Offsets::_gammaValue) = instance.f_GammaValue; 57 | *reinterpret_cast((uintptr_t)this_ + Offsets::PostProcessLayer::Offsets::_gammaValueChanged) = true; 58 | } 59 | 60 | if (instance.b_Outline) { 61 | *reinterpret_cast((uintptr_t)this_ + Offsets::PostProcessLayer::Offsets::outlineCorrectionWidth) = instance.f_OutlineValue; 62 | *reinterpret_cast((uintptr_t)this_ + Offsets::PostProcessLayer::Offsets::cameraBufferDirty) = true; 63 | } 64 | 65 | if (instance.b_ResolutionScale) { 66 | *reinterpret_cast((uintptr_t)this_ + Offsets::PostProcessLayer::Offsets::m_InnerResolutionScale) = instance.f_ResolutionScaleValue; 67 | *reinterpret_cast((uintptr_t)this_ + Offsets::PostProcessLayer::Offsets::cameraBufferDirty) = true; 68 | } 69 | 70 | Hooks::Call(hook_PostProcessLayer_Update, this_); 71 | } 72 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/ftbbox.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftbbox.h 4 | * 5 | * FreeType exact bbox computation (specification). 6 | * 7 | * Copyright (C) 1996-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | /************************************************************************** 20 | * 21 | * This component has a _single_ role: to compute exact outline bounding 22 | * boxes. 23 | * 24 | * It is separated from the rest of the engine for various technical 25 | * reasons. It may well be integrated in 'ftoutln' later. 26 | * 27 | */ 28 | 29 | 30 | #ifndef FTBBOX_H_ 31 | #define FTBBOX_H_ 32 | 33 | 34 | #include 35 | 36 | #ifdef FREETYPE_H 37 | #error "freetype.h of FreeType 1 has been loaded!" 38 | #error "Please fix the directory search order for header files" 39 | #error "so that freetype.h of FreeType 2 is found first." 40 | #endif 41 | 42 | 43 | FT_BEGIN_HEADER 44 | 45 | 46 | /************************************************************************** 47 | * 48 | * @section: 49 | * outline_processing 50 | * 51 | */ 52 | 53 | 54 | /************************************************************************** 55 | * 56 | * @function: 57 | * FT_Outline_Get_BBox 58 | * 59 | * @description: 60 | * Compute the exact bounding box of an outline. This is slower than 61 | * computing the control box. However, it uses an advanced algorithm 62 | * that returns _very_ quickly when the two boxes coincide. Otherwise, 63 | * the outline Bezier arcs are traversed to extract their extrema. 64 | * 65 | * @input: 66 | * outline :: 67 | * A pointer to the source outline. 68 | * 69 | * @output: 70 | * abbox :: 71 | * The outline's exact bounding box. 72 | * 73 | * @return: 74 | * FreeType error code. 0~means success. 75 | * 76 | * @note: 77 | * If the font is tricky and the glyph has been loaded with 78 | * @FT_LOAD_NO_SCALE, the resulting BBox is meaningless. To get 79 | * reasonable values for the BBox it is necessary to load the glyph at a 80 | * large ppem value (so that the hinting instructions can properly shift 81 | * and scale the subglyphs), then extracting the BBox, which can be 82 | * eventually converted back to font units. 83 | */ 84 | FT_EXPORT( FT_Error ) 85 | FT_Outline_Get_BBox( FT_Outline* outline, 86 | FT_BBox *abbox ); 87 | 88 | /* */ 89 | 90 | 91 | FT_END_HEADER 92 | 93 | #endif /* FTBBOX_H_ */ 94 | 95 | 96 | /* END */ 97 | 98 | 99 | /* Local Variables: */ 100 | /* coding: utf-8 */ 101 | /* End: */ 102 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/services/svcfftl.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svcfftl.h 4 | * 5 | * The FreeType CFF tables loader service (specification). 6 | * 7 | * Copyright (C) 2017-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVCFFTL_H_ 20 | #define SVCFFTL_H_ 21 | 22 | #include 23 | #include 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_CFF_LOAD "cff-load" 30 | 31 | 32 | typedef FT_UShort 33 | (*FT_Get_Standard_Encoding_Func)( FT_UInt charcode ); 34 | 35 | typedef FT_Error 36 | (*FT_Load_Private_Dict_Func)( CFF_Font font, 37 | CFF_SubFont subfont, 38 | FT_UInt lenNDV, 39 | FT_Fixed* NDV ); 40 | 41 | typedef FT_Byte 42 | (*FT_FD_Select_Get_Func)( CFF_FDSelect fdselect, 43 | FT_UInt glyph_index ); 44 | 45 | typedef FT_Bool 46 | (*FT_Blend_Check_Vector_Func)( CFF_Blend blend, 47 | FT_UInt vsindex, 48 | FT_UInt lenNDV, 49 | FT_Fixed* NDV ); 50 | 51 | typedef FT_Error 52 | (*FT_Blend_Build_Vector_Func)( CFF_Blend blend, 53 | FT_UInt vsindex, 54 | FT_UInt lenNDV, 55 | FT_Fixed* NDV ); 56 | 57 | 58 | FT_DEFINE_SERVICE( CFFLoad ) 59 | { 60 | FT_Get_Standard_Encoding_Func get_standard_encoding; 61 | FT_Load_Private_Dict_Func load_private_dict; 62 | FT_FD_Select_Get_Func fd_select_get; 63 | FT_Blend_Check_Vector_Func blend_check_vector; 64 | FT_Blend_Build_Vector_Func blend_build_vector; 65 | }; 66 | 67 | 68 | #define FT_DEFINE_SERVICE_CFFLOADREC( class_, \ 69 | get_standard_encoding_, \ 70 | load_private_dict_, \ 71 | fd_select_get_, \ 72 | blend_check_vector_, \ 73 | blend_build_vector_ ) \ 74 | static const FT_Service_CFFLoadRec class_ = \ 75 | { \ 76 | get_standard_encoding_, \ 77 | load_private_dict_, \ 78 | fd_select_get_, \ 79 | blend_check_vector_, \ 80 | blend_build_vector_ \ 81 | }; 82 | 83 | 84 | FT_END_HEADER 85 | 86 | 87 | #endif 88 | 89 | 90 | /* END */ 91 | -------------------------------------------------------------------------------- /src/Functions/Teleports/ChestTP.cpp: -------------------------------------------------------------------------------- 1 | #include "ChestTP.h" 2 | 3 | namespace Teleports { 4 | void OnUpdate_ChestTP(); 5 | 6 | void ChestTP::InitConfig() 7 | { 8 | h_TP = Hotkey(m_Name, ("TP"), ImGuiKey_Y); 9 | } 10 | 11 | void ChestTP::InitHooks() { 12 | Distance = 0; 13 | ClosestEntity = nullptr; 14 | } 15 | 16 | ChestTP::ChestTP() : Feature( 17 | ("Chest TP"), 18 | ("Teleports you to closest closed chest")) 19 | { 20 | InitConfig(); 21 | InitHooks(); 22 | } 23 | 24 | void ChestTP::Options() 25 | { 26 | h_TP.Draw(("TP key")); 27 | } 28 | 29 | void ChestTP::Status() {} 30 | 31 | void ChestTP::OnUpdate() 32 | { 33 | if (!m_Enabled) 34 | return; 35 | 36 | ImGui::SetNextWindowPos({ 300, 100 }, ImGuiCond_FirstUseEver); 37 | ImGui::Begin(("##TP"), nullptr, ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar); 38 | ImGui::Text((" TP Status:")); 39 | ImGui::Separator(); 40 | ImGui::Text(("Chest TP: %s"), ClosestEntity == nullptr ? "Not found" : std::string(std::to_string(Distance) + "m").c_str()); 41 | ImGui::End(); 42 | } 43 | 44 | void ChestTP::ProcessHotkeys() 45 | { 46 | if (m_Enabled && h_TP.IsPressed()) 47 | { 48 | if (ClosestEntity == nullptr) 49 | return; 50 | 51 | auto pos = ClosestEntity->getPosition(); 52 | if (pos.zero()) 53 | return; 54 | 55 | pos.x += 1; 56 | pos.z += 1; 57 | 58 | std::thread(TeleportBase::TeleportTo, pos, 0).detach(); 59 | } 60 | } 61 | 62 | void OnUpdate_ChestTP() { 63 | auto& instance = ChestTP::Instance(); 64 | 65 | if (!instance.m_Enabled) 66 | return; 67 | 68 | if (!MoleMole::LoadingManager::get_LoadingManager()->IsLoaded()) return; 69 | 70 | auto manager = MoleMole::EntityManager::get_EntityManager(); 71 | if (manager == nullptr) return; 72 | 73 | auto avatar = manager->avatar(); 74 | if (avatar == nullptr) return; 75 | 76 | auto avatarPos = avatar->getPosition(); 77 | 78 | auto entities = manager->entities(); 79 | 80 | if (instance.cachedSize != entities.size()) 81 | { 82 | //printf(("[ChestTP] cache is wrong! recaching...\n")); 83 | 84 | instance.cachedSize = entities.size(); 85 | instance.cachedEntities.clear(); 86 | 87 | for (auto entity : entities) 88 | { 89 | if (entity == nullptr) continue; 90 | if (entity->name().find(("TreasureBox")) == std::string::npos) continue; 91 | 92 | instance.cachedEntities.push_back(entity); 93 | } 94 | 95 | if (instance.cachedEntities.empty()) 96 | { 97 | instance.Distance = 0; 98 | instance.ClosestEntity = nullptr; 99 | } 100 | 101 | //printf(("[ChestTP] recaching done!\n")); 102 | } 103 | 104 | for (auto& entity : instance.cachedEntities) 105 | { 106 | float distance = avatarPos.distance(entity->getPosition()); 107 | instance.chestMap[distance] = entity; 108 | } 109 | 110 | if (!instance.chestMap.empty()) 111 | { 112 | instance.Distance = instance.chestMap.begin()->first; 113 | instance.ClosestEntity = instance.chestMap.begin()->second; 114 | } 115 | 116 | instance.chestMap.clear(); 117 | } 118 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/ftlzw.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftlzw.h 4 | * 5 | * LZW-compressed stream support. 6 | * 7 | * Copyright (C) 2004-2024 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef FTLZW_H_ 20 | #define FTLZW_H_ 21 | 22 | #include 23 | 24 | #ifdef FREETYPE_H 25 | #error "freetype.h of FreeType 1 has been loaded!" 26 | #error "Please fix the directory search order for header files" 27 | #error "so that freetype.h of FreeType 2 is found first." 28 | #endif 29 | 30 | 31 | FT_BEGIN_HEADER 32 | 33 | /************************************************************************** 34 | * 35 | * @section: 36 | * lzw 37 | * 38 | * @title: 39 | * LZW Streams 40 | * 41 | * @abstract: 42 | * Using LZW-compressed font files. 43 | * 44 | * @description: 45 | * In certain builds of the library, LZW compression recognition is 46 | * automatically handled when calling @FT_New_Face or @FT_Open_Face. 47 | * This means that if no font driver is capable of handling the raw 48 | * compressed file, the library will try to open a LZW stream from it and 49 | * re-open the face with it. 50 | * 51 | * The stream implementation is very basic and resets the decompression 52 | * process each time seeking backwards is needed within the stream, 53 | * which significantly undermines the performance. 54 | * 55 | * This section contains the declaration of LZW-specific functions. 56 | * 57 | */ 58 | 59 | /************************************************************************** 60 | * 61 | * @function: 62 | * FT_Stream_OpenLZW 63 | * 64 | * @description: 65 | * Open a new stream to parse LZW-compressed font files. This is mainly 66 | * used to support the compressed `*.pcf.Z` fonts that come with XFree86. 67 | * 68 | * @input: 69 | * stream :: 70 | * The target embedding stream. 71 | * 72 | * source :: 73 | * The source stream. 74 | * 75 | * @return: 76 | * FreeType error code. 0~means success. 77 | * 78 | * @note: 79 | * The source stream must be opened _before_ calling this function. 80 | * 81 | * Calling the internal function `FT_Stream_Close` on the new stream will 82 | * **not** call `FT_Stream_Close` on the source stream. None of the 83 | * stream objects will be released to the heap. 84 | * 85 | * This function may return `FT_Err_Unimplemented_Feature` if your build 86 | * of FreeType was not compiled with LZW support. 87 | */ 88 | FT_EXPORT( FT_Error ) 89 | FT_Stream_OpenLZW( FT_Stream stream, 90 | FT_Stream source ); 91 | 92 | /* */ 93 | 94 | 95 | FT_END_HEADER 96 | 97 | #endif /* FTLZW_H_ */ 98 | 99 | 100 | /* END */ 101 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/ftbzip2.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftbzip2.h 4 | * 5 | * Bzip2-compressed stream support. 6 | * 7 | * Copyright (C) 2010-2024 by 8 | * Joel Klinghed. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef FTBZIP2_H_ 20 | #define FTBZIP2_H_ 21 | 22 | #include 23 | 24 | #ifdef FREETYPE_H 25 | #error "freetype.h of FreeType 1 has been loaded!" 26 | #error "Please fix the directory search order for header files" 27 | #error "so that freetype.h of FreeType 2 is found first." 28 | #endif 29 | 30 | 31 | FT_BEGIN_HEADER 32 | 33 | /************************************************************************** 34 | * 35 | * @section: 36 | * bzip2 37 | * 38 | * @title: 39 | * BZIP2 Streams 40 | * 41 | * @abstract: 42 | * Using bzip2-compressed font files. 43 | * 44 | * @description: 45 | * In certain builds of the library, bzip2 compression recognition is 46 | * automatically handled when calling @FT_New_Face or @FT_Open_Face. 47 | * This means that if no font driver is capable of handling the raw 48 | * compressed file, the library will try to open a bzip2 compressed 49 | * stream from it and re-open the face with it. 50 | * 51 | * The stream implementation is very basic and resets the decompression 52 | * process each time seeking backwards is needed within the stream, 53 | * which significantly undermines the performance. 54 | * 55 | * This section contains the declaration of Bzip2-specific functions. 56 | * 57 | */ 58 | 59 | 60 | /************************************************************************** 61 | * 62 | * @function: 63 | * FT_Stream_OpenBzip2 64 | * 65 | * @description: 66 | * Open a new stream to parse bzip2-compressed font files. This is 67 | * mainly used to support the compressed `*.pcf.bz2` fonts that come with 68 | * XFree86. 69 | * 70 | * @input: 71 | * stream :: 72 | * The target embedding stream. 73 | * 74 | * source :: 75 | * The source stream. 76 | * 77 | * @return: 78 | * FreeType error code. 0~means success. 79 | * 80 | * @note: 81 | * The source stream must be opened _before_ calling this function. 82 | * 83 | * Calling the internal function `FT_Stream_Close` on the new stream will 84 | * **not** call `FT_Stream_Close` on the source stream. None of the 85 | * stream objects will be released to the heap. 86 | * 87 | * This function may return `FT_Err_Unimplemented_Feature` if your build 88 | * of FreeType was not compiled with bzip2 support. 89 | */ 90 | FT_EXPORT( FT_Error ) 91 | FT_Stream_OpenBzip2( FT_Stream stream, 92 | FT_Stream source ); 93 | 94 | /* */ 95 | 96 | 97 | FT_END_HEADER 98 | 99 | #endif /* FTBZIP2_H_ */ 100 | 101 | 102 | /* END */ 103 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/ftmmtypes.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftmmtypes.h 4 | * 5 | * OpenType Variations type definitions for internal use 6 | * with the multi-masters service (specification). 7 | * 8 | * Copyright (C) 2022-2024 by 9 | * David Turner, Robert Wilhelm, Werner Lemberg, George Williams, and 10 | * Dominik Röttsches. 11 | * 12 | * This file is part of the FreeType project, and may only be used, 13 | * modified, and distributed under the terms of the FreeType project 14 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 15 | * this file you indicate that you have read the license and 16 | * understand and accept it fully. 17 | * 18 | */ 19 | 20 | 21 | #ifndef FTMMTYPES_H_ 22 | #define FTMMTYPES_H_ 23 | 24 | FT_BEGIN_HEADER 25 | 26 | 27 | typedef FT_Int32 FT_ItemVarDelta; 28 | 29 | typedef struct GX_ItemVarDataRec_ 30 | { 31 | FT_UInt itemCount; /* Number of delta sets per item. */ 32 | FT_UInt regionIdxCount; /* Number of region indices. */ 33 | FT_UInt* regionIndices; /* Array of `regionCount` indices; */ 34 | /* these index `varRegionList`. */ 35 | FT_Byte* deltaSet; /* Array of `itemCount` deltas; */ 36 | /* use `innerIndex` for this array. */ 37 | FT_UShort wordDeltaCount; /* Number of the first 32-bit ints */ 38 | /* or 16-bit ints of `deltaSet` */ 39 | /* depending on `longWords`. */ 40 | FT_Bool longWords; /* If true, `deltaSet` is a 32-bit */ 41 | /* array followed by a 16-bit */ 42 | /* array, otherwise a 16-bit array */ 43 | /* followed by an 8-bit array. */ 44 | } GX_ItemVarDataRec, *GX_ItemVarData; 45 | 46 | 47 | /* contribution of one axis to a region */ 48 | typedef struct GX_AxisCoordsRec_ 49 | { 50 | FT_Fixed startCoord; 51 | FT_Fixed peakCoord; /* zero means no effect (factor = 1) */ 52 | FT_Fixed endCoord; 53 | 54 | } GX_AxisCoordsRec, *GX_AxisCoords; 55 | 56 | 57 | typedef struct GX_VarRegionRec_ 58 | { 59 | GX_AxisCoords axisList; /* array of axisCount records */ 60 | 61 | } GX_VarRegionRec, *GX_VarRegion; 62 | 63 | 64 | /* item variation store */ 65 | typedef struct GX_ItemVarStoreRec_ 66 | { 67 | FT_UInt dataCount; 68 | GX_ItemVarData varData; /* array of dataCount records; */ 69 | /* use `outerIndex' for this array */ 70 | FT_UShort axisCount; 71 | FT_UInt regionCount; /* total number of regions defined */ 72 | GX_VarRegion varRegionList; 73 | 74 | } GX_ItemVarStoreRec, *GX_ItemVarStore; 75 | 76 | 77 | typedef struct GX_DeltaSetIdxMapRec_ 78 | { 79 | FT_ULong mapCount; 80 | FT_UInt* outerIndex; /* indices to item var data */ 81 | FT_UInt* innerIndex; /* indices to delta set */ 82 | 83 | } GX_DeltaSetIdxMapRec, *GX_DeltaSetIdxMap; 84 | 85 | 86 | FT_END_HEADER 87 | 88 | #endif /* FTMMTYPES_H_ */ 89 | 90 | 91 | /* END */ 92 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # What? 2 | This is the source code of the Minty-GI! 3 | We decided to leak it cause of Minty-GI getting discontinued, due to various AC updates. 4 | 5 | # How to use it? 6 | It's NOT compilable out-of-box. Lot of things (bypasses, encryption, few functions, all the offsets) were removed. 7 | This source code is not meant for people to just rename the project and sell as their own. 8 | Think of it as a manual, something that can help you learning to make your own projects. 9 | 10 | # How to use the code base properly? 11 | We've tried to make the code base as user-friendly as possible. 12 | It's object-oriented, written in modern C++, without many dependencies. 13 | Here's how you can use it: 14 | 15 | \- **Bootstrap**\ 16 | --| dllmain.cpp // entry point of the application, starting all the required threads\ 17 | --| threads.cpp // define main threads here 18 | 19 | \- **Bypass**\ 20 | --| bypass.cpp // Maybe something was here.. 21 | 22 | \- **Config**\ 23 | --| ConfigManager.cpp // Here is the config manager. It saves\loads all the settings to\from chosen config file. Many config files can be created 24 | 25 | \- **Engine**\ 26 | --| SDK.cpp // Here starts the interesting part. You can define here any complex engine functions, e.g. "Entity::GetName()"\ 27 | --| SDK_offsets.h // Define all the functors with their offsets here. In this code, every offset is replaced with 0x0, which was stated above.\ 28 | --| SDK_types.h // Define some game structs or enums here\ 29 | --| SDK_utils.h // Defines all the classes and macro required for the SDK 30 | 31 | \- **Frameworks**\ 32 | --| ... // Contains project dependencies, like Dear ImGui 33 | 34 | \- **Functions**\ 35 | --| ... // Contains all the functions, separated into categories\ 36 | --| Feature.h // "Feature" class\ 37 | --| FeatureManager.h // Code for managing modules and their features 38 | 39 | \- **GUI**\ 40 | --| DirectX\ 41 | ----| DirectXHook.cpp // Code to initialize DX11 hook\ 42 | --| Menu\ 43 | ----| Hotkey.cpp // "Hotkey" class\ 44 | ----| InitGUI.cpp // Some menu initialization code - fonts, images, themes, ...\ 45 | ----| MainGUI.cpp // Menu layout code 46 | 47 | \- **Resources**\ 48 | --| ... // Put all the images and fonts here 49 | 50 | \- **Utils**\ 51 | --| ... // Some miscellaneous stuff 52 | 53 | # "Feature" class 54 | It holds all the info about every single feature. 55 | ``` 56 | std::string m_Name; // Function name, appears in menu and config files 57 | std::string m_Description; // Function description, appears in menu 58 | 59 | Hotkey h_Enable; // Hotkey that toggles the function 60 | 61 | ConfigField m_Enabled; // Config field, thats holds "enabled" var of the function 62 | 63 | virtual void Options() {}; // ImGui code that is used in function settings 64 | virtual void Status() {}; // Mostly unused. Put some text here, to display in "Active functions" window 65 | virtual void OnUpdate() {}; // Code that gets called every frame 66 | virtual void ProcessHotkeys() {}; // Stuff like "if (hotkey.IsPressed) {...}". Also gets called every frame, but separated to make code cleaner 67 | 68 | virtual void InitConfig() {}; // Gets called when program starts, and when you load a config. Init some function variables here 69 | virtual void InitHooks() {}; // Gets called when program starts. Init your hooks here 70 | 71 | Feature(const char* name, const char* description); // Just a ctor, that inits variables. 72 | ``` 73 | -------------------------------------------------------------------------------- /src/Functions/World/KillAura.cpp: -------------------------------------------------------------------------------- 1 | #include "KillAura.h" 2 | 3 | namespace World 4 | { 5 | void hook_VCAnimatorMove_LateTick(void* this_, float tick); 6 | void hook_RequestSceneEntityMoveReq(void* this_, uint32_t entityId, MoleMole::MotionInfo* motionInfo, bool a1, uint32_t a2, uint32_t a3); 7 | 8 | extern void DrawVisualRange(float range); 9 | 10 | void KillAura::InitConfig() { 11 | f_Range = Config::GetValue(this->m_Name, "range", 5.f); 12 | i_Type.setValue(1); 13 | } 14 | 15 | void KillAura::InitHooks() { 16 | Hooks::Attach(Offsets::LevelSyncCombatPlugin::RequestSceneEntityMoveReq, hook_RequestSceneEntityMoveReq); 17 | Hooks::Attach(Offsets::VCAnimatorMove::LateTick, hook_VCAnimatorMove_LateTick); 18 | } 19 | 20 | KillAura::KillAura() : Feature( 21 | "Kill Aura", 22 | "Automatically kills enemies around you") 23 | { 24 | InitConfig(); 25 | InitHooks(); 26 | } 27 | 28 | void hook_VCAnimatorMove_LateTick(void* this_, float tick) { 29 | auto& instance = KillAura::Instance(); 30 | if (instance.m_Enabled && instance.i_Type == 0) { 31 | MoleMole::BaseEntity* monster = *reinterpret_cast((uintptr_t)this_ + 0x0); 32 | if (monster->type() == MoleMole::EntityType::Monster) { 33 | auto avatarPos = MoleMole::EntityManager::get_EntityManager()->avatar()->getPosition(); 34 | float distance = monster->getPosition().distance(avatarPos); 35 | 36 | if (distance <= instance.f_Range) { 37 | *reinterpret_cast((uintptr_t)this_ + 0x0) = 2; 38 | Offsets::VCAnimatorMove::DrownWater(this_); 39 | } 40 | } 41 | } 42 | 43 | Hooks::Call(hook_VCAnimatorMove_LateTick, this_, tick); 44 | } 45 | 46 | void hook_RequestSceneEntityMoveReq(void* this_, uint32_t entityId, MoleMole::MotionInfo* motionInfo, bool a1, uint32_t a2, uint32_t a3) 47 | { 48 | auto& instance = KillAura::Instance(); 49 | 50 | if (instance.m_Enabled && instance.i_Type == 1) 51 | { 52 | auto mgr = MoleMole::EntityManager::get_EntityManager(); 53 | auto entity = Offsets::EntityManager::GetValidEntity(mgr, entityId); 54 | 55 | if (entity->type() == MoleMole::EntityType::Monster) 56 | { 57 | auto avatarPos = MoleMole::EntityManager::get_EntityManager()->avatar()->getPosition(); 58 | float distance = entity->getPosition().distance(avatarPos); 59 | 60 | if (distance <= instance.f_Range) 61 | { 62 | motionInfo->pos4->y = -52525252; 63 | } 64 | } 65 | } 66 | 67 | Hooks::Call(hook_RequestSceneEntityMoveReq, this_, entityId, motionInfo, a1, a2, a3); 68 | } 69 | 70 | void KillAura::Options() 71 | { 72 | if (ImGui::BeginCombo("Kill aura type", KillAuraTypes[i_Type].c_str())) { 73 | if (ImGui::Selectable(KillAuraTypes[0].c_str())) { 74 | i_Type.setValue(0); 75 | Config::SetValue(i_Type, 0); 76 | } 77 | if (ImGui::Selectable(KillAuraTypes[1].c_str())) { 78 | i_Type.setValue(1); 79 | Config::SetValue(i_Type, 1); 80 | } 81 | 82 | ImGui::EndCombo(); 83 | } 84 | if (ImGui::IsItemHovered()) { 85 | ImGui::SetTooltip("'Overworld': better in world and safer, DON'T USE IN DUNGEONS!\n'Dungeon': slower than 'Overworld', but works in dungeons."); 86 | } 87 | 88 | ConfigSliderFloat("Range", f_Range, 0, 10); 89 | //if (ImGui::IsItemActive()) 90 | //DrawVisualRange(f_Range); 91 | } 92 | 93 | void KillAura::Status() { 94 | ImGui::Text("Kill aura"); 95 | } 96 | 97 | void KillAura::OnUpdate() {} 98 | 99 | void KillAura::ProcessHotkeys() {} 100 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/imgui_stdlib.cpp: -------------------------------------------------------------------------------- 1 | // dear imgui: wrappers for C++ standard library (STL) types (std::string, etc.) 2 | // This is also an example of how you may wrap your own similar types. 3 | 4 | // Changelog: 5 | // - v0.10: Initial version. Added InputText() / InputTextMultiline() calls with std::string 6 | 7 | // See more C++ related extension (fmt, RAII, syntaxis sugar) on Wiki: 8 | // https://github.com/ocornut/imgui/wiki/Useful-Extensions#cness 9 | 10 | #include "imgui.h" 11 | #include "imgui_stdlib.h" 12 | 13 | // Clang warnings with -Weverything 14 | #if defined(__clang__) 15 | #pragma clang diagnostic push 16 | #pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness 17 | #endif 18 | 19 | struct InputTextCallback_UserData 20 | { 21 | std::string* Str; 22 | ImGuiInputTextCallback ChainCallback; 23 | void* ChainCallbackUserData; 24 | }; 25 | 26 | static int InputTextCallback(ImGuiInputTextCallbackData* data) 27 | { 28 | InputTextCallback_UserData* user_data = (InputTextCallback_UserData*)data->UserData; 29 | if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) 30 | { 31 | // Resize string callback 32 | // If for some reason we refuse the new length (BufTextLen) and/or capacity (BufSize) we need to set them back to what we want. 33 | std::string* str = user_data->Str; 34 | IM_ASSERT(data->Buf == str->c_str()); 35 | str->resize(data->BufTextLen); 36 | data->Buf = (char*)str->c_str(); 37 | } 38 | else if (user_data->ChainCallback) 39 | { 40 | // Forward to user callback, if any 41 | data->UserData = user_data->ChainCallbackUserData; 42 | return user_data->ChainCallback(data); 43 | } 44 | return 0; 45 | } 46 | 47 | bool ImGui::InputText(const char* label, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data) 48 | { 49 | IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0); 50 | flags |= ImGuiInputTextFlags_CallbackResize; 51 | 52 | InputTextCallback_UserData cb_user_data; 53 | cb_user_data.Str = str; 54 | cb_user_data.ChainCallback = callback; 55 | cb_user_data.ChainCallbackUserData = user_data; 56 | return InputText(label, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data); 57 | } 58 | 59 | bool ImGui::InputTextMultiline(const char* label, std::string* str, const ImVec2& size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data) 60 | { 61 | IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0); 62 | flags |= ImGuiInputTextFlags_CallbackResize; 63 | 64 | InputTextCallback_UserData cb_user_data; 65 | cb_user_data.Str = str; 66 | cb_user_data.ChainCallback = callback; 67 | cb_user_data.ChainCallbackUserData = user_data; 68 | return InputTextMultiline(label, (char*)str->c_str(), str->capacity() + 1, size, flags, InputTextCallback, &cb_user_data); 69 | } 70 | 71 | bool ImGui::InputTextWithHint(const char* label, const char* hint, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data) 72 | { 73 | IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0); 74 | flags |= ImGuiInputTextFlags_CallbackResize; 75 | 76 | InputTextCallback_UserData cb_user_data; 77 | cb_user_data.Str = str; 78 | cb_user_data.ChainCallback = callback; 79 | cb_user_data.ChainCallbackUserData = user_data; 80 | return InputTextWithHint(label, hint, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data); 81 | } 82 | 83 | #if defined(__clang__) 84 | #pragma clang diagnostic pop 85 | #endif 86 | -------------------------------------------------------------------------------- /src/Functions/Teleports/OculiTP.cpp: -------------------------------------------------------------------------------- 1 | #include "OculiTP.h" 2 | #include "ChestTP.h" 3 | 4 | namespace Teleports { 5 | void OnUpdate_OculiTP(); 6 | 7 | void OculiTP::InitConfig() 8 | { 9 | h_TP = Hotkey(m_Name, ("TP"), ImGuiKey_P); 10 | } 11 | 12 | void OculiTP::InitHooks() { 13 | Distance = 0; 14 | ClosestEntity = nullptr; 15 | } 16 | 17 | OculiTP::OculiTP() : Feature( 18 | ("Oculi TP"), 19 | ("Teleports you to closest oculus")) 20 | { 21 | InitConfig(); 22 | InitHooks(); 23 | } 24 | 25 | void OculiTP::Options() 26 | { 27 | h_TP.Draw(("TP key")); 28 | } 29 | 30 | void OculiTP::Status() {} 31 | 32 | void OculiTP::OnUpdate() 33 | { 34 | if (!m_Enabled) 35 | return; 36 | 37 | ImGui::SetNextWindowPos({ 300, 100 }, ImGuiCond_FirstUseEver); 38 | ImGui::Begin(("##TP"), nullptr, ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar); 39 | if (!ChestTP::Instance().m_Enabled) 40 | { 41 | ImGui::Text((" TP Status:")); 42 | ImGui::Separator(); 43 | } 44 | ImGui::Text(("Oculi TP: %s"), ClosestEntity == nullptr ? "Not found" : std::string(std::to_string(Distance) + "m").c_str()); 45 | ImGui::End(); 46 | } 47 | 48 | void OculiTP::ProcessHotkeys() 49 | { 50 | if (m_Enabled && h_TP.IsPressed()) 51 | { 52 | if (ClosestEntity == nullptr) 53 | return; 54 | 55 | auto pos = ClosestEntity->getPosition(); 56 | if (pos.zero()) 57 | return; 58 | 59 | std::thread(TeleportBase::TeleportTo, pos, 0).detach(); 60 | } 61 | } 62 | 63 | void OnUpdate_OculiTP() { 64 | auto& instance = OculiTP::Instance(); 65 | 66 | if (!instance.m_Enabled) 67 | return; 68 | 69 | if (!MoleMole::LoadingManager::get_LoadingManager()->IsLoaded()) return; 70 | 71 | auto manager = MoleMole::EntityManager::get_EntityManager(); 72 | if (manager == nullptr) return; 73 | 74 | auto avatar = manager->avatar(); 75 | if (avatar == nullptr) return; 76 | 77 | auto avatarPos = avatar->getPosition(); 78 | 79 | auto entities = manager->entities(); 80 | 81 | if (instance.cachedSize != entities.size()) 82 | { 83 | //printf(QENC("[OculiTP] cache is wrong! recaching...\n").c_str()); 84 | 85 | instance.cachedSize = entities.size(); 86 | instance.cachedEntities.clear(); 87 | 88 | for (auto entity : entities) 89 | { 90 | if (entity == nullptr) continue; 91 | auto entityName = entity->name(); 92 | if (entityName.find(("WindCrystalShell")) != std::string::npos || 93 | entityName.find(("Prop_ElectricCrystal")) != std::string::npos || 94 | entityName.find(("_XuMiCrystal")) != std::string::npos || 95 | entityName.find(("RockCrystalShell")) != std::string::npos || 96 | entityName.find(("_FontaineCrystal")) != std::string::npos || 97 | entityName.find(("_NataCrystal")) != std::string::npos) 98 | { 99 | instance.cachedEntities.push_back(entity); 100 | } 101 | } 102 | 103 | if (instance.cachedEntities.empty()) 104 | { 105 | instance.Distance = 0; 106 | instance.ClosestEntity = nullptr; 107 | } 108 | 109 | //printf(QENC("[OculiTP] recaching done!\n").c_str()); 110 | } 111 | 112 | for (auto& entity : instance.cachedEntities) 113 | { 114 | float distance = avatarPos.distance(entity->getPosition()); 115 | instance.chestMap[distance] = entity; 116 | } 117 | 118 | if (!instance.chestMap.empty()) 119 | { 120 | instance.Distance = instance.chestMap.begin()->first; 121 | instance.ClosestEntity = instance.chestMap.begin()->second; 122 | } 123 | 124 | instance.chestMap.clear(); 125 | } 126 | } -------------------------------------------------------------------------------- /src/Functions/World/KillAura.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Engine/SDK.h" 4 | #include "../../Frameworks/ImGui/ImGuiInclude.h" 5 | #include "../../Utils/Hooking.h" 6 | #include "../../Utils/Singleton.h" 7 | #include "../Feature.h" 8 | 9 | namespace World { 10 | class KillAura : public Feature, public Singleton { 11 | public: 12 | ConfigField f_Range; 13 | ConfigField i_Type; 14 | 15 | bool kill = false; 16 | 17 | std::string KillAuraTypes[2] = {"Overworld", "Dungeon"}; 18 | 19 | void Options(); 20 | void Status(); 21 | void OnUpdate(); 22 | void ProcessHotkeys(); 23 | 24 | void InitConfig(); 25 | void InitHooks(); 26 | 27 | KillAura(); 28 | }; 29 | } 30 | 31 | /* 32 | a1: 880804931 33 | a2: 41005001 34 | a7: 0 35 | a8: 16777250 36 | a9: 33554902 37 | a10: 0 38 | a11: 0 39 | a13: 1 40 | a14: 0 41 | a16: 0 42 | a17: 0 43 | a18: 16777250 44 | a19: 0 45 | a21: 1 46 | a22: 0 47 | a23: 0 48 | a26: 0 49 | a27: 0 50 | a28: 0 51 | a30: 0 52 | a31: 0 53 | a32: 0 54 | a34: 1041 55 | a35: 0 56 | */ 57 | 58 | /* 59 | a1: 880804905 60 | a2: 41005001 61 | a7: 0 62 | a8: 16777250 63 | a9: 33554902 64 | a10: 0 65 | a11: 0 66 | a13: 1 67 | a14: 0 68 | a16: 0 69 | a17: 0 70 | a18: 16777250 71 | a19: 0 72 | a21: 1 73 | a22: 0 74 | a23: 0 75 | a26: 0 76 | a27: 0 77 | a28: 0 78 | a30: 0 79 | a31: 0 80 | a32: 0 81 | a34: 1041 82 | a35: 0 83 | */ 84 | 85 | /* 86 | Called gadget with configId: 41005001! 87 | Called gadget at 1805.470459, 207.455673, -1248.931519! 88 | a1: 880804921 89 | a2: 41005001 90 | a7: 0 91 | a8: 16777250 92 | a9: 33554900 93 | a10: 0 94 | a11: 0 95 | a13: 1 96 | a14: 0 97 | a16: 0 98 | a17: 0 99 | a18: 16777250 100 | a19: 0 101 | a21: 1 102 | a22: 0 103 | a23: 0 104 | a26: 0 105 | a27: 0 106 | a28: 0 107 | a30: 0 108 | a31: 0 109 | a32: 0 110 | a34: 1041 111 | a35: 0 112 | 113 | Called gadget with configId: 42101006! 114 | Called gadget at 1809.213257, 208.641098, -1283.700684! 115 | a1: 880804922 116 | a2: 42101006 117 | a7: 0 118 | a8: 33554901 119 | a9: 16777250 120 | a10: 0 121 | a11: 0 122 | a13: 1 123 | a14: 0 124 | a16: 0 125 | a17: 0 126 | a18: 33554901 127 | a19: 0 128 | a21: 1 129 | a22: 0 130 | a23: 0 131 | a26: 0 132 | a27: 0 133 | a28: 0 134 | a30: 0 135 | a31: 0 136 | a32: 0 137 | a34: 529 138 | a35: 0 139 | 140 | Called gadget with configId: 42101006! 141 | Called gadget at 1809.333130, 208.731140, -1283.842651! 142 | a1: 880804923 143 | a2: 42101006 144 | a7: 0 145 | a8: 33554901 146 | a9: 16777250 147 | a10: 0 148 | a11: 0 149 | a13: 1 150 | a14: 0 151 | a16: 0 152 | a17: 0 153 | a18: 33554901 154 | a19: 0 155 | a21: 1 156 | a22: 0 157 | a23: 0 158 | a26: 0 159 | a27: 0 160 | a28: 0 161 | a30: 0 162 | a31: 0 163 | a32: 0 164 | a34: 529 165 | a35: 0 166 | 167 | Called gadget with configId: 42101006! 168 | Called gadget at 1809.447754, 208.798416, -1284.011475! 169 | a1: 880804924 170 | a2: 42101006 171 | a7: 0 172 | a8: 33554901 173 | a9: 16777250 174 | a10: 0 175 | a11: 0 176 | a13: 1 177 | a14: 0 178 | a16: 0 179 | a17: 0 180 | a18: 33554901 181 | a19: 0 182 | a21: 1 183 | a22: 0 184 | a23: 0 185 | a26: 0 186 | a27: 0 187 | a28: 0 188 | a30: 0 189 | a31: 0 190 | a32: 0 191 | a34: 529 192 | a35: 0 193 | 194 | Called gadget with configId: 42101006! 195 | Called gadget at 1809.181763, 208.728088, -1283.788940! 196 | a1: 880804927 197 | a2: 42101006 198 | a7: 0 199 | a8: 33554901 200 | a9: 16777250 201 | a10: 0 202 | a11: 0 203 | a13: 1 204 | a14: 0 205 | a16: 0 206 | a17: 0 207 | a18: 33554901 208 | a19: 0 209 | a21: 1 210 | a22: 0 211 | a23: 0 212 | a26: 0 213 | a27: 0 214 | a28: 0 215 | a30: 0 216 | a31: 0 217 | a32: 0 218 | a34: 529 219 | a35: 0 220 | */ -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/ftchapters.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * This file defines the structure of the FreeType reference. 4 | * It is used by the python script that generates the HTML files. 5 | * 6 | */ 7 | 8 | 9 | /************************************************************************** 10 | * 11 | * @chapter: 12 | * general_remarks 13 | * 14 | * @title: 15 | * General Remarks 16 | * 17 | * @sections: 18 | * preamble 19 | * header_inclusion 20 | * user_allocation 21 | * 22 | */ 23 | 24 | 25 | /************************************************************************** 26 | * 27 | * @chapter: 28 | * core_api 29 | * 30 | * @title: 31 | * Core API 32 | * 33 | * @sections: 34 | * basic_types 35 | * library_setup 36 | * face_creation 37 | * font_testing_macros 38 | * sizing_and_scaling 39 | * glyph_retrieval 40 | * character_mapping 41 | * information_retrieval 42 | * other_api_data 43 | * 44 | */ 45 | 46 | 47 | /************************************************************************** 48 | * 49 | * @chapter: 50 | * extended_api 51 | * 52 | * @title: 53 | * Extended API 54 | * 55 | * @sections: 56 | * glyph_variants 57 | * color_management 58 | * layer_management 59 | * glyph_management 60 | * mac_specific 61 | * sizes_management 62 | * header_file_macros 63 | * 64 | */ 65 | 66 | 67 | /************************************************************************** 68 | * 69 | * @chapter: 70 | * format_specific 71 | * 72 | * @title: 73 | * Format-Specific API 74 | * 75 | * @sections: 76 | * multiple_masters 77 | * truetype_tables 78 | * type1_tables 79 | * sfnt_names 80 | * bdf_fonts 81 | * cid_fonts 82 | * pfr_fonts 83 | * winfnt_fonts 84 | * svg_fonts 85 | * font_formats 86 | * gasp_table 87 | * 88 | */ 89 | 90 | 91 | /************************************************************************** 92 | * 93 | * @chapter: 94 | * module_specific 95 | * 96 | * @title: 97 | * Controlling FreeType Modules 98 | * 99 | * @sections: 100 | * auto_hinter 101 | * cff_driver 102 | * t1_cid_driver 103 | * tt_driver 104 | * pcf_driver 105 | * ot_svg_driver 106 | * properties 107 | * parameter_tags 108 | * lcd_rendering 109 | * 110 | */ 111 | 112 | 113 | /************************************************************************** 114 | * 115 | * @chapter: 116 | * cache_subsystem 117 | * 118 | * @title: 119 | * Cache Sub-System 120 | * 121 | * @sections: 122 | * cache_subsystem 123 | * 124 | */ 125 | 126 | 127 | /************************************************************************** 128 | * 129 | * @chapter: 130 | * support_api 131 | * 132 | * @title: 133 | * Support API 134 | * 135 | * @sections: 136 | * computations 137 | * list_processing 138 | * outline_processing 139 | * quick_advance 140 | * bitmap_handling 141 | * raster 142 | * glyph_stroker 143 | * system_interface 144 | * module_management 145 | * gzip 146 | * lzw 147 | * bzip2 148 | * debugging_apis 149 | * 150 | */ 151 | 152 | 153 | /************************************************************************** 154 | * 155 | * @chapter: 156 | * error_codes 157 | * 158 | * @title: 159 | * Error Codes 160 | * 161 | * @sections: 162 | * error_enumerations 163 | * error_code_values 164 | * 165 | */ 166 | 167 | 168 | /* END */ 169 | -------------------------------------------------------------------------------- /src/Functions/Teleports/MapTP.cpp: -------------------------------------------------------------------------------- 1 | #include "MapTP.h" 2 | 3 | namespace Teleports { 4 | void hook_InLevelMapPageContext_OnMapClicked(void* this_, Unity::Vector2 pos); 5 | void hook_InLevelMapPageContext_OnMarkClicked(void* this_, void* mark); 6 | 7 | void MapTP::InitConfig() 8 | { 9 | h_TP = Hotkey(m_Name, ("TP"), ImGuiKey_T); 10 | } 11 | 12 | void MapTP::InitHooks() 13 | { 14 | Hooks::Attach(Offsets::InLevelMapPageContext::OnMapClicked, hook_InLevelMapPageContext_OnMapClicked); 15 | Hooks::Attach(Offsets::InLevelMapPageContext::OnMarkClicked, hook_InLevelMapPageContext_OnMarkClicked); 16 | } 17 | 18 | MapTP::MapTP() : Feature( 19 | ("Map TP"), 20 | ("Click on the map while holding TP key to teleport to that location")) 21 | { 22 | InitConfig(); 23 | InitHooks(); 24 | } 25 | 26 | void MapTP::Options() 27 | { 28 | h_TP.Draw(("TP key")); 29 | } 30 | 31 | void MapTP::Status() {} 32 | 33 | void MapTP::OnUpdate() {} 34 | 35 | void MapTP::ProcessHotkeys() {} 36 | 37 | void hook_InLevelMapPageContext_OnMapClicked(void* this_, Unity::Vector2 pos) 38 | { 39 | auto& instance = MapTP::Instance(); 40 | 41 | if (instance.m_Enabled && instance.h_TP.IsDown()) 42 | { 43 | auto mgr = Offsets::SingletonManager::get_Instance(); 44 | if (mgr != nullptr) 45 | { 46 | auto uiManager = Offsets::SingletonManager::GetSingletonInstance(mgr, Unity::String::FromCString(("<...>"))); 47 | if (uiManager != nullptr) 48 | { 49 | auto monoInLevelMapPage = *reinterpret_cast((uintptr_t)this_ + 0x0); 50 | if (monoInLevelMapPage != nullptr) 51 | { 52 | auto mapBackground = Offsets::MonoInLevelMapPage::get_mapBackground(monoInLevelMapPage); 53 | if (mapBackground != nullptr) 54 | { 55 | auto uiCamera = *reinterpret_cast((uintptr_t)uiManager + 0x0); 56 | if (uiCamera != nullptr) 57 | { 58 | Unity::Vector2 levelPos = { 0,0 }; 59 | 60 | if (Offsets::RectTransformUtility::ScreenPointToLocalPointInRectangle(mapBackground, pos, uiCamera, &levelPos)) 61 | { 62 | auto mapRect = Offsets::MonoInLevelMapPage::get_mapRect(monoInLevelMapPage); 63 | auto mapViewRect = *reinterpret_cast((uintptr_t)this_ + 0x0); 64 | 65 | levelPos.x = (levelPos.x - mapRect.m_XMin) / mapRect.m_Width; 66 | levelPos.x = (levelPos.x * mapViewRect.m_Width) + mapViewRect.m_XMin; 67 | 68 | levelPos.y = (levelPos.y - mapRect.m_YMin) / mapRect.m_Height; 69 | levelPos.y = (levelPos.y * mapViewRect.m_Height) + mapViewRect.m_YMin; 70 | 71 | auto worldPos = Offsets::Miscs::GenWorldPos(levelPos); 72 | auto relativePos = Offsets::WorldShiftManager::GetRelativePosition(worldPos); 73 | worldPos.y = Offsets::Miscs::CalcCurrentGroundHeight(relativePos.x, relativePos.z) + 10.f; 74 | 75 | std::thread(TeleportBase::TeleportTo, worldPos, 0).detach(); 76 | 77 | Offsets::BasePageContext::ClosePage(this_); 78 | } 79 | } 80 | } 81 | } 82 | } 83 | } 84 | } 85 | 86 | Hooks::Call(hook_InLevelMapPageContext_OnMapClicked, this_, pos); 87 | } 88 | 89 | void hook_InLevelMapPageContext_OnMarkClicked(void* this_, void* mark) 90 | { 91 | auto& instance = MapTP::Instance(); 92 | 93 | if (instance.m_Enabled && instance.h_TP.IsDown()) 94 | { 95 | auto mapPos = Offsets::MonoMapMark::get_levelMapPos(mark); 96 | auto worldPos = Offsets::Miscs::GenWorldPos(mapPos); 97 | auto relativePos = Offsets::WorldShiftManager::GetRelativePosition(worldPos); 98 | worldPos.y = Offsets::MonoMapMark::get_height(mark) + 3.f; 99 | 100 | std::thread(TeleportBase::TeleportTo, worldPos, 0).detach(); 101 | 102 | Offsets::BasePageContext::ClosePage(this_); 103 | } 104 | 105 | Hooks::Call(hook_InLevelMapPageContext_OnMarkClicked, this_, mark); 106 | } 107 | } 108 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/imgui_impl_win32.h: -------------------------------------------------------------------------------- 1 | // dear imgui: Platform Backend for Windows (standard windows API for 32-bits AND 64-bits applications) 2 | // This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..) 3 | 4 | // Implemented features: 5 | // [X] Platform: Clipboard support (for Win32 this is actually part of core dear imgui) 6 | // [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen. 7 | // [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy VK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set] 8 | // [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'. 9 | // [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. 10 | 11 | // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. 12 | // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. 13 | // Learn about Dear ImGui: 14 | // - FAQ https://dearimgui.com/faq 15 | // - Getting Started https://dearimgui.com/getting-started 16 | // - Documentation https://dearimgui.com/docs (same as your local docs/ folder). 17 | // - Introduction, links and more at the top of imgui.cpp 18 | 19 | #pragma once 20 | #include "imgui.h" // IMGUI_IMPL_API 21 | #include "imgui_impl_win32.h" 22 | #ifndef WIN32_LEAN_AND_MEAN 23 | #define WIN32_LEAN_AND_MEAN 24 | #endif 25 | #include 26 | #include // GET_X_LPARAM(), GET_Y_LPARAM() 27 | #include 28 | #include 29 | #ifndef IMGUI_DISABLE 30 | 31 | IMGUI_IMPL_API bool ImGui_ImplWin32_Init(void* hwnd); 32 | IMGUI_IMPL_API bool ImGui_ImplWin32_InitForOpenGL(void* hwnd); 33 | IMGUI_IMPL_API void ImGui_ImplWin32_Shutdown(); 34 | IMGUI_IMPL_API void ImGui_ImplWin32_NewFrame(); 35 | 36 | // Win32 message handler your application need to call. 37 | // - Intentionally commented out in a '#if 0' block to avoid dragging dependencies on from this helper. 38 | // - You should COPY the line below into your .cpp code to forward declare the function and then you can call it. 39 | // - Call from your application's message handler. Keep calling your message handler unless this function returns TRUE. 40 | 41 | #if 0 42 | extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); 43 | #endif 44 | IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); 45 | // DPI-related helpers (optional) 46 | // - Use to enable DPI awareness without having to create an application manifest. 47 | // - Your own app may already do this via a manifest or explicit calls. This is mostly useful for our examples/ apps. 48 | // - In theory we could call simple functions from Windows SDK such as SetProcessDPIAware(), SetProcessDpiAwareness(), etc. 49 | // but most of the functions provided by Microsoft require Windows 8.1/10+ SDK at compile time and Windows 8/10+ at runtime, 50 | // neither we want to require the user to have. So we dynamically select and load those functions to avoid dependencies. 51 | IMGUI_IMPL_API void ImGui_ImplWin32_EnableDpiAwareness(); 52 | IMGUI_IMPL_API float ImGui_ImplWin32_GetDpiScaleForHwnd(void* hwnd); // HWND hwnd 53 | IMGUI_IMPL_API float ImGui_ImplWin32_GetDpiScaleForMonitor(void* monitor); // HMONITOR monitor 54 | 55 | // Transparency related helpers (optional) [experimental] 56 | // - Use to enable alpha compositing transparency with the desktop. 57 | // - Use together with e.g. clearing your framebuffer with zero-alpha. 58 | IMGUI_IMPL_API void ImGui_ImplWin32_EnableAlphaCompositing(void* hwnd); // HWND hwnd 59 | 60 | #endif // #ifndef IMGUI_DISABLE 61 | -------------------------------------------------------------------------------- /src/Frameworks/ImGui/freetype/internal/fthash.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * fthash.h 4 | * 5 | * Hashing functions (specification). 6 | * 7 | */ 8 | 9 | /* 10 | * Copyright 2000 Computing Research Labs, New Mexico State University 11 | * Copyright 2001-2015 12 | * Francesco Zappa Nardelli 13 | * 14 | * Permission is hereby granted, free of charge, to any person obtaining a 15 | * copy of this software and associated documentation files (the "Software"), 16 | * to deal in the Software without restriction, including without limitation 17 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, 18 | * and/or sell copies of the Software, and to permit persons to whom the 19 | * Software is furnished to do so, subject to the following conditions: 20 | * 21 | * The above copyright notice and this permission notice shall be included in 22 | * all copies or substantial portions of the Software. 23 | * 24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 27 | * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY 28 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 29 | * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR 30 | * THE USE OR OTHER DEALINGS IN THE SOFTWARE. 31 | */ 32 | 33 | /************************************************************************** 34 | * 35 | * This file is based on code from bdf.c,v 1.22 2000/03/16 20:08:50 36 | * 37 | * taken from Mark Leisher's xmbdfed package 38 | * 39 | */ 40 | 41 | 42 | #ifndef FTHASH_H_ 43 | #define FTHASH_H_ 44 | 45 | 46 | #include 47 | 48 | 49 | FT_BEGIN_HEADER 50 | 51 | 52 | typedef union FT_Hashkey_ 53 | { 54 | FT_Int num; 55 | const char* str; 56 | 57 | } FT_Hashkey; 58 | 59 | 60 | typedef struct FT_HashnodeRec_ 61 | { 62 | FT_Hashkey key; 63 | size_t data; 64 | 65 | } FT_HashnodeRec; 66 | 67 | typedef struct FT_HashnodeRec_ *FT_Hashnode; 68 | 69 | 70 | typedef FT_ULong 71 | (*FT_Hash_LookupFunc)( FT_Hashkey* key ); 72 | 73 | typedef FT_Bool 74 | (*FT_Hash_CompareFunc)( FT_Hashkey* a, 75 | FT_Hashkey* b ); 76 | 77 | 78 | typedef struct FT_HashRec_ 79 | { 80 | FT_UInt limit; 81 | FT_UInt size; 82 | FT_UInt used; 83 | 84 | FT_Hash_LookupFunc lookup; 85 | FT_Hash_CompareFunc compare; 86 | 87 | FT_Hashnode* table; 88 | 89 | } FT_HashRec; 90 | 91 | typedef struct FT_HashRec_ *FT_Hash; 92 | 93 | 94 | FT_Error 95 | ft_hash_str_init( FT_Hash hash, 96 | FT_Memory memory ); 97 | 98 | FT_Error 99 | ft_hash_num_init( FT_Hash hash, 100 | FT_Memory memory ); 101 | 102 | void 103 | ft_hash_str_free( FT_Hash hash, 104 | FT_Memory memory ); 105 | 106 | #define ft_hash_num_free ft_hash_str_free 107 | 108 | FT_Error 109 | ft_hash_str_insert( const char* key, 110 | size_t data, 111 | FT_Hash hash, 112 | FT_Memory memory ); 113 | 114 | FT_Error 115 | ft_hash_num_insert( FT_Int num, 116 | size_t data, 117 | FT_Hash hash, 118 | FT_Memory memory ); 119 | 120 | size_t* 121 | ft_hash_str_lookup( const char* key, 122 | FT_Hash hash ); 123 | 124 | size_t* 125 | ft_hash_num_lookup( FT_Int num, 126 | FT_Hash hash ); 127 | 128 | 129 | FT_END_HEADER 130 | 131 | 132 | #endif /* FTHASH_H_ */ 133 | 134 | 135 | /* END */ 136 | -------------------------------------------------------------------------------- /src/Functions/World/AutoDestroy.cpp: -------------------------------------------------------------------------------- 1 | #include "AutoDestroy.h" 2 | 3 | namespace World { 4 | void hook_LCAbilityModifier_ReduceModifierDurability(void* this_, int index, float reduce, void* nullable); 5 | 6 | void AutoDestroy::InitConfig() 7 | { 8 | b_Ores = Config::GetValue(this->m_Name, "ores", false); 9 | b_Props = Config::GetValue(this->m_Name, "props", false); 10 | b_Shields = Config::GetValue(this->m_Name, "shields", false); 11 | f_Range = Config::GetValue(this->m_Name, "range", 15.f); 12 | } 13 | 14 | void AutoDestroy::InitHooks() { 15 | Hooks::Attach(Offsets::LCAbilityComponent::ReduceModifierDurability, hook_LCAbilityModifier_ReduceModifierDurability); 16 | } 17 | 18 | AutoDestroy::AutoDestroy() : Feature( 19 | "Auto Destroy", 20 | "Automatically destroys selected types of objects") 21 | { 22 | InitConfig(); 23 | InitHooks(); 24 | } 25 | 26 | void AutoDestroy::Options() 27 | { 28 | ConfigCheckbox("Ores", b_Ores); 29 | ConfigCheckbox("Scene props (barrels, boxes, ...)", b_Props); 30 | ConfigCheckbox("Shields", b_Shields); 31 | ConfigSliderFloat("Range", f_Range, 1, 50); 32 | } 33 | 34 | void AutoDestroy::Status() {} 35 | 36 | void AutoDestroy::OnUpdate() {} 37 | 38 | void AutoDestroy::ProcessHotkeys() {} 39 | 40 | bool IsValidEntity(MoleMole::BaseEntity* entity) 41 | { 42 | auto& instance = AutoDestroy::Instance(); 43 | 44 | auto type = entity->type(); 45 | auto name = entity->name(); 46 | 47 | if (instance.b_Ores && 48 | type == MoleMole::EntityType::GatherObject && 49 | 50 | (name.find("_ElementRock") != std::string::npos || 51 | name.find("Ore") != std::string::npos || 52 | name.find("_Drop") != std::string::npos)) 53 | { 54 | return true; 55 | } 56 | 57 | if (instance.b_Props && 58 | type == MoleMole::EntityType::Gadget && 59 | 60 | (name.find("Monster_Effigy") != std::string::npos || 61 | name.find("HiliWoodenBox") != std::string::npos || 62 | name.find("HumanBox") != std::string::npos || 63 | name.find("HumanJars") != std::string::npos || 64 | name.find("QQTotem") != std::string::npos || 65 | name.find("WatchTower") != std::string::npos || 66 | name.find("StonePile") != std::string::npos || 67 | name.find("BrokenWall") != std::string::npos || 68 | name.find("WoodenBox") != std::string::npos || 69 | name.find("RoadBlock") != std::string::npos)) 70 | { 71 | return true; 72 | } 73 | 74 | if (instance.b_Shields && 75 | (type == MoleMole::EntityType::Monster || 76 | type == MoleMole::EntityType::MonsterEquip) && 77 | 78 | (name.find("_Abyss") != std::string::npos || 79 | name.find("_Slime") != std::string::npos || 80 | name.find("_Brute") != std::string::npos || 81 | name.find("_Invoker") != std::string::npos || 82 | name.find("_Fatuus_Summoner") != std::string::npos || 83 | name.find("_Skirmisher") != std::string::npos || 84 | name.find("_Cicin") != std::string::npos || 85 | name.find("_Mimik") != std::string::npos)) 86 | { 87 | return true; 88 | } 89 | 90 | return false; 91 | } 92 | 93 | void hook_LCAbilityModifier_ReduceModifierDurability(void* this_, int index, float reduce, void* nullable) 94 | { 95 | auto& instance = AutoDestroy::Instance(); 96 | 97 | if (instance.m_Enabled) 98 | { 99 | auto entity = *reinterpret_cast((uintptr_t)this_ + 0x0); 100 | if (entity) 101 | { 102 | auto entityManager = MoleMole::EntityManager::get_EntityManager(); 103 | if (entityManager) 104 | { 105 | auto avatar = entityManager->avatar(); 106 | if (avatar) 107 | { 108 | auto avatarPos = avatar->getPosition(); 109 | float distance = entity->getPosition().distance(avatarPos); 110 | 111 | if (IsValidEntity(entity) && distance <= instance.f_Range) 112 | reduce = 10000.f; 113 | } 114 | } 115 | } 116 | } 117 | 118 | Hooks::Call(hook_LCAbilityModifier_ReduceModifierDurability, this_, index, reduce, nullable); 119 | } 120 | } -------------------------------------------------------------------------------- /src/Frameworks/ImGui/imgui_freetype.h: -------------------------------------------------------------------------------- 1 | // dear imgui: FreeType font builder (used as a replacement for the stb_truetype builder) 2 | // (headers) 3 | 4 | #pragma once 5 | #include "imgui.h" // IMGUI_API 6 | #ifndef IMGUI_DISABLE 7 | 8 | // Usage: 9 | // - Add '#define IMGUI_ENABLE_FREETYPE' in your imconfig to enable support for imgui_freetype in imgui. 10 | 11 | // Optional support for OpenType SVG fonts: 12 | // - Add '#define IMGUI_ENABLE_FREETYPE_PLUTOSVG' to use plutosvg (not provided). See #7927. 13 | // - Add '#define IMGUI_ENABLE_FREETYPE_LUNASVG' to use lunasvg (not provided). See #6591. 14 | 15 | // Forward declarations 16 | struct ImFontAtlas; 17 | struct ImFontBuilderIO; 18 | 19 | // Hinting greatly impacts visuals (and glyph sizes). 20 | // - By default, hinting is enabled and the font's native hinter is preferred over the auto-hinter. 21 | // - When disabled, FreeType generates blurrier glyphs, more or less matches the stb_truetype.h 22 | // - The Default hinting mode usually looks good, but may distort glyphs in an unusual way. 23 | // - The Light hinting mode generates fuzzier glyphs but better matches Microsoft's rasterizer. 24 | // You can set those flags globally in ImFontAtlas::FontBuilderFlags 25 | // You can set those flags on a per font basis in ImFontConfig::FontBuilderFlags 26 | enum ImGuiFreeTypeBuilderFlags 27 | { 28 | ImGuiFreeTypeBuilderFlags_NoHinting = 1 << 0, // Disable hinting. This generally generates 'blurrier' bitmap glyphs when the glyph are rendered in any of the anti-aliased modes. 29 | ImGuiFreeTypeBuilderFlags_NoAutoHint = 1 << 1, // Disable auto-hinter. 30 | ImGuiFreeTypeBuilderFlags_ForceAutoHint = 1 << 2, // Indicates that the auto-hinter is preferred over the font's native hinter. 31 | ImGuiFreeTypeBuilderFlags_LightHinting = 1 << 3, // A lighter hinting algorithm for gray-level modes. Many generated glyphs are fuzzier but better resemble their original shape. This is achieved by snapping glyphs to the pixel grid only vertically (Y-axis), as is done by Microsoft's ClearType and Adobe's proprietary font renderer. This preserves inter-glyph spacing in horizontal text. 32 | ImGuiFreeTypeBuilderFlags_MonoHinting = 1 << 4, // Strong hinting algorithm that should only be used for monochrome output. 33 | ImGuiFreeTypeBuilderFlags_Bold = 1 << 5, // Styling: Should we artificially embolden the font? 34 | ImGuiFreeTypeBuilderFlags_Oblique = 1 << 6, // Styling: Should we slant the font, emulating italic style? 35 | ImGuiFreeTypeBuilderFlags_Monochrome = 1 << 7, // Disable anti-aliasing. Combine this with MonoHinting for best results! 36 | ImGuiFreeTypeBuilderFlags_LoadColor = 1 << 8, // Enable FreeType color-layered glyphs 37 | ImGuiFreeTypeBuilderFlags_Bitmap = 1 << 9 // Enable FreeType bitmap glyphs 38 | }; 39 | 40 | namespace ImGuiFreeType 41 | { 42 | // This is automatically assigned when using '#define IMGUI_ENABLE_FREETYPE'. 43 | // If you need to dynamically select between multiple builders: 44 | // - you can manually assign this builder with 'atlas->FontBuilderIO = ImGuiFreeType::GetBuilderForFreeType()' 45 | // - prefer deep-copying this into your own ImFontBuilderIO instance if you use hot-reloading that messes up static data. 46 | IMGUI_API const ImFontBuilderIO* GetBuilderForFreeType(); 47 | 48 | // Override allocators. By default ImGuiFreeType will use IM_ALLOC()/IM_FREE() 49 | // However, as FreeType does lots of allocations we provide a way for the user to redirect it to a separate memory heap if desired. 50 | IMGUI_API void SetAllocatorFunctions(void* (*alloc_func)(size_t sz, void* user_data), void (*free_func)(void* ptr, void* user_data), void* user_data = nullptr); 51 | 52 | // Obsolete names (will be removed soon) 53 | #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS 54 | //static inline bool BuildFontAtlas(ImFontAtlas* atlas, unsigned int flags = 0) { atlas->FontBuilderIO = GetBuilderForFreeType(); atlas->FontBuilderFlags = flags; return atlas->Build(); } // Prefer using '#define IMGUI_ENABLE_FREETYPE' 55 | #endif 56 | } 57 | 58 | #endif // #ifndef IMGUI_DISABLE 59 | -------------------------------------------------------------------------------- /src/Engine/SDK.cpp: -------------------------------------------------------------------------------- 1 | #include "SDK.h" 2 | 3 | namespace Unity 4 | { 5 | String* String::FromCString(std::string text) 6 | { 7 | return Offsets::Marshal::PtrToStringAnsi(text.c_str()); 8 | } 9 | 10 | std::string String::ToCString() 11 | { 12 | if (this == nullptr) return (""); 13 | 14 | std::u16string u16(reinterpret_cast(reinterpret_cast(this)->chars)); 15 | return std::wstring_convert, char16_t>{}.to_bytes(u16); 16 | } 17 | 18 | Transform* GameObject::GetTransform() 19 | { 20 | if (this == nullptr) return 0; 21 | return Offsets::GameObject::get_transform(this); 22 | } 23 | 24 | void Transform::setPosition(Unity::Vector3 pos) 25 | { 26 | if (this == nullptr) return; 27 | Offsets::Transform::set_localPosition(this, pos); 28 | } 29 | 30 | Unity::Vector3 Transform::getPosition() 31 | { 32 | if (this == nullptr) return {0,0,0}; 33 | return Offsets::Transform::get_localPosition(this); 34 | } 35 | } 36 | 37 | namespace MoleMole 38 | { 39 | EntityManager* EntityManager::get_EntityManager() 40 | { 41 | try { 42 | auto mgr = Offsets::SingletonManager::get_Instance(); 43 | if (mgr != nullptr) { 44 | auto loadingMgr = Offsets::SingletonManager::GetSingletonInstance(mgr, Unity::String::FromCString("<...>")); // Class name of EntityManager 45 | if (loadingMgr != nullptr) return (EntityManager*)loadingMgr; 46 | } 47 | return 0; 48 | } 49 | catch (...) { 50 | return 0; 51 | } 52 | } 53 | 54 | std::vector EntityManager::entities() { 55 | std::vector vector; 56 | 57 | if (this == nullptr) return vector; 58 | 59 | auto list = Offsets::EntityManager::GetEntities(this); 60 | if (list == nullptr) return vector; 61 | 62 | for (int i = 0; i < list->size; i++) { 63 | auto ent = list->items->operator[](i); 64 | if (ent == nullptr) continue; 65 | vector.push_back(ent); 66 | } 67 | 68 | return vector; 69 | } 70 | 71 | BaseEntity* EntityManager::avatar() 72 | { 73 | if (this == nullptr) return 0; 74 | try { 75 | return Offsets::EntityManager::GetLocalAvatarEntity(this); 76 | } 77 | catch (...) { 78 | return 0; 79 | } 80 | } 81 | 82 | EntityType BaseEntity::type() 83 | { 84 | if (this == nullptr) return EntityType::None; 85 | try { 86 | return Offsets::BaseEntity::get_EntityType(this); 87 | } 88 | catch (...) { 89 | return EntityType::None; 90 | } 91 | } 92 | 93 | uint32_t BaseEntity::runtimeId() 94 | { 95 | if (this == nullptr) return 0; 96 | try { 97 | return Offsets::BaseEntity::get_runtimeId(this); 98 | } 99 | catch (...) { 100 | return 0; 101 | } 102 | } 103 | 104 | Unity::GameObject* BaseEntity::get_GameObject() 105 | { 106 | if (this == nullptr) return 0; 107 | return Offsets::BaseEntity::get_GameObject(this); 108 | } 109 | 110 | void BaseEntity::setPosition(Unity::Vector3 pos) 111 | { 112 | if (this == nullptr) return; 113 | Offsets::BaseEntity::set_Position(this, pos, true); 114 | } 115 | 116 | Unity::Vector3 BaseEntity::getPosition() 117 | { 118 | if (this == nullptr) return {0,0,0}; 119 | return Offsets::BaseEntity::get_Position(this); 120 | } 121 | 122 | void* BaseEntity::animator() 123 | { 124 | if (this == nullptr) return 0; 125 | return Offsets::BaseEntity::GetAnimator(this); 126 | } 127 | 128 | std::string BaseEntity::name() 129 | { 130 | if (this == nullptr) return (""); 131 | return Offsets::BaseEntity::get_name(this)->ToCString(); 132 | } 133 | 134 | LoadingManager* LoadingManager::get_LoadingManager() 135 | { 136 | auto mgr = Offsets::SingletonManager::get_Instance(); 137 | if (mgr != nullptr) { 138 | auto loadingMgr = Offsets::SingletonManager::GetSingletonInstance(mgr, Unity::String::FromCString("<...>")); // Classname of LoadingManager 139 | if (loadingMgr != nullptr) return (LoadingManager*)loadingMgr; 140 | } 141 | return 0; 142 | } 143 | 144 | bool LoadingManager::IsLoaded() 145 | { 146 | if (this == nullptr) return 0; 147 | return Offsets::LoadingManager::IsLoaded(this); 148 | } 149 | } -------------------------------------------------------------------------------- /src/Functions/Player/Noclip.cpp: -------------------------------------------------------------------------------- 1 | #include "Noclip.h" 2 | 3 | #define UNSAFE 4 | 5 | namespace Player { 6 | void OnUpdate_Noclip(); 7 | 8 | void Noclip::InitConfig() { 9 | b_UseAltSpeed = Config::GetValue(this->m_Name, ("useAltSpeed"), false); 10 | f_Speed = Config::GetValue(this->m_Name, ("speed"), 5.f); 11 | f_AltSpeed = Config::GetValue(this->m_Name, ("altSpeed"), 10.f); 12 | } 13 | 14 | void Noclip::InitHooks() { 15 | #ifdef UNSAFE 16 | // ¯\_(ツ)_ /¯ 17 | #endif 18 | } 19 | 20 | Noclip::Noclip() : Feature( 21 | ("Noclip"), 22 | ("Lets you fly")) 23 | { 24 | InitConfig(); 25 | InitHooks(); 26 | } 27 | 28 | void Noclip::Options() { 29 | ConfigSliderFloat(("Speed"), f_Speed, 1.f, 20.f); 30 | ConfigCheckbox(("Use alt. speed"), b_UseAltSpeed); 31 | if (b_UseAltSpeed) { 32 | ImGui::Indent(); 33 | ConfigSliderFloat(("Alt. Speed"), f_AltSpeed, 1.f, 20.f); 34 | ImGui::Unindent(); 35 | } 36 | } 37 | 38 | void Noclip::Status() {} 39 | 40 | void Noclip::OnUpdate() {} 41 | 42 | void Noclip::ProcessHotkeys() {} 43 | 44 | void OnUpdate_Noclip() 45 | { 46 | auto& instance = Noclip::Instance(); 47 | 48 | if (!MoleMole::LoadingManager::get_LoadingManager()->IsLoaded()) return; 49 | 50 | if (instance.m_Enabled) 51 | { 52 | static auto start_time = std::chrono::steady_clock::now(); 53 | 54 | auto current_time = std::chrono::steady_clock::now(); 55 | auto elapsed_time = std::chrono::duration_cast(current_time - start_time).count(); 56 | 57 | if (elapsed_time > 1000) 58 | { 59 | instance.cachedMgr = MoleMole::EntityManager::get_EntityManager(); 60 | if (instance.cachedMgr == nullptr) 61 | return; 62 | 63 | auto mgr = (MoleMole::EntityManager*)instance.cachedMgr; 64 | instance.cachedAvatar = mgr->avatar(); 65 | if (instance.cachedAvatar == nullptr) 66 | return; 67 | 68 | instance.cachedCamera = Offsets::Camera::get_main(); 69 | if (instance.cachedCamera == nullptr) 70 | return; 71 | 72 | instance.cachedRelativeTransform = Offsets::Component::get_transform(instance.cachedCamera); 73 | if (instance.cachedRelativeTransform == nullptr) 74 | return; 75 | #ifdef UNSAFE 76 | // ¯\_(ツ)_/¯ 77 | #endif 78 | start_time = std::chrono::steady_clock::now(); 79 | } 80 | 81 | Unity::Vector3 dir = { 0,0,0 }; 82 | 83 | auto avatar = (MoleMole::BaseEntity*)instance.cachedAvatar; 84 | if (avatar == nullptr) return; 85 | 86 | auto relativeTransform = (Unity::Transform*)instance.cachedRelativeTransform; 87 | if (relativeTransform == nullptr) return; 88 | 89 | if (ImGui::IsKeyDown(ImGuiKey_W)) 90 | dir = dir + Offsets::Transform::get_forward(relativeTransform); 91 | if (ImGui::IsKeyDown(ImGuiKey_S)) 92 | dir = dir - Offsets::Transform::get_forward(relativeTransform); 93 | if (ImGui::IsKeyDown(ImGuiKey_A)) 94 | dir = dir - Offsets::Transform::get_right(relativeTransform); 95 | if (ImGui::IsKeyDown(ImGuiKey_D)) 96 | dir = dir + Offsets::Transform::get_right(relativeTransform); 97 | 98 | if (ImGui::IsKeyDown(ImGuiKey_LeftShift)) 99 | dir.y -= 1; 100 | if (ImGui::IsKeyDown(ImGuiKey_Space)) 101 | dir.y += 1; 102 | 103 | Unity::Vector3 prevPos = avatar->getPosition(); 104 | 105 | dir = dir * (instance.b_UseAltSpeed && ImGui::IsKeyDown(ImGuiKey_LeftCtrl) ? instance.f_AltSpeed : instance.f_Speed) * (1 / 60.f); 106 | 107 | Unity::Vector3 newPos = prevPos + dir; 108 | 109 | Offsets::Rigidbody::set_Velocity(Offsets::BaseEntity::GetRigidbody(avatar), { 0,0,0 }); 110 | 111 | avatar->setPosition(newPos); 112 | } 113 | } 114 | 115 | void hook_BaseComponent_LateTickAction(void* this_, float a1) { 116 | auto& instance = Noclip::Instance(); 117 | if (instance.m_Enabled) 118 | return; 119 | 120 | Hooks::Call(hook_BaseComponent_LateTickAction, this_, a1); 121 | } 122 | 123 | void hook_HumanoidMoveFSM_LateTick(void* this_, float a1) { 124 | auto& instance = Noclip::Instance(); 125 | if (instance.m_Enabled) 126 | return; 127 | 128 | Hooks::Call(hook_HumanoidMoveFSM_LateTick, this_, a1); 129 | } 130 | } --------------------------------------------------------------------------------