#define NOMINMAX #include #include "CommonHeaders.h" #include "UEMath.hpp" #include "SDK/Basic.hpp" #include "SDK/Engine_classes.hpp" #include "SDK/Phoenix_classes.hpp" using namespace SDK; using namespace UEMath; // Constants const std::string PLUGIN_NAME = "TheCallistoProtocol"; const std::string PLUGIN_LOG = PLUGIN_NAME + ".log"; constexpr float INVENTORY_CAM_OFFSET = 59.16f; constexpr float FORGE_CAM_OFFSET = 46.f; constexpr ULONGLONG DEFAULT_ACTORS_SCAN_BETWEEN_TICKS = 300; // Used for enemies time dilation // 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_camera_fix_enabled = false; static bool g_HUD_fix_enabled = false; static bool g_fov_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_TimeDilation_fix_enabled = false; static bool g_GodMode_fix_enabled = false; static bool g_IgnoreHits_fix_enabled = false; static bool g_Stealth_fix_enabled = false; static int g_AdditionalFOVValue = 0; static int g_CameraOffset = 0; static float g_WorldTimeDilationValue = 1.f; static float g_AITimeDilationValue = 1.f; static float g_CameraSmoothnessValue = 3.5f; static float g_TransitionCameraOffset = 0.f; static float g_NativeCameraDistance = 80.f; static float g_LastCameraDeltaTime = 1.f / 60.f; // fallback static float g_HUDLeft = 0.f; static float g_HUDRight = 1.f; static bool g_Console = false; static bool bIsInBenchmarkMode = false; static bool bIsInventoryOpen = false; static bool bIsInCinematicMode = false; static bool bIsInPrinterMode = false; static bool bIsAiming = false; static double LastCineCallTime = 0.0; static bool user_inputs_logged = false; static ULONGLONG lastScanTick = 0; // Last time Actors were scanned for enemies time dilation // Shared values static float g_FOV_In = 75.f; static float g_FOV_Out = 75.f; static bool g_Console_Enabled = false; // AOB Unreal Engine offsets addresses static uint8_t* GObjectsaddress = nullptr; static uint8_t* GWorldaddress = nullptr; static uint8_t* AppendStringaddress = nullptr; static uint8_t* ProcessEventaddress = nullptr; // AOB Scan pointers static uint8_t* FOVaddress = nullptr; static uint8_t* ConstrainAspectaddress = nullptr; static uint8_t* Cameraaddress = nullptr; static uint8_t* HUDaddress = nullptr; static uint8_t* CAaddress = nullptr; static uint8_t* Vignettingaddress = nullptr; static uint8_t* Fogaddress = nullptr; static uint8_t* WorldTimedilationaddress = nullptr; static uint8_t* SetBenchmarkModeaddress = nullptr; static uint8_t* CheatManageraddress = nullptr; // Hooking static SafetyHookMid FOVHook{}; static SafetyHookMid CameraHook{}; static SafetyHookMid HUDHook{}; static SafetyHookMid FogHook{}; static SafetyHookMid WorldTimeDilationHook{}; static SafetyHookMid BenchmarkHook{}; static SafetyHookMid PEHook{}; static SafetyHookMid CheatsHook{}; // Prototypes static void FOVFixEnabled(); static void UltraWideFixEnabled(); static void CameraFixEnabled(); static void HUDFixEnabled(); static void DOFFixEnabled(); static void CAFixEnabled(); static void VignettingFixEnabled(); static void FogFixEnabled(); static void EnableConsole(); static void EnableCheats(Cheat cheat); // Unreal Engine camera struct struct BlueprintModifyCamera_Params { float DeltaTime; // in FVector ViewLocation; // in FRotator ViewRotation; // in float FOV; // in // OUT parameters (Passed by refernce in Blueprint signature) FVector NewViewLocation; // out FRotator NewViewRotation; // out float NewFOV; // out }; extern "C" __declspec(dllexport) void SetFixEnabled(bool enabled, bool init) { g_fix_enabled = enabled; if (g_fix_enabled && !AOBScanDone) { // Unreal Engine 4.27.2 uint8_t* baseModule = reinterpret_cast(GetModuleHandleA(nullptr)); // Get game base address logger->info("--------------- AOB scan started ---------------"); using AOBScan::Make; using OffsetScan::Make; constexpr auto FOVStringObfuscated = make_obfuscated<0x4A>("EB ?? F3 0F ?? ?? ?? ?? ?? ?? F3 0F ?? ?? ?? F3 0F ?? ?? ?? ?? ?? ?? F3 0F ?? ?? ?? 8B"); constexpr auto CameraStringObfuscated = make_obfuscated<0x2F>("49 8B ?? ?? ?? ?? ?? 48 ?? ?? 74 ?? 48 8D ?? ?? ?? E8 ?? ?? ?? ?? 49 8B ?? ?? ?? ?? ?? EB"); constexpr auto BenchMarkStringObfuscated = make_obfuscated<0xC3>("88 86 58 03 ?? ?? 48 8B ?? ?? ?? 48 83 ?? ?? 5F C3"); constexpr auto HUDStringObfuscated = make_obfuscated<0x8A>("FF ?? 48 8B ?? ?? ?? 0F ?? ?? 48 ?? ?? 0F ?? ?? 48 83"); constexpr auto CAStringObfuscated = make_obfuscated<0xFC>("7F ?? 89 B3 ?? ?? ?? ?? 8B ?? ?? 39 05 ?? ?? ?? ?? 0F"); constexpr auto VignettingStringObfuscated = make_obfuscated<0x97>("8B ?? 83 ?? ?? 7D ?? 89 B3"); constexpr auto FogStringObfuscated = make_obfuscated<0x46>("83 ?? ?? ?? 75 ?? B3 ?? EB ?? 32 ?? 48 8B ?? ?? ?? 48 ?? ?? 74 ?? E8"); constexpr auto WorldTimeDilationStringObfuscated = make_obfuscated<0x6E>("F3 0F 10 ?? ?? ?? ?? ?? F3 0F 10 ?? ?? ?? ?? ?? F3 0F ?? ?? ?? ?? ?? ?? F3 0F ?? ?? ?? ?? ?? ?? F3 0F ?? ?? C3"); constexpr auto CheatManagerStringObfuscated = make_obfuscated<0xAB>("FF 90 ?? ?? ?? ?? 84 ?? 75 ?? 84 ?? 0F 84 ?? ?? ?? ?? 48 89"); // Prepare all data for scanning std::vector signatures = { Make(&FOVaddress, FOVStringObfuscated, "FOV"), Make(&Cameraaddress, CameraStringObfuscated, "Camera"), Make(&SetBenchmarkModeaddress, BenchMarkStringObfuscated, "Set Benchmark mode"), Make(&HUDaddress, HUDStringObfuscated, "HUD"), Make(&CAaddress, CAStringObfuscated, "Chromatic aberrations"), Make(&Vignettingaddress, VignettingStringObfuscated, "Vignetting"), Make(&Fogaddress, FogStringObfuscated, "Fog"), Make(&WorldTimedilationaddress, WorldTimeDilationStringObfuscated, "World time dilation"), Make(&CheatManageraddress, CheatManagerStringObfuscated, "Cheat manager"), }; // Scan all signature in a batch Memory::AOBScanBatch(signatures, logger); if (FOVaddress && Cameraaddress && SetBenchmarkModeaddress && HUDaddress && CAaddress && Vignettingaddress && Fogaddress && WorldTimedilationaddress && CheatManageraddress) logger->info("All AOB signatures found. Ready to patch..."); AOBScanDone = true; if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) { logger->info("------------ UEngine offsets search ------------"); constexpr auto GWorldStringObfuscated = make_obfuscated<0xCA>("48 8B ?? ?? ?? ?? ?? 48 ?? ?? 74 ?? 48 ?? ?? E8 ?? ?? ?? ?? 83 ?? ?? 74"); constexpr auto GObjetcsStringObfuscated = make_obfuscated<0x87>("48 8B ?? ?? ?? ?? ?? 48 8B ?? ?? 48 8D ?? ?? EB ?? 33"); constexpr auto AppendStringStringObfuscated = make_obfuscated<0x32>("48 89 ?? ?? ?? 48 89 ?? ?? ?? 57 48 ?? ?? ?? 8B ?? 48 ?? ?? 8B ?? 44 ?? ?? ?? C1 ?? ?? 48 ?? ?? 80 3D ?? ?? ?? ?? ?? 89 ?? ?? ?? 44 89 ?? ?? ?? 74 ?? 4C 8D ?? ?? ?? ?? ?? EB ?? 48 8D ?? ?? ?? ?? ?? E8 ?? ?? ?? ?? 4C ?? ?? C6 05 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? 48 ?? ?? 48 ?? ?? ?? 8D ?? ?? 49 03 ?? ?? ?? E8 ?? ?? ?? ?? 83"); constexpr auto ProcessEventStringObfuscated = make_obfuscated<0xAC>("40 ?? 56 57 41 ?? 41 ?? 41 ?? 41 ?? 48 81 ?? ?? ?? ?? ?? 48 8D ?? ?? ?? 48 89 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? ?? ?? 48 ?? ?? 48 89 ?? ?? ?? ?? ?? 8B"); // Prepare all data for scanning std::vector UEoffsetsScans = { Make(&GWorldaddress, GWorldStringObfuscated, "GWorld", OffsetCalcType::GetOffsetFromOpcode, &Offsets::GWorld, 0x3), Make(&GObjectsaddress, GObjetcsStringObfuscated, "GObjects", OffsetCalcType::GetOffsetFromOpcode, &Offsets::GObjects, 0x3), Make(&AppendStringaddress, AppendStringStringObfuscated, "AppendString", OffsetCalcType::UE_CalculateOffset, &Offsets::AppendString), Make(&ProcessEventaddress, ProcessEventStringObfuscated, "ProcessEvent", OffsetCalcType::UE_CalculateOffset, &Offsets::ProcessEvent) }; // Retrieve all Unreal Engine offsets in a batch Memory::OffsetScanBatch(UEoffsetsScans, baseModule, logger, ""); if (!init) logger->info("-------------- Fixes initialisation -------------"); } } if (init && g_fix_enabled) logger->info("-------------- Fixes initialisation -------------"); if (!init && FOVaddress) FOVFixEnabled(); if (!init && Cameraaddress) CameraFixEnabled(); if (!init && HUDaddress) HUDFixEnabled(); if (!init && CAaddress) CAFixEnabled(); if (!init && Vignettingaddress) VignettingFixEnabled(); if (!init && Fogaddress) FogFixEnabled(); if (!init && GObjectsaddress && AppendStringaddress && ProcessEventaddress) EnableConsole(); if (FOVaddress) UltraWideFixEnabled(); } // Setters for Reshade addon call extern "C" __declspec(dllexport) void SetFixesEnabled(GameFixes fix, bool enabled) { if (fix == GameFixes::DevConsole) { g_Console = enabled; EnableConsole(); }; if (fix == GameFixes::FOV) { g_fov_fix_enabled = enabled; FOVFixEnabled(); } if (fix == GameFixes::Camera) { g_camera_fix_enabled = enabled; CameraFixEnabled(); } if (fix == GameFixes::HUD) { g_HUD_fix_enabled = enabled; HUDFixEnabled(); } if (fix == GameFixes::ChromaticAberrations) { g_CA_fix_enabled = enabled; CAFixEnabled(); } if (fix == GameFixes::Vignetting) { g_Vignetting_fix_enabled = enabled; VignettingFixEnabled(); } if (fix == GameFixes::Fog) { g_Fog_fix_enabled = enabled; FogFixEnabled(); } if (fix == GameFixes::TimeDilation) { g_TimeDilation_fix_enabled = enabled; EnableCheats(Cheat::TimeDilation); } if (fix == GameFixes::GodMode) { g_GodMode_fix_enabled = enabled; EnableCheats(Cheat::GodMode); } if (fix == GameFixes::IgnoreHits) { g_IgnoreHits_fix_enabled = enabled; EnableCheats(Cheat::IgnoreHits); } if (fix == GameFixes::Stealth) { g_Stealth_fix_enabled = enabled; EnableCheats(Cheat::Stealth); } } extern "C" __declspec(dllexport) void SetFOV(int fov) { g_AdditionalFOVValue = fov; } extern "C" __declspec(dllexport) void SetCameraOffset(int cameraOffset) { g_CameraOffset = cameraOffset + 80; g_TransitionCameraOffset = (float)g_CameraOffset; } extern "C" __declspec(dllexport) void SetHUDScale(int HUDScale) { g_HUDLeft = (float)HUDScale / 100; g_HUDRight = 1.f - ((float)HUDScale / 100); } extern "C" __declspec(dllexport) void SetWorldTimeDilation(float timeDilation) { g_WorldTimeDilationValue = timeDilation; } extern "C" __declspec(dllexport) void SetAITimeDilation(float timeDilation) { g_AITimeDilationValue = timeDilation; } extern "C" __declspec(dllexport) void SetCameraSmoothness(float smoothness) { g_CameraSmoothnessValue = smoothness; } // Unreal Engine functions /** * @brief Gets the current player Pawn from the world. * @param world Optional UWorld pointer. * @return Player Pawn or nullptr. */ static APawn* GetPawnFromWorld(UWorld* world = nullptr) { if (!world) UWorld* world = UWorld::GetWorld(); if (!world) return nullptr; UGameInstance* gameInstance = world->OwningGameInstance; if (!gameInstance || gameInstance->LocalPlayers.Num() == 0) return nullptr; ULocalPlayer* localPlayer = gameInstance->LocalPlayers[0]; if (!localPlayer) return nullptr; APlayerController* pc = localPlayer->PlayerController; if (!pc) return nullptr; APawn* pawn = pc->AcknowledgedPawn; return pawn; } static APhxCharacter* GetPhxCharacterFromPawn(APawn* pawn) { void* inventoryComp = *(void**)((uintptr_t)pawn + 0x6d8); // inventoryComp offset from SDK void* moveComp = *(void**)((uintptr_t)pawn + 0x908); // moveComp offset FROM SDK if (inventoryComp && moveComp) { APhxCharacter* phxChar = static_cast(pawn); if (phxChar) return phxChar; } return nullptr; } // Miscellaneous functions static inline double NowSeconds() { using namespace std::chrono; static steady_clock::time_point start = steady_clock::now(); return duration(steady_clock::now() - start).count(); } // Getters for Reshade addon call extern "C" __declspec(dllexport) void GetGameInfos(GameInfos* infos) { if (!infos) return; infos->FOVIn = g_FOV_In; infos->FOVOut = g_FOV_Out; infos->CompensatedFOV = g_NativeCameraDistance; infos->consoleEnabled = g_Console_Enabled; } // Code injection functions static void FOVFixEnabled() { if (g_fix_enabled && g_fov_fix_enabled && FOVaddress) { if (!FOVHook) { // Hook only once FOVHook = safetyhook::create_mid(FOVaddress + 0xa, [](SafetyHookContext& ctx) { g_FOV_In = ctx.xmm0.f32[0]; ctx.xmm0.f32[0] += g_AdditionalFOVValue; // Additional FOV g_FOV_Out = ctx.xmm0.f32[0]; }); } else FOVHook.enable(); logger->info("FOV fix enabled"); } if (!(g_fix_enabled && g_fov_fix_enabled) && FOVaddress) { if (FOVHook) FOVHook.disable(); logger->info("FOV fix disabled"); } } static void CameraFixEnabled() { if (g_fix_enabled && g_camera_fix_enabled && ProcessEventaddress) { if (!PEHook) { PEHook = safetyhook::create_mid(ProcessEventaddress + 0xc, [](SafetyHookContext& ctx) { UObject* object = (UObject*)ctx.rcx; UFunction* func = (UFunction*)ctx.rdx; if (object && func) { std::string funcName = func->GetName(); std::string objectName = object->GetName(); std::string objectFullName = object->GetFullName(); static auto start = std::chrono::high_resolution_clock::now(); // Detect when benchmark or performance test is not launched if (objectName.contains("WBP_MainMenu_C") && funcName == "OnInitialized") bIsInBenchmarkMode = false; // Detect cinematics to disable temporarily camera fix if (objectFullName.contains("CineCameraComponent") && funcName == "SetCurrentFocalLength") { bIsInCinematicMode = true; LastCineCallTime = NowSeconds(); } // Detect reforge station interactions to disable temporarily camera fix if (objectFullName.contains("BP_PrinterTabs_C")) { if (funcName == "Show") bIsInPrinterMode = true; if (funcName == "Hide") bIsInPrinterMode = false; } // Detect inventory interactions to disable temporarily camera fix if (objectFullName.contains("BP_State_Inventory_C")) { if (funcName == "OnBegin") bIsInventoryOpen = true; if (funcName == "OnEnd") bIsInventoryOpen = false; } // Detect camera collisions to avoid world to vanish ending in character death if (objectFullName.contains("CameraModifier_PhxCameraRig") && funcName == "BlueprintModifyCamera") { auto* cameraParams = reinterpret_cast(ctx.r8); if (!cameraParams) return; if (cameraParams->DeltaTime > 0.f && cameraParams->DeltaTime < 0.1f) g_LastCameraDeltaTime = cameraParams->DeltaTime; // --- World to Pawn (player) --- UWorld* world = UWorld::GetWorld(); if (!world) return; APawn* pawn = GetPawnFromWorld(world); if (!pawn) return; // Retrieve PhxCharacter class APhxCharacter* phxChar = GetPhxCharacterFromPawn(pawn); if (phxChar) bIsAiming = phxChar->bIsAiming; // Is player aiming ? // --- Positions --- FVector pawnPos = pawn->K2_GetActorLocation(); FVector engineCamPos = cameraParams->ViewLocation; // --- Camera direction --- Vector forward = RotatorToForwardVector(*reinterpret_cast(&cameraParams->ViewRotation)); // Transform own vector into UE SDK vector FVector forwardVector { forward.X , forward.Y, forward.Z }; FVector backward = forwardVector * -1.f; // --- ENGINE OFFSET (full) --- FVector engineOffset = engineCamPos - pawnPos; // --- DECOMPOSE OFFSET --- // Projection of engine offset onto backward axis (recul moteur) float engineBackDist = engineOffset.Dot(backward); g_NativeCameraDistance = engineBackDist; FVector backComponent = backward * engineBackDist; // No need to set camera offset in these modes if (bIsInBenchmarkMode || bIsInCinematicMode || bIsAiming) return; // What we KEEP (height + lateral) FVector preservedOffset = engineOffset - backComponent; // --- Desired corrected distance --- float maxDistance = g_TransitionCameraOffset; FVector traceStart = pawnPos /*+ preservedOffset*/; FVector traceEnd = traceStart + backward * maxDistance; // --- Sphere Trace --- TArray ignoreActors; TArray hits; float radius = 12.f; bool bHit = UKismetSystemLibrary::SphereTraceMulti( object, traceStart, traceEnd, radius, ETraceTypeQuery::TraceTypeQuery2, // camera channel true, ignoreActors, EDrawDebugTrace::None, &hits, true, FLinearColor(1, 0, 0, 1), FLinearColor(0, 1, 0, 1), 0.f); // --- Compute target distance --- float targetDist = maxDistance; if (bHit && hits.Num() > 0) { float best = maxDistance; float padding = 15.f; for (const FHitResult& hit : hits) { if (hit.bStartPenetrating) continue; if (hit.PenetrationDepth > 2.f) continue; float dist = (hit.Location - traceStart).Magnitude(); dist -= padding; dist = std::max(dist, 0.f); if (dist < best) best = dist; } targetDist = best; } // --- Smoothing --- static float lastSafeDistance = -1.f; if (lastSafeDistance < 0.f) lastSafeDistance = targetDist; float interpSpeed = (targetDist < lastSafeDistance) ? 14.f : 6.f; float alpha = std::clamp(interpSpeed * cameraParams->DeltaTime, 0.f, 1.f); lastSafeDistance = UKismetMathLibrary::Lerp(lastSafeDistance, targetDist, alpha); lastSafeDistance = std::clamp(lastSafeDistance, 0.f, maxDistance); // --- FINAL CAMERA POSITION --- FVector finalCamPos = pawnPos + preservedOffset + backward * lastSafeDistance; if (!world->K2_GetWorldSettings()) return; // --- APPLY --- cameraParams->NewViewLocation = finalCamPos; cameraParams->NewViewRotation = cameraParams->ViewRotation; cameraParams->NewFOV = cameraParams->FOV; } } }); } else PEHook.enable(); } if (!(g_fix_enabled && g_camera_fix_enabled) && ProcessEventaddress) if (PEHook) PEHook.disable(); if (g_fix_enabled && g_camera_fix_enabled && Cameraaddress) { if (!CameraHook) { CameraHook = safetyhook::create_mid(Cameraaddress, [](SafetyHookContext& ctx) { if (bIsInCinematicMode) { double now = NowSeconds(); if ((now - LastCineCallTime) > 1.0) // 1 second FOV is not changed -> cinematics = false bIsInCinematicMode = false; } float dt = g_LastCameraDeltaTime; if (dt <= 0.f || dt > 0.1f) dt = 1.f / 60.f; // Secure float targetOffset = g_CameraOffset; if (bIsInCinematicMode || bIsAiming) targetOffset = g_NativeCameraDistance; if (bIsInventoryOpen) targetOffset = INVENTORY_CAM_OFFSET; else if (bIsInPrinterMode) targetOffset = FORGE_CAM_OFFSET; g_TransitionCameraOffset = UKismetMathLibrary::FInterpTo(g_TransitionCameraOffset, targetOffset,dt, g_CameraSmoothnessValue); }); } else CameraHook.enable(); logger->info("Camera fix enabled"); } if (!(g_fix_enabled && g_camera_fix_enabled) && Cameraaddress) { if (CameraHook) CameraHook.disable(); logger->info("Camera fix disabled"); } if (g_fix_enabled && g_camera_fix_enabled && SetBenchmarkModeaddress) { if (!BenchmarkHook) { BenchmarkHook = safetyhook::create_mid(SetBenchmarkModeaddress, [](SafetyHookContext& ctx) { bIsInBenchmarkMode = true; }); } else BenchmarkHook.enable(); } if (!(g_fix_enabled && g_camera_fix_enabled) && SetBenchmarkModeaddress) if (BenchmarkHook) BenchmarkHook.disable(); } static void HUDFixEnabled() { if (g_fix_enabled && g_HUD_fix_enabled && HUDaddress) { if (!HUDHook) { // Hook only once HUDHook = safetyhook::create_mid(HUDaddress + 0xa, [](SafetyHookContext& ctx) { ctx.xmm0.f32[0] = g_HUDLeft; ctx.xmm0.f32[1] = 0.f; ctx.xmm0.f32[2] = g_HUDRight; ctx.xmm0.f32[3] = 1.f; }); } else HUDHook.enable(); logger->info("HUD fix enabled"); } if (!(g_fix_enabled && g_HUD_fix_enabled) && HUDaddress) { if (HUDHook) HUDHook.disable(); logger->info("HUD fix disabled"); } } static void EnableCheats(Cheat cheat) { if (WorldTimedilationaddress && !WorldTimeDilationHook) { WorldTimeDilationHook = safetyhook::create_mid(WorldTimedilationaddress + 0x20, [](SafetyHookContext& ctx) { // From AWorldSettings retrieved from world->K2_GetWorldSettings() ctx.xmm0.f32[0] = g_TimeDilation_fix_enabled ? g_WorldTimeDilationValue : 1.f; ULONGLONG now = GetTickCount64(); if (now - lastScanTick < DEFAULT_ACTORS_SCAN_BETWEEN_TICKS) return; lastScanTick = now; UWorld* world = UWorld::GetWorld(); if (!world) return; APawn* pawn = GetPawnFromWorld(world); if (!pawn) return; // Enemies time dilation & stealth for (int i = 0; i < world->Levels.Num(); i++) { // Loop through level to find actors ULevel* Level = world->Levels[i]; if (!Level) continue; for (int j = 0; j < Level->Actors.Num(); j++) { // Loop through actors AActor* actor = Level->Actors[j]; if (!actor || actor == pawn) continue; // We don't want to affect Jacob if (!actor->IsA(APhxAICharacter::StaticClass())) continue; // We want to affect enemies only actor->CustomTimeDilation = g_TimeDilation_fix_enabled ? g_AITimeDilationValue : 1.f; // Stealth APhxAICharacter* aiChar = static_cast(actor); if (!aiChar || !aiChar->SenseComponent) continue; // UPhxAISenseComponent class aiChar->SenseComponent->EnableSensing(!g_Stealth_fix_enabled); // Enemies won't be aware of Jacob } } // God mode AActor* jacob = static_cast(pawn); if (jacob) jacob->bCanBeDamaged = !g_GodMode_fix_enabled; // Jacob won't be hurt // Ignore hits APhxCharacter* phxChar = GetPhxCharacterFromPawn(pawn); if (phxChar) phxChar->bInvulnerable = g_IgnoreHits_fix_enabled; // Jacob can't be hit }); } if (cheat == Cheat::TimeDilation) logger->info("Time dilation cheat {}", g_TimeDilation_fix_enabled ? "enabled" : "disabled"); if (cheat == Cheat::GodMode) logger->info("God mode cheat {}", g_GodMode_fix_enabled ? "enabled" : "disabled"); if (cheat == Cheat::IgnoreHits) logger->info("Ignore hits cheat {}", g_IgnoreHits_fix_enabled ? "enabled" : "disabled"); if (cheat == Cheat::Stealth) logger->info("Stealth cheat {}", g_Stealth_fix_enabled ? "enabled" : "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; *reinterpret_cast(ctx.rax + 0x4) = g_fix_enabled && g_Fog_fix_enabled ? 0 : 1; // r.Fog = 0 }); } logger->info("Fog fix enabled"); } if (!(g_fix_enabled && g_Fog_fix_enabled) && Fogaddress) logger->info("Fog fix disabled"); } // Memory patch fixes static void UltraWideFixEnabled() { if (FOVaddress) Memory::PatchBytes(FOVaddress + 0x25, "\x31\xC0\x90\x90\x90\x90\x90", 7); // bConstrainAspectRatio = 0 } static void CAFixEnabled() { if (g_fix_enabled && g_CA_fix_enabled && CAaddress) { Memory::PatchBytes(CAaddress, "\x90\x90", 2); // NOP jg r.SceneColorFringeQuality = 0 logger->info("Chromatic aberrations fix enabled"); } if (!(g_fix_enabled && g_CA_fix_enabled) && CAaddress) { Memory::RestoreBytes(CAaddress); logger->info("Chromatic 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"); } } // UE Console creation static void EnableConsole() { if (g_Console_Enabled || !g_Console || !GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) { if (!g_Console && !user_inputs_logged) { logger->info("------------------ User inputs ------------------"); user_inputs_logged = true; } return; } logger->info("-------------- Console re-enabling --------------"); std::thread([&]() { auto start = std::chrono::high_resolution_clock::now(); // Measure the time to renable console UEngine* Engine = nullptr; for (int i = 0; i < 10; ++i) { // gives 10 seconds to find UE Engine std::this_thread::sleep_for(std::chrono::milliseconds(1000)); 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); // Compute console enabling duration 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 ------------------"); // Enable cheat commands through console if (CheatManageraddress) Memory::PatchBytes(CheatManageraddress, "\xB0\x01\x90\x90\x90\x90", 6); // mov al,1 g_Console_Enabled = true; } else { logger->error("Could not spawn console object"); logger->info("------------------ User inputs ------------------"); } }).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("The Callisto Protocol", 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; }