#include #include #include #include #include #include "GameInformations.h" #include "ObfuscateString.h" #include "Memory.hpp"; #include "Maths.hpp"; #include "UEngine.hpp"; #include "SDK/Basic.hpp" #include "SDK/Engine_classes.hpp" #include "SDK/Charlie_classes.hpp" #include "SDK/UMG_classes.hpp" #include "HUD_PlayerStatus_SUMG_classes.hpp" using namespace SDK; // Constants const std::string PLUGIN_NAME = "HellIsUs"; const std::string PLUGIN_LOG = PLUGIN_NAME + ".log"; const std::string gameExecutable = "HellIsUs-Win64-Shipping.exe"; const float BASE_ASPECT = 1.777777791; const float DEFAULT_WORLD_FOV = 70.f; const float DEFAULT_CAMERA_HEIGHT = -15.f; // Logger std::shared_ptr logger; // Screen informations static int screenWidth = GetSystemMetrics(SM_CXSCREEN); static int screenHeight = GetSystemMetrics(SM_CYSCREEN); static float aspectRatio = (float)screenWidth / screenHeight; // Plugin states static bool AOBScanDone = false; static bool g_fix_enabled = false; static bool g_fov_fix_enabled = false; static bool g_aspect_fix_enabled = false; static bool g_DOF_fix_enabled = false; static bool g_CA_fix_enabled = false; static bool g_Vignetting_fix_enabled = false; static bool g_Fog_fix_enabled = false; static bool g_Camera_fix_enabled = false; static bool g_HUD_fix_enabled = false; static int g_AdditionalFOVValue = 0; static float g_cameraDistanceMultiplier = 1.f; static float g_cameraHeight = -15.f; // Shared values static float g_FOV_In = 70.f; static float g_Compensated_FOV = 70.f; static float g_FOV_Out = 70.f; static float g_Camera_In = 550.f; static float g_Camera_Out = 550.f; static bool g_Console_Enabled = false; // AOB Unreal Engine offsets addresses static uint8_t* GObjectsaddress = nullptr; static uint8_t* GNamesaddress = nullptr; static uint8_t* AppendStringaddress = nullptr; static uint8_t* ProcessEventaddress = nullptr; // AOB Scan pointers static uint8_t* FOVaddress = nullptr; static uint8_t* Aspectaddress = nullptr; static uint8_t* DOFaddress = nullptr; static uint8_t* CAaddress = nullptr; static uint8_t* Vignettingaddress = nullptr; static uint8_t* Fogaddress = nullptr; static uint8_t* Cameraaddress = nullptr; static uint8_t* HUDaddress = nullptr; static uint8_t* SetAnchorsaddress = nullptr; // Hooking static SafetyHookMid FOVHook{}; static SafetyHookMid AspectHook{}; static SafetyHookMid FogHook{}; static SafetyHookMid CameraHook{}; static SafetyHookMid HUDHook{}; static SafetyHookMid HUDProcessEventHook{}; // HUD anchors static FAnchors HUDAnchors = {{ 0.f, 0.f }, { 0.f , 1.f }}; static FAnchors referenceHUDAnchors = { { 0.25f, 0.f }, { 0.25f , 1.f } }; static FAnchors defaultHUDAnchors = {{ 0.f, 0.f }, { 1.f, 1.f }}; // Will be displayed on all screen viewport // Camera Mode enum class ECharlieCameraMode : uint8_t { Camera = 1, FOV = 2 }; // Prototypes static void FOVFixEnabled(); static void AspectFixEnabled(); static void DOFFixEnabled(); static void CAFixEnabled(); static void VignettingFixEnabled(); static void FogFixEnabled(); static void CameraFixEnabled(ECharlieCameraMode Mode); static void HUDFixEnabled(); static void EnableConsole(); extern "C" __declspec(dllexport) void SetFixEnabled(bool enabled) { g_fix_enabled = enabled; if (g_fix_enabled && !AOBScanDone) { logger->info("--------------- AOB scan started ---------------"); if (FOVaddress == nullptr) { constexpr auto FOVStringObfuscated = make_obfuscated<0x4A>("77 ?? 48 ?? ?? FF ?? ?? ?? ?? ?? F3 0F ?? ?? ?? 48"); FOVaddress = Memory::AOBScan(gameExecutable, FOVStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 3C92144 - 48 8B 01 - mov rax, [rcx] //"HellIsUs-Win64-Shipping.exe" + 3C92147 - FF 90 60 07 00 00 - call qword ptr[rax + 00000760] //"HellIsUs-Win64-Shipping.exe" + 3C9214D - F3 0F 10 40 30 - movss xmm0, [rax + 30] //"HellIsUs-Win64-Shipping.exe" + 3C92152 - 48 83 C4 28 - add rsp, 28 //"HellIsUs-Win64-Shipping.exe" + 3C92156 - C3 - ret if (!FOVaddress) logger->warn("FOV signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("FOV signature found at address: 0x{:X}.", reinterpret_cast(FOVaddress)); FOVaddress += 0x10; } } if (Aspectaddress == nullptr) { constexpr auto AspectStringObfuscated = make_obfuscated<0x4A>("E9 ?? ?? ?? ?? CC CC CC CC CC CC 48 89 ?? ?? ?? 57 48 83 ?? ?? 0F ?? ?? 48 ?? ?? 48"); Aspectaddress = Memory::AOBScan(gameExecutable, AspectStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 3453EBA - 89 41 58 - mov[rcx + 58], eax //"HellIsUs-Win64-Shipping.exe" + 3453EBD - 8B 42 5C - mov eax, [rdx + 5C] //"HellIsUs-Win64-Shipping.exe" + 3453EC0 - 89 41 5C - mov[rcx + 5C], eax <<= Aspect ratio //"HellIsUs-Win64-Shipping.exe" + 3453EC3 - 48 8D 42 60 - lea rax, [rdx + 60] //"HellIsUs-Win64-Shipping.exe" + 3453EC7 - 48 83 C1 60 - add rcx, 60 if (!Aspectaddress) logger->warn("Aspect ratio ratio signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("Aspect ratio signature found at address: 0x{:X}.", reinterpret_cast(Aspectaddress)); Aspectaddress = Aspectaddress + 0x8b; } } if (DOFaddress == nullptr) { constexpr auto DOFStringObfuscated = make_obfuscated<0x4A>("74 ?? 48 ?? ?? 8B ?? ?? 48 ?? ?? E8"); DOFaddress = Memory::AOBScan(gameExecutable, DOFStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 26ABA27 - 74 03 - je "HellIsUs-Win64-Shipping.exe" + 26ABA2C //"HellIsUs-Win64-Shipping.exe" + 26ABA29 - 48 8B C3 - mov rax, rbx //"HellIsUs-Win64-Shipping.exe" + 26ABA2C - 8B 34 30 - mov esi, [rax + rsi] //"HellIsUs-Win64-Shipping.exe" + 26ABA2F - 48 8B CF - mov rcx, rdi //"HellIsUs-Win64-Shipping.exe" + 26ABA32 - E8 D9 C4 6C 01 - call "HellIsUs-Win64-Shipping.exe" + 3D77F10 if (!DOFaddress) logger->warn("DOF signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("DOF signature found at address: 0x{:X}.", reinterpret_cast(DOFaddress)); DOFaddress += 0x5; } } if (CAaddress == nullptr) { constexpr auto CAStringObfuscated = make_obfuscated<0x4A>("7F ?? 44 89 ?? ?? ?? ?? ?? 43 ?? ?? ?? 39 05"); CAaddress = Memory::AOBScan(gameExecutable, CAStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 3D73BC2 - 48 8B 05 D7 F7 6E 05 - mov rax, ["HellIsUs-Win64-Shipping.exe" + 94633A0] //"HellIsUs-Win64-Shipping.exe" + 3D73BC9 - 44 39 38 - cmp[rax], r15d //"HellIsUs-Win64-Shipping.exe" + 3D73BCC - 7F 07 - jg "HellIsUs-Win64-Shipping.exe" + 3D73BD5 //"HellIsUs-Win64-Shipping.exe" + 3D73BCE - 44 89 BB 1C 20 00 00 - mov[rbx + 0000201C], r15d //"HellIsUs-Win64-Shipping.exe" + 3D73BD5 - 43 8B 04 26 - mov eax, [r14 + r12] if (!CAaddress) logger->warn("Chromatic aberrations signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("Chromatic aberrations signature found at address: 0x{:X}.", reinterpret_cast(CAaddress)); } } if (Vignettingaddress == nullptr) { constexpr auto VignettingStringObfuscated = make_obfuscated<0x4A>("8B ?? 83 ?? ?? 7D ?? 44 89"); Vignettingaddress = Memory::AOBScan(gameExecutable, VignettingStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 3D73C64 - 8B 08 - mov ecx, [rax] //"HellIsUs-Win64-Shipping.exe" + 3D73C66 - 83 F9 02 - cmp ecx, 02 //"HellIsUs-Win64-Shipping.exe" + 3D73C69 - 7D 09 - jnl "HellIsUs-Win64-Shipping.exe" + 3D73C74 //"HellIsUs-Win64-Shipping.exe" + 3D73C6B - 44 89 BB C8 22 00 00 - mov[rbx + 000022C8], r15d //"HellIsUs-Win64-Shipping.exe" + 3D73C72 - EB 05 - jmp "HellIsUs-Win64-Shipping.exe" + 3D73C79 if (!Vignettingaddress) logger->warn("Vignetting signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("Vignetting signature found at address: 0x{:X}.", reinterpret_cast(Vignettingaddress)); Vignettingaddress += 0x5; } } if (Fogaddress == nullptr) { // 40 ?? 48 83 ?? ?? 48 8B ?? ?? ?? ?? ?? 48 ?? ?? 48 89 ?? ?? ?? 48 8D ?? ?? 48 8D ?? ?? ?? E8 //constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("0F 84 ?? ?? ?? ?? F6 ?? ?? ?? 0F 84 ?? ?? ?? ?? 83 BF"); constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("40 ?? 48 83 ?? ?? 48 8B ?? ?? ?? ?? ?? 48 ?? ?? 48 89 ?? ?? ?? 48 8D ?? ?? 48 8D ?? ?? ?? E8"); Fogaddress = Memory::AOBScan(gameExecutable, FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 22B77C8 - 74 11 - je "HellIsUs-Win64-Shipping.exe" + 22B77DB //"HellIsUs-Win64-Shipping.exe" + 22B77CA - 48 8B 05 8F 23 08 07 - mov rax, ["HellIsUs-Win64-Shipping.exe" + 9339B60] //"HellIsUs-Win64-Shipping.exe" + 22B77D1 - 83 78 04 01 - cmp dword ptr[rax + 04], 01 //"HellIsUs-Win64-Shipping.exe" + 22B77D5 - 75 04 - jne "HellIsUs-Win64-Shipping.exe" + 22B77DB //"HellIsUs-Win64-Shipping.exe" + 22B77D7 - B3 01 - mov bl, 01 //"HellIsUs-Win64-Shipping.exe" + 22B77D9 - EB 02 - jmp "HellIsUs-Win64-Shipping.exe" + 22B77DD //"HellIsUs-Win64-Shipping.exe" + 22B77DB - 32 DB - xor bl, bl if (!Fogaddress) logger->warn("Fog signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("Fog signature found at address: 0x{:X}.", reinterpret_cast(Fogaddress)); Fogaddress += 0x31; // 0x57 } } if (Cameraaddress == nullptr) { constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("28 C3 48 83 ?? ?? 48 8B ?? ?? ?? ?? ?? 48 8B ?? 48 85 ?? 75"); Cameraaddress = Memory::AOBScan(gameExecutable, FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 4E9D3F2 - 48 85 C0 - test rax, rax //"HellIsUs-Win64-Shipping.exe" + 4E9D3F5 - 74 0A - je "HellIsUs-Win64-Shipping.exe" + 4E9D401 //"HellIsUs-Win64-Shipping.exe" + 4E9D3F7 - F3 0F 10 40 4C - movss xmm0, [rax + 4C] //"HellIsUs-Win64-Shipping.exe" + 4E9D3FC - 48 83 C4 28 - add rsp, 28 //"HellIsUs-Win64-Shipping.exe" + 4E9D400 - C3 - ret if (!Cameraaddress) logger->warn("Camera signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("Camera signature found at address: 0x{:X}.", reinterpret_cast(Cameraaddress)); } } if (HUDaddress == nullptr) { // Low level function involved in displaying Widgets in real time constexpr auto UEConstructStringObfuscated = make_obfuscated<0x4A>("44 0F ?? ?? ?? 74 ?? 48 8B ?? ?? ?? ?? ?? 48 85 ?? 74 ?? 48 8B"); HUDaddress = Memory::AOBScan(gameExecutable, UEConstructStringObfuscated.decrypt(), PAGE_EXECUTE_READ); //"HellIsUs-Win64-Shipping.exe" + 1817760 - 0F11 4F 58 - movups[rdi + 58], xmm1 //"HellIsUs-Win64-Shipping.exe" + 1817764 - 83 BF B8 00 00 00 00 - cmp dword ptr[rdi + HellIsUsCore.dtor_list_head + 88], 00 //"HellIsUs-Win64-Shipping.exe" + 181776B - 44 0F 10 4F 48 - movups xmm9, [rdi + 48] //"HellIsUs-Win64-Shipping.exe" + 1817770 - 44 0F 10 57 58 - movups xmm10, [rdi + 58] //"HellIsUs-Win64-Shipping.exe" + 1817775 - 74 36 - je "HellIsUs-Win64-Shipping.exe" + 18177AD //"HellIsUs-Win64-Shipping.exe" + 1817777 - 48 8B 8F B0 00 00 00 - mov rcx, [rdi + HellIsUsCore.dtor_list_head + 80] if (!HUDaddress) logger->warn("HUD signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { logger->info("HUD signature found at address: 0x{:X}.", reinterpret_cast(HUDaddress)); HUDaddress += 0x05; } } if (Aspectaddress && DOFaddress && CAaddress && Vignettingaddress && Fogaddress && Cameraaddress) { logger->info("All AOB signatures found. Ready to patch..."); AOBScanDone = true; } if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) { logger->info("------------ UEngine offsets search ------------"); constexpr auto GObjetcsStringObfuscated = make_obfuscated<0x4A>("48 8B ?? ?? ?? ?? ?? 48 8B ?? ?? 48 8D ?? ?? EB ?? 33"); GObjectsaddress = Memory::AOBScan(gameExecutable, GObjetcsStringObfuscated.decrypt(), PAGE_EXECUTE_READ); constexpr auto GNamesStringObfuscated = make_obfuscated<0x4A>("48 8D ?? ?? ?? ?? ?? EB ?? 48 8D ?? ?? ?? ?? ?? E8 ?? ?? ?? ?? C6 05 ?? ?? ?? ?? ?? 0F ?? ?? 4C"); GNamesaddress = Memory::AOBScan(gameExecutable, GNamesStringObfuscated.decrypt(), PAGE_EXECUTE_READ); constexpr auto AppendStringStringObfuscated = make_obfuscated<0x4A>("48 89 ?? ?? ?? 48 89 ?? ?? ?? 57 48 83 ?? ?? 80 3D ?? ?? ?? ?? ?? 48 8B F2 8B ?? 48"); AppendStringaddress = Memory::AOBScan(gameExecutable, AppendStringStringObfuscated.decrypt(), PAGE_EXECUTE_READ); constexpr auto ProcessEventStringObfuscated = make_obfuscated<0x4A>("40 ?? 56 57 41 ?? 41 ?? 41 ?? 41 ?? 48 81 ?? ?? ?? ?? ?? 48 8D ?? ?? ?? 48 89 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? ?? ?? 48 33 ?? 48 89 ?? ?? ?? ?? ?? 4D ?? ?? 48"); ProcessEventaddress = Memory::AOBScan(gameExecutable, ProcessEventStringObfuscated.decrypt(), PAGE_EXECUTE_READ); if (!GObjectsaddress) logger->warn("GObjects signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { uint32_t gObjectsOffset = static_cast(Memory::GetOffsetFromOpcode(GObjectsaddress + 0x3) - reinterpret_cast(GetModuleHandleA(gameExecutable.c_str()))); logger->info("GObjects offset is: 0x{:X}.", gObjectsOffset); Offsets::GObjects = static_cast(gObjectsOffset); // Update GObjects offset } if (!GNamesaddress) logger->warn("GNames signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { uint32_t gNamesOffset = static_cast(Memory::GetOffsetFromOpcode(GNamesaddress + 0x3) - reinterpret_cast(GetModuleHandleA(gameExecutable.c_str()))); logger->info("GNames offset is: 0x{:X}.", gNamesOffset); Offsets::GNames = static_cast(gNamesOffset); // Update GNames offset } if (!AppendStringaddress) logger->warn("AppendString signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { std::optional gAppendStringOffsetOpt = UE::CalculateOffset(gameExecutable, AppendStringaddress); // Get Offset from opcode uint32_t gAppendStringOffset = *gAppendStringOffsetOpt; logger->info("AppendString offset is: 0x{:X}.", gAppendStringOffset); Offsets::AppendString = static_cast(gAppendStringOffset); // Update AppendString offset } if (!ProcessEventaddress) logger->warn("Process Event signature not found. Maybe your game has been updated and is no more compatible with this plugin."); else { std::optional gProcessEventOffsetOpt = UE::CalculateOffset(gameExecutable, ProcessEventaddress); uint32_t gProcessEventOffset = *gProcessEventOffsetOpt; logger->info("Process Event offset is: 0x{:X}.", gProcessEventOffset); Offsets::ProcessEvent = static_cast(gProcessEventOffset);// Update ProcessEvent offset } } logger->info("-------------- Fixes initialisation -------------"); } if (FOVaddress) FOVFixEnabled(); if (Aspectaddress) AspectFixEnabled(); if (Cameraaddress) CameraFixEnabled(ECharlieCameraMode::Camera); if (Cameraaddress) CameraFixEnabled(ECharlieCameraMode::FOV); if (DOFaddress) DOFFixEnabled(); if (CAaddress) CAFixEnabled(); if (Vignettingaddress) VignettingFixEnabled(); if (Fogaddress) FogFixEnabled(); if (GObjectsaddress && GNamesaddress && AppendStringaddress && ProcessEventaddress && HUDaddress) HUDFixEnabled(); if (!g_Console_Enabled && GObjectsaddress && GNamesaddress && AppendStringaddress && ProcessEventaddress) EnableConsole(); } // Setters for Reshade addon call extern "C" __declspec(dllexport) void SetFOVFixEnabled(bool enabled, bool init) { g_fov_fix_enabled = enabled; if (!init) { FOVFixEnabled(); CameraFixEnabled(ECharlieCameraMode::FOV); } } extern "C" __declspec(dllexport) void SetAspectRatioFixEnabled(bool enabled, bool init) { g_aspect_fix_enabled = enabled; if (!init) AspectFixEnabled(); } extern "C" __declspec(dllexport) void SetDOFFixEnabled(bool enabled, bool init) { g_DOF_fix_enabled = enabled; if (!init) DOFFixEnabled(); } extern "C" __declspec(dllexport) void SetCAFixEnabled(bool enabled, bool init) { g_CA_fix_enabled = enabled; if (!init) CAFixEnabled(); } extern "C" __declspec(dllexport) void SetVignettingFixEnabled(bool enabled, bool init) { g_Vignetting_fix_enabled = enabled; if (!init) VignettingFixEnabled(); } extern "C" __declspec(dllexport) void SetFogFixEnabled(bool enabled, bool init) { g_Fog_fix_enabled = enabled; if (!init) FogFixEnabled(); } extern "C" __declspec(dllexport) void SetCameraFixEnabled(bool enabled, bool init) { g_Camera_fix_enabled = enabled; if (!init) CameraFixEnabled(ECharlieCameraMode::Camera); } extern "C" __declspec(dllexport) void SetHUDFixEnabled(bool enabled, bool init) { g_HUD_fix_enabled = enabled; if (!init) HUDFixEnabled(); } extern "C" __declspec(dllexport) void SetFOV(int fov) { g_AdditionalFOVValue = fov; } extern "C" __declspec(dllexport) void SetCameraDistance(float cameraDistance) { g_cameraDistanceMultiplier = cameraDistance; } extern "C" __declspec(dllexport) void SetCameraHeight(int cameraHeight) { g_cameraHeight = (float)cameraHeight; } extern "C" __declspec(dllexport) void SetHUD(int HUDValue) { float percentageLeft = (float)HUDValue / 100; float percentageRight = 1 - (float)HUDValue / 100; HUDAnchors = { { percentageLeft , 0.f }, { percentageRight , 1.f} }; } // Getters for Reshade addon call extern "C" __declspec(dllexport) void GetGameInfos(GameInfos* infos) { if (!infos) return; infos->FOVIn = g_FOV_In; infos->CompensatedFOV = g_Compensated_FOV; infos->FOVOut = g_FOV_Out; infos->cameraIn = g_Camera_In; infos->cameraOut = g_Camera_Out; infos->consoleEnabled = g_Console_Enabled; } // Code injection functions // FOV compensation only static void FOVFixEnabled() { if (FOVaddress) { if (!FOVHook) { // Hook only once FOVHook = safetyhook::create_mid(FOVaddress, [](SafetyHookContext& ctx) { g_FOV_In = ctx.xmm0.f32[0]; g_Compensated_FOV = ctx.xmm0.f32[0]; if (g_fix_enabled && g_aspect_fix_enabled) g_Compensated_FOV = ctx.xmm0.f32[0] = Maths::CompensateHorizontalFOV(g_FOV_In, BASE_ASPECT, aspectRatio); g_FOV_Out = ctx.xmm0.f32[0]; }); } } } static void AspectFixEnabled() { if (g_fix_enabled && g_aspect_fix_enabled && Aspectaddress) { if (!AspectHook) { AspectHook = safetyhook::create_mid(Aspectaddress, [](SafetyHookContext& ctx) { ctx.rax = *reinterpret_cast(&aspectRatio); }); } else AspectHook.enable(); FOVFixEnabled(); logger->info("Aspect fix enabled"); } if (!(g_fix_enabled && g_aspect_fix_enabled)) { if (AspectHook) AspectHook.disable(); logger->info("Aspect ratio fix disabled"); } } // Controls FOV & camera height & distance static void CameraFixEnabled(ECharlieCameraMode mode) { if (Cameraaddress) { if (!CameraHook) { // Hook only once +0x4e or start to test +0x13 CameraHook = safetyhook::create_mid(Cameraaddress + 0x4e, [](SafetyHookContext& ctx) { g_Camera_In = ctx.xmm0.f32[0]; ctx.xmm0.f32[0] *= (g_Camera_fix_enabled ? g_cameraDistanceMultiplier : 1.f); g_Camera_Out = ctx.xmm0.f32[0]; // Retrieve player camera object auto* charlieCameraBaseConfig = reinterpret_cast(ctx.rax); if (charlieCameraBaseConfig && charlieCameraBaseConfig->IsA(UCharlieCameraBaseConfig::StaticClass())) { // Camera height charlieCameraBaseConfig->DefaultHeightFromPlayer = (g_fix_enabled && g_Camera_fix_enabled ? g_cameraHeight : DEFAULT_CAMERA_HEIGHT); // World FOV charlieCameraBaseConfig->FieldOfView = DEFAULT_WORLD_FOV + (g_fix_enabled && g_fov_fix_enabled ? g_AdditionalFOVValue : 0.f); } }); } } if (mode == ECharlieCameraMode::Camera) { if (g_Camera_fix_enabled) logger->info("Camera fix enabled"); else logger->info("Camera fix disabled"); } if (mode == ECharlieCameraMode::FOV) { if (g_fov_fix_enabled) logger->info("FOV fix enabled"); else logger->info("FOV fix disabled"); } } static void HUDFixEnabled() { if (ProcessEventaddress && HUDaddress) { if (!HUDProcessEventHook) { HUDProcessEventHook = safetyhook::create_mid(ProcessEventaddress + 0xc, [](SafetyHookContext& ctx) { auto* object = reinterpret_cast(ctx.rcx); auto* function = reinterpret_cast(ctx.rdx); // Filter object on Unreal User widgets if (object && object->IsA(UUserWidget::StaticClass()) && function) { std::string funcName = function->GetName(); std::string objectName = object->GetName(); // Filter by function construct if (funcName == "Construct") { auto* objectClass = object->Class; std::string className = objectClass ? objectClass->GetName() : "Unknown"; auto* widget = static_cast(object); // Ensure the widget is of UCanvasPanelSlot & valid if (widget && widget->Slot && widget->Slot->IsA(UCanvasPanelSlot::StaticClass())) { auto* canvasSlot = static_cast(widget->Slot); // Filter on class drawing HUD in game if (canvasSlot && className.contains("CombatHud_SUMG_C")) canvasSlot->SetAnchors(referenceHUDAnchors); } } } }); } if (!HUDHook) { HUDHook = safetyhook::create_mid(HUDaddress, [](SafetyHookContext& ctx) { if (ctx.xmm9.f64[0] == referenceHUDAnchors.Minimum.X && ctx.xmm9.f64[1] == referenceHUDAnchors.Minimum.Y && ctx.xmm10.f64[0] == referenceHUDAnchors.Maximum.X && ctx.xmm10.f64[1] == referenceHUDAnchors.Maximum.Y) { // Comparison between reference anchors previously set and the one retrieved here // This is to ensure the right Widget is targeted (CombatHud_SUMG_C) if (g_fix_enabled && g_HUD_fix_enabled) { ctx.xmm9.f64[0] = HUDAnchors.Minimum.X; ctx.xmm9.f64[1] = HUDAnchors.Minimum.Y; ctx.xmm10.f64[0] = HUDAnchors.Maximum.X; ctx.xmm10.f64[1] = HUDAnchors.Maximum.Y; } else { ctx.xmm9.f64[0] = defaultHUDAnchors.Minimum.X; ctx.xmm9.f64[1] = defaultHUDAnchors.Minimum.Y; ctx.xmm10.f64[0] = defaultHUDAnchors.Maximum.X; ctx.xmm10.f64[1] = defaultHUDAnchors.Maximum.Y; } } }); } if (g_fix_enabled && g_HUD_fix_enabled) logger->info("HUD fix enabled"); else logger->info("HUD fix disabled"); } } // Memory patch fixes static void DOFFixEnabled() { if (g_fix_enabled && g_DOF_fix_enabled && DOFaddress) { Memory::PatchBytes(DOFaddress, "\x31\xF6\x90", 3); // xor esi,esi r.DepthOfFieldQuality = 0 logger->info("Depth of field fix enabled"); } if (!(g_fix_enabled && g_DOF_fix_enabled) && DOFaddress) { Memory::RestoreBytes(DOFaddress); logger->info("Depth of field fix disabled"); } } static void CAFixEnabled() { if (g_fix_enabled && g_CA_fix_enabled && CAaddress) { Memory::PatchBytes(CAaddress, "\x90\x90", 2); // NOP jg "HellIsUs-Win64-Shipping.exe"+3D73BD5 logger->info("Chromatics aberrations fix enabled"); } if (!(g_fix_enabled && g_CA_fix_enabled) && CAaddress) { Memory::RestoreBytes(CAaddress); logger->info("Chromatics aberrations fix disabled"); } } static void VignettingFixEnabled() { if (g_fix_enabled && g_Vignetting_fix_enabled && Vignettingaddress) { Memory::PatchBytes(Vignettingaddress, "\x31\xC9", 2); // xor ecx,ecx r.Tonemapper.Quality=0 logger->info("Vignetting fix enabled"); } if (!(g_fix_enabled && g_Vignetting_fix_enabled) && Vignettingaddress) { Memory::RestoreBytes(Vignettingaddress); logger->info("Vignetting fix disabled"); } } static void FogFixEnabled() { if (g_fix_enabled && g_Fog_fix_enabled && Fogaddress) { if (!FogHook) { FogHook = safetyhook::create_mid(Fogaddress, [](SafetyHookContext& ctx) { if (!ctx.rax) return; uintptr_t* rax = reinterpret_cast(ctx.rax); bool* bFog = reinterpret_cast(reinterpret_cast(rax) + 0x04); *bFog = g_fix_enabled && g_Fog_fix_enabled ? false : true; }); } logger->info("Fog fix enabled"); } if (!(g_fix_enabled && g_Fog_fix_enabled) && Fogaddress) logger->info("Fog fix disabled"); } // UE Console creation static void EnableConsole() { logger->info("-------------- Console re-enabling --------------"); if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) { logger->warn("Could not re-enable console"); logger->info("------------------ User inputs ------------------"); return; } std::thread([&]() { auto start = std::chrono::high_resolution_clock::now(); // Measure the time to renable console UEngine* Engine = nullptr; for (int i = 0; i < 100; ++i) { // gives 10 seconds to find UE Engine std::this_thread::sleep_for(std::chrono::milliseconds(100)); Engine = UEngine::GetEngine(); if (Engine && Engine->ConsoleClass && Engine->GameViewport) break; } if (!Engine || !Engine->ConsoleClass || !Engine->GameViewport) { logger->error("Console could not be found in engine."); return; } logger->info("Console found in engine"); /* Creates a new UObject of class-type specified by Engine->ConsoleClass */ UObject* NewObject = UGameplayStatics::SpawnObject(Engine->ConsoleClass, Engine->GameViewport); if (NewObject) { logger->info("Successfully spawned console object"); // Set the console viewport so that it will be displayed Engine->GameViewport->ViewportConsole = static_cast(NewObject); //Engine->GameViewport->ViewportConsole->ConsoleTargetPlayer->ViewportClient auto end = std::chrono::high_resolution_clock::now(); std::chrono::duration elapsed = end - start; // Set the all the console shortkey to F2 for (int i = 0; i < UInputSettings::GetDefaultObj()->ConsoleKeys.Num(); i++) { UInputSettings::GetDefaultObj()->ConsoleKeys[i].KeyName = UKismetStringLibrary::Conv_StringToName(L"F2"); } logger->info("Console fully reactivated in {:.3f}s and bound to key F2", elapsed.count()); logger->info("------------------ User inputs ------------------"); g_Console_Enabled = true; } else { logger->error("Could not spawn console object"); } }).detach(); } static void InitializeLogger() { try { std::filesystem::path log_path = std::filesystem::absolute(PLUGIN_LOG); if (std::filesystem::exists(log_path)) std::filesystem::remove(log_path); logger = std::make_shared("Hell Is Us", std::make_shared(PLUGIN_LOG, 10 * 1024 * 1024, 1)); logger->set_level(spdlog::level::debug); logger->flush_on(spdlog::level::debug); // Flush automatically } catch (const spdlog::spdlog_ex& ex) { std::string plugin_error_message = "Could not open " + PLUGIN_LOG; MessageBoxA(nullptr, plugin_error_message.c_str(), "Logger Error", MB_ICONERROR | MB_OK); } } // Standard dll entry BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID) { if (reason == DLL_PROCESS_ATTACH) { InitializeLogger(); logger->info("Plugin {} loaded.", PLUGIN_NAME); } else if (reason == DLL_PROCESS_DETACH) { logger->info("Plugin {} unloaded.", PLUGIN_NAME); spdlog::drop_all(); } return TRUE; }