yindo/Project-Reboot-3.0
1
0
Fork 0
mirror of https://github.com/Milxnor/Project-Reboot-3.0.git synced 2026-01-13 19:02:21 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
f41be934eb951358a5253744d9ae2b0f36397840
Project-Reboot-3.0/Project Reboot 3.0/gui.h
Milxnor 3fb5c4671d a good update 
Added a very useful debugging tool, made looting even more proper
2023-05-09 22:37:04 -04:00

1221 lines
36 KiB
C++
Raw Blame History

#pragma once
// TODO: Update ImGUI
#pragma comment(lib, "d3d9.lib")
#include <Windows.h>
#include <dxgi.h>
#include <d3d11.h>
#include <d3d9.h>
#include <ImGui/imgui.h>
#include <ImGui/imgui_impl_dx9.h>
#include <string>
#include <imgui/imgui_impl_win32.h>
#include <imgui/imgui_stdlib.h>
#include <vector>
#include <format>
#include <imgui/imgui_internal.h>
#include <set>
#include <fstream>
#include <olectl.h>
#include "FortAthenaMutator_Disco.h"
#include "globals.h"
#include "Fonts/ruda-bold.h"
#include "Vector.h"
#include "reboot.h"
#include "FortGameModeAthena.h"
#include "UnrealString.h"
#include "KismetTextLibrary.h"
#include "KismetSystemLibrary.h"
#include "GameplayStatics.h"
#include "Text.h"
#include <Images/reboot_icon.h>
#include "FortGadgetItemDefinition.h"
#include "FortWeaponItemDefinition.h"
#include "events.h"
#include "FortAthenaMutator_Heist.h"
#include "BGA.h"
#include "objectviewer.h"
#define GAME_TAB 1
#define PLAYERS_TAB 2
#define GAMEMODE_TAB 3
#define THANOS_TAB 4
#define EVENT_TAB 5
#define LATEGAME_TAB 6
#define DUMP_TAB 7
#define UNBAN_TAB 8
#define DEVELOPER_TAB 9
#define DEBUGLOG_TAB 10
#define SETTINGS_TAB 11
#define CREDITS_TAB 12
#define MAIN_PLAYERTAB 1
#define INVENTORY_PLAYERTAB 2
#define LOADOUT_PLAYERTAB 4
#define FUN_PLAYERTAB 5
extern inline int SecondsUntilTravel = 5;
extern inline bool bSwitchedInitialLevel = false;
extern inline bool bIsInAutoRestart = false;
extern inline float AutoBusStartSeconds = 60;
extern inline int NumRequiredPlayersToStart = 2;
extern inline bool bDebugPrintLooting = false;
extern inline bool bDebugPrintSwapping = false;
extern inline bool bEnableBotTick = false;
extern inline bool bEnableCombinePickup = false;
extern inline int AmountOfBotsToSpawn = 0;
// THE BASE CODE IS FROM IMGUI GITHUB
static inline LPDIRECT3D9 g_pD3D = NULL;
static inline LPDIRECT3DDEVICE9 g_pd3dDevice = NULL;
static inline D3DPRESENT_PARAMETERS g_d3dpp = {};
// Forward declarations of helper functions
static inline bool CreateDeviceD3D(HWND hWnd);
static inline void CleanupDeviceD3D();
static inline void ResetDevice();
static inline LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
extern inline bool bStartedBus = false;
static inline void Restart() // todo move?
{
FString LevelA = Engine_Version < 424
? L"open Athena_Terrain" : Engine_Version >= 500 ? Engine_Version >= 501
? L"open Asteria_Terrain"
: Globals::bCreative ? L"open Creative_NoApollo_Terrain"
: L"open Artemis_Terrain"
: Globals::bCreative ? L"open Creative_NoApollo_Terrain"
: L"open Apollo_Terrain";
static auto BeaconClass = FindObject<UClass>(L"/Script/FortniteGame.FortOnlineBeaconHost");
auto AllFortBeacons = UGameplayStatics::GetAllActorsOfClass(GetWorld(), BeaconClass);
for (int i = 0; i < AllFortBeacons.Num(); i++)
{
AllFortBeacons.at(i)->K2_DestroyActor();
}
AllFortBeacons.Free();
Globals::bInitializedPlaylist = false;
Globals::bStartedListening = false;
Globals::bHitReadyToStartMatch = false;
bStartedBus = false;
AmountOfRestarts++;
LOG_INFO(LogDev, "Switching!");
if (Fortnite_Version >= 3) // idk what ver
{
((AGameMode*)GetWorld()->GetGameMode())->RestartGame();
}
else
{
UKismetSystemLibrary::ExecuteConsoleCommand(GetWorld(), LevelA, nullptr);
}
/*
auto& LevelCollections = GetWorld()->Get<TArray<__int64>>("LevelCollections");
int LevelCollectionSize = FindObject<UStruct>("/Script/Engine.LevelCollection")->GetPropertiesSize();
*(UNetDriver**)(__int64(LevelCollections.AtPtr(0, LevelCollectionSize)) + 0x10) = nullptr;
*(UNetDriver**)(__int64(LevelCollections.AtPtr(1, LevelCollectionSize)) + 0x10) = nullptr;
*/
// UGameplayStatics::OpenLevel(GetWorld(), UKismetStringLibrary::Conv_StringToName(LevelA), true, FString());
}
static inline std::string wstring_to_utf8(const std::wstring& str)
{
if (str.empty()) return {};
const auto size_needed = WideCharToMultiByte(CP_UTF8, 0, &str[0], static_cast<int>(str.size()), nullptr, 0, nullptr, nullptr);
std::string str_to(size_needed, 0);
WideCharToMultiByte(CP_UTF8, 0, &str[0], static_cast<int>(str.size()), &str_to[0], size_needed, nullptr, nullptr);
return str_to;
}
static inline void InitStyle()
{
ImFontConfig FontConfig;
FontConfig.FontDataOwnedByAtlas = false;
ImGui::GetIO().Fonts->AddFontFromMemoryTTF((void*)ruda_bold_data, sizeof(ruda_bold_data), 17.f, &FontConfig);
// ImGui::GetIO().Fonts->AddFontFromFileTTF("Reboot Resources/fonts/ruda-bold.ttf", 17);
auto& mStyle = ImGui::GetStyle();
mStyle.FramePadding = ImVec2(4, 2);
mStyle.ItemSpacing = ImVec2(6, 2);
mStyle.ItemInnerSpacing = ImVec2(6, 4);
mStyle.Alpha = 0.95f;
mStyle.WindowRounding = 4.0f;
mStyle.FrameRounding = 2.0f;
mStyle.IndentSpacing = 6.0f;
mStyle.ItemInnerSpacing = ImVec2(2, 4);
mStyle.ColumnsMinSpacing = 50.0f;
mStyle.GrabMinSize = 14.0f;
mStyle.GrabRounding = 16.0f;
mStyle.ScrollbarSize = 12.0f;
mStyle.ScrollbarRounding = 16.0f;
ImGuiStyle& style = mStyle;
style.Colors[ImGuiCol_Text] = ImVec4(0.86f, 0.93f, 0.89f, 0.78f);
style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.86f, 0.93f, 0.89f, 0.28f);
style.Colors[ImGuiCol_WindowBg] = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
style.Colors[ImGuiCol_Border] = ImVec4(0.31f, 0.31f, 1.00f, 0.00f);
style.Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
style.Colors[ImGuiCol_FrameBg] = ImVec4(0.20f, 0.22f, 0.27f, 1.00f);
style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.92f, 0.18f, 0.29f, 0.78f);
style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_TitleBg] = ImVec4(0.20f, 0.22f, 0.27f, 1.00f);
style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.20f, 0.22f, 0.27f, 0.75f);
style.Colors[ImGuiCol_TitleBgActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_MenuBarBg] = ImVec4(0.20f, 0.22f, 0.27f, 0.47f);
style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.20f, 0.22f, 0.27f, 1.00f);
style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.09f, 0.15f, 0.16f, 1.00f);
style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.92f, 0.18f, 0.29f, 0.78f);
style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_CheckMark] = ImVec4(0.71f, 0.22f, 0.27f, 1.00f);
style.Colors[ImGuiCol_SliderGrab] = ImVec4(0.47f, 0.77f, 0.83f, 0.14f);
style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_Button] = ImVec4(0.47f, 0.77f, 0.83f, 0.14f);
style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.92f, 0.18f, 0.29f, 0.86f);
style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_Header] = ImVec4(0.92f, 0.18f, 0.29f, 0.76f);
style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.92f, 0.18f, 0.29f, 0.86f);
style.Colors[ImGuiCol_HeaderActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_Separator] = ImVec4(0.14f, 0.16f, 0.19f, 1.00f);
style.Colors[ImGuiCol_SeparatorHovered] = ImVec4(0.92f, 0.18f, 0.29f, 0.78f);
style.Colors[ImGuiCol_SeparatorActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_ResizeGrip] = ImVec4(0.47f, 0.77f, 0.83f, 0.04f);
style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.92f, 0.18f, 0.29f, 0.78f);
style.Colors[ImGuiCol_ResizeGripActive] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_PlotLines] = ImVec4(0.86f, 0.93f, 0.89f, 0.63f);
style.Colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_PlotHistogram] = ImVec4(0.86f, 0.93f, 0.89f, 0.63f);
style.Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(0.92f, 0.18f, 0.29f, 1.00f);
style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.92f, 0.18f, 0.29f, 0.43f);
style.Colors[ImGuiCol_PopupBg] = ImVec4(0.20f, 0.22f, 0.27f, 0.9f);
}
static inline void TextCentered(std::string text, bool bNewLine = true) {
if (bNewLine)
ImGui::NewLine();
float win_width = ImGui::GetWindowSize().x;
float text_width = ImGui::CalcTextSize(text.c_str()).x;
// calculate the indentation that centers the text on one line, relative
// to window left, regardless of the `ImGuiStyleVar_WindowPadding` value
float text_indentation = (win_width - text_width) * 0.5f;
// if text is too long to be drawn on one line, `text_indentation` can
// become too small or even negative, so we check a minimum indentation
float min_indentation = 20.0f;
if (text_indentation <= min_indentation) {
text_indentation = min_indentation;
}
ImGui::SameLine(text_indentation);
ImGui::PushTextWrapPos(win_width - text_indentation);
ImGui::TextWrapped(text.c_str());
ImGui::PopTextWrapPos();
}
static inline bool ButtonCentered(std::string text, bool bNewLine = true) {
if (bNewLine)
ImGui::NewLine();
float win_width = ImGui::GetWindowSize().x;
float text_width = ImGui::CalcTextSize(text.c_str()).x;
// calculate the indentation that centers the text on one line, relative
// to window left, regardless of the `ImGuiStyleVar_WindowPadding` value
float text_indentation = (win_width - text_width) * 0.5f;
// if text is too long to be drawn on one line, `text_indentation` can
// become too small or even negative, so we check a minimum indentation
float min_indentation = 20.0f;
if (text_indentation <= min_indentation) {
text_indentation = min_indentation;
}
ImGui::SameLine(text_indentation);
ImGui::PushTextWrapPos(win_width - text_indentation);
auto res = ImGui::Button(text.c_str());
ImGui::PopTextWrapPos();
return res;
}
static inline void InputVector(const std::string& baseText, FVector* vec)
{
ImGui::InputFloat((baseText + " X").c_str(), &vec->X);
ImGui::InputFloat((baseText + " Y").c_str(), &vec->Y);
ImGui::InputFloat((baseText + " Z").c_str(), &vec->Z);
}
static int Width = 640;
static int Height = 480;
static int Tab = 1;
static int PlayerTab = -1;
static bool bIsEditingInventory = false;
static bool bInformationTab = false;
static int playerTabTab = MAIN_PLAYERTAB;
static inline void StaticUI()
{
if (IsRestartingSupported())
{
ImGui::Checkbox("Auto Restart", &Globals::bAutoRestart);
if (Globals::bAutoRestart)
{
ImGui::InputFloat(std::format("How long after {} players join the bus will start", NumRequiredPlayersToStart).c_str(), &AutoBusStartSeconds);
ImGui::InputInt("How many players required to join for bus auto timer to start", &NumRequiredPlayersToStart);
}
}
#ifndef PROD
ImGui::Checkbox("Log ProcessEvent", &Globals::bLogProcessEvent);
// ImGui::InputInt("Amount of bots to spawn", &AmountOfBotsToSpawn);
#endif
ImGui::Checkbox("Infinite Ammo", &Globals::bInfiniteAmmo);
ImGui::Checkbox("Infinite Materials", &Globals::bInfiniteMaterials);
ImGui::Checkbox("No MCP (Don't change unless you know what this is)", &Globals::bNoMCP);
if (Addresses::ApplyGadgetData && Addresses::RemoveGadgetData && Engine_Version < 424)
{
ImGui::Checkbox("Enable AGIDs (Don't change unless you know what this is)", &Globals::bEnableAGIDs);
}
}
static inline void MainTabs()
{
// std::ofstream bannedStream(Moderation::Banning::GetFilePath());
if (ImGui::BeginTabBar(""))
{
if (ImGui::BeginTabItem("Game"))
{
Tab = GAME_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
// if (serverStatus == EServerStatus::Up)
{
/* if (ImGui::BeginTabItem("Players"))
{
Tab = PLAYERS_TAB;
ImGui::EndTabItem();
} */
}
if (false && ImGui::BeginTabItem("Gamemode"))
{
Tab = GAMEMODE_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
// if (Events::HasEvent())
if (Globals::bGoingToPlayEvent)
{
if (ImGui::BeginTabItem(("Event")))
{
Tab = EVENT_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
}
if (false && Globals::bLateGame && ImGui::BeginTabItem(("Lategame")))
{
Tab = LATEGAME_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Dump"))
{
Tab = DUMP_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
#if 0
if (bannedStream.is_open() && ImGui::BeginTabItem("Unban")) // skunked
{
Tab = UNBAN_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
#endif
/* if (ImGui::BeginTabItem(("Settings")))
{
Tab = SETTINGS_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
} */
// maybe a Replication Stats for >3.3?
#ifndef PROD
if (ImGui::BeginTabItem("Developer"))
{
Tab = DEVELOPER_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Debug Logs"))
{
Tab = DEBUGLOG_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
#endif
if (false && ImGui::BeginTabItem(("Credits")))
{
Tab = CREDITS_TAB;
PlayerTab = -1;
bInformationTab = false;
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
static inline void PlayerTabs()
{
if (ImGui::BeginTabBar(""))
{
if (ImGui::BeginTabItem("Main"))
{
playerTabTab = MAIN_PLAYERTAB;
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem(("Inventory")))
{
playerTabTab = INVENTORY_PLAYERTAB;
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem(("Cosmetics")))
{
playerTabTab = LOADOUT_PLAYERTAB;
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem(("Fun")))
{
playerTabTab = FUN_PLAYERTAB;
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
static inline void MainUI()
{
bool bLoaded = true;
if (PlayerTab == -1)
{
MainTabs();
if (Tab == GAME_TAB)
{
if (bLoaded)
{
StaticUI();
if (!bStartedBus)
{
bool bWillBeLategame = Globals::bLateGame.load();
ImGui::Checkbox("Lategame", &bWillBeLategame);
Globals::bLateGame.store(bWillBeLategame);
}
ImGui::Text(std::format("Joinable {}", Globals::bStartedListening).c_str());
static std::string ConsoleCommand;
ImGui::InputText("Console command", &ConsoleCommand);
if (ImGui::Button("Execute console command"))
{
auto wstr = std::wstring(ConsoleCommand.begin(), ConsoleCommand.end());
auto aa = wstr.c_str();
FString cmd = aa;
UKismetSystemLibrary::ExecuteConsoleCommand(GetWorld(), cmd, nullptr);
}
if (ImGui::Button("Spawn BGAs"))
{
SpawnBGAs();
}
if (!bIsInAutoRestart && (Engine_Version < 424 && ImGui::Button("Restart")))
{
if (Engine_Version < 424)
{
Restart();
LOG_INFO(LogGame, "Restarting!");
}
else
{
LOG_ERROR(LogGame, "Restarting is not supported on chapter 2 and above!");
}
}
if (!bStartedBus)
{
if (Globals::bLateGame.load())
{
if (ImGui::Button("Start Bus"))
{
bStartedBus = true;
auto GameMode = (AFortGameMode*)GetWorld()->GetGameMode();
auto GameState = GameMode->GetGameState();
UKismetSystemLibrary::ExecuteConsoleCommand(GetWorld(), L"startaircraft", nullptr);
auto GetAircrafts = [&]() -> TArray<AActor*>
{
static auto AircraftsOffset = GameState->GetOffset("Aircrafts", false);
if (AircraftsOffset == -1)
{
// GameState->Aircraft
static auto FortAthenaAircraftClass = FindObject<UClass>("/Script/FortniteGame.FortAthenaAircraft");
auto AllAircrafts = UGameplayStatics::GetAllActorsOfClass(GetWorld(), FortAthenaAircraftClass);
return AllAircrafts;
}
return GameState->Get<TArray<AActor*>>(AircraftsOffset);
};
while (GetAircrafts().Num() <= 0) // hmm
{
Sleep(500);
}
UKismetSystemLibrary::ExecuteConsoleCommand(GetWorld(), L"startsafezone", nullptr);
static auto SafeZoneIndicatorOffset = GameState->GetOffset("SafeZoneIndicator");
static auto SafeZonesStartTimeOffset = GameState->GetOffset("SafeZonesStartTime");
GameState->Get<float>(SafeZonesStartTimeOffset) = 0;
while (!GameState->Get(SafeZoneIndicatorOffset))
{
Sleep(500);
}
while (GetAircrafts().Num() <= 0) // hmm
{
Sleep(500);
}
static auto NextNextCenterOffset = GameState->Get(SafeZoneIndicatorOffset)->GetOffset("NextNextCenter", false);
static auto NextCenterOffset = GameState->Get(SafeZoneIndicatorOffset)->GetOffset("NextCenter");
FVector LocationToStartAircraft = GameState->Get(SafeZoneIndicatorOffset)->Get<FVector>(NextNextCenterOffset == -1 ? NextCenterOffset : NextNextCenterOffset); // SafeZoneLocations.at(4);
LocationToStartAircraft.Z += 10000;
for (int i = 0; i < GetAircrafts().Num(); i++)
{
auto CurrentAircraft = GetAircrafts().at(i);
CurrentAircraft->TeleportTo(LocationToStartAircraft, FRotator());
static auto FlightInfoOffset = CurrentAircraft->GetOffset("FlightInfo", false);
float FlightSpeed = 0.0f;
if (FlightInfoOffset == -1)
{
static auto FlightStartLocationOffset = CurrentAircraft->GetOffset("FlightStartLocation");
static auto FlightSpeedOffset = CurrentAircraft->GetOffset("FlightSpeed");
static auto DropStartTimeOffset = CurrentAircraft->GetOffset("DropStartTime");
CurrentAircraft->Get<FVector>(FlightStartLocationOffset) = LocationToStartAircraft;
CurrentAircraft->Get<float>(FlightSpeedOffset) = FlightSpeed;
CurrentAircraft->Get<float>(DropStartTimeOffset) = GameState->GetServerWorldTimeSeconds();
}
else
{
auto FlightInfo = CurrentAircraft->GetPtr<FAircraftFlightInfo>(FlightInfoOffset);
FlightInfo->GetFlightSpeed() = FlightSpeed;
FlightInfo->GetFlightStartLocation() = LocationToStartAircraft;
FlightInfo->GetTimeTillDropStart() = 0.0f;
}
}
static auto MapInfoOffset = GameState->GetOffset("MapInfo");
auto MapInfo = GameState->Get(MapInfoOffset);
if (MapInfo)
{
static auto FlightInfosOffset = MapInfo->GetOffset("FlightInfos", false);
if (FlightInfosOffset != -1)
{
auto& FlightInfos = MapInfo->Get<TArray<FAircraftFlightInfo>>(FlightInfosOffset);
LOG_INFO(LogDev, "FlightInfos.Num(): {}", FlightInfos.Num());
for (int i = 0; i < FlightInfos.Num(); i++)
{
auto FlightInfo = FlightInfos.AtPtr(i, FAircraftFlightInfo::GetStructSize());
FlightInfo->GetFlightSpeed() = 0;
FlightInfo->GetFlightStartLocation() = LocationToStartAircraft;
FlightInfo->GetTimeTillDropStart() = 0.0f;
}
}
}
static auto bAircraftIsLockedOffset = GameState->GetOffset("bAircraftIsLocked");
static auto bAircraftIsLockedFieldMask = GetFieldMask(GameState->GetProperty("bAircraftIsLocked"));
GameState->SetBitfieldValue(bAircraftIsLockedOffset, bAircraftIsLockedFieldMask, false);
}
}
else
{
if (ImGui::Button("Start Bus Countdown"))
{
bStartedBus = true;
auto GameMode = (AFortGameMode*)GetWorld()->GetGameMode();
auto GameState = GameMode->GetGameState();
if (Fortnite_Version == 1.11)
{
static auto OverrideBattleBusSkin = FindObject("/Game/Athena/Items/Cosmetics/BattleBuses/BBID_WinterBus.BBID_WinterBus");
LOG_INFO(LogDev, "OverrideBattleBusSkin: {}", __int64(OverrideBattleBusSkin));
if (OverrideBattleBusSkin)
{
static auto AssetManagerOffset = GetEngine()->GetOffset("AssetManager");
auto AssetManager = GetEngine()->Get(AssetManagerOffset);
if (AssetManager)
{
static auto AthenaGameDataOffset = AssetManager->GetOffset("AthenaGameData");
auto AthenaGameData = AssetManager->Get(AthenaGameDataOffset);
if (AthenaGameData)
{
static auto DefaultBattleBusSkinOffset = AthenaGameData->GetOffset("DefaultBattleBusSkin");
AthenaGameData->Get(DefaultBattleBusSkinOffset) = OverrideBattleBusSkin;
}
}
static auto DefaultBattleBusOffset = GameState->GetOffset("DefaultBattleBus");
GameState->Get(DefaultBattleBusOffset) = OverrideBattleBusSkin;
static auto FortAthenaAircraftClass = FindObject<UClass>("/Script/FortniteGame.FortAthenaAircraft");
auto AllAircrafts = UGameplayStatics::GetAllActorsOfClass(GetWorld(), FortAthenaAircraftClass);
for (int i = 0; i < AllAircrafts.Num(); i++)
{
auto Aircraft = AllAircrafts.at(i);
static auto DefaultBusSkinOffset = Aircraft->GetOffset("DefaultBusSkin");
Aircraft->Get(DefaultBusSkinOffset) = OverrideBattleBusSkin;
static auto SpawnedCosmeticActorOffset = Aircraft->GetOffset("SpawnedCosmeticActor");
auto SpawnedCosmeticActor = Aircraft->Get<AActor*>(SpawnedCosmeticActorOffset);
if (SpawnedCosmeticActor)
{
static auto ActiveSkinOffset = SpawnedCosmeticActor->GetOffset("ActiveSkin");
SpawnedCosmeticActor->Get(ActiveSkinOffset) = OverrideBattleBusSkin;
}
}
}
}
GameState->Get<float>("WarmupCountdownEndTime") = UGameplayStatics::GetTimeSeconds(GetWorld()) + 10;
}
}
}
}
}
else if (Tab == PLAYERS_TAB)
{
}
else if (Tab == EVENT_TAB)
{
if (ImGui::Button(std::format("Start {}", GetEventName()).c_str()))
{
StartEvent();
}
if (Fortnite_Version == 8.51)
{
if (ImGui::Button("Unvault DrumGun"))
{
static auto SetUnvaultItemNameFn = FindObject<UFunction>("/Game/Athena/Prototype/Blueprints/White/BP_SnowScripting.BP_SnowScripting_C.SetUnvaultItemName");
auto EventScripting = GetEventScripting();
if (EventScripting)
{
FName Name = UKismetStringLibrary::Conv_StringToName(L"DrumGun");
EventScripting->ProcessEvent(SetUnvaultItemNameFn, &Name);
static auto PillarsConcludedFn = FindObject<UFunction>("/Game/Athena/Prototype/Blueprints/White/BP_SnowScripting.BP_SnowScripting_C.PillarsConcluded");
EventScripting->ProcessEvent(PillarsConcludedFn, &Name);
}
}
}
}
else if (Tab == DUMP_TAB)
{
ImGui::Text("These will all be in your Win64 folder!");
static std::string FortniteVersionStr = std::format("Fortnite Version {}\n\n", std::to_string(Fortnite_Version));
if (ImGui::Button("Dump Objects"))
{
auto ObjectNum = ChunkedObjects ? ChunkedObjects->Num() : UnchunkedObjects ? UnchunkedObjects->Num() : 0;
std::ofstream obj("ObjectsDump.txt");
obj << FortniteVersionStr;
for (int i = 0; i < ObjectNum; i++)
{
auto CurrentObject = GetObjectByIndex(i);
if (!CurrentObject)
continue;
obj << CurrentObject->GetFullName() << '\n';
}
}
if (ImGui::Button("Dump Skins (Skins.txt)"))
{
std::ofstream SkinsFile("Skins.txt");
if (SkinsFile.is_open())
{
SkinsFile << FortniteVersionStr;
static auto CIDClass = FindObject<UClass>("/Script/FortniteGame.AthenaCharacterItemDefinition");
auto AllObjects = GetAllObjectsOfClass(CIDClass);
for (int i = 0; i < AllObjects.size(); i++)
{
auto CurrentCID = AllObjects.at(i);
static auto DisplayNameOffset = CurrentCID->GetOffset("DisplayName");
FString DisplayNameFStr = UKismetTextLibrary::Conv_TextToString(CurrentCID->Get<FText>(DisplayNameOffset));
if (!DisplayNameFStr.Data.Data)
continue;
SkinsFile << std::format("[{}] {}\n", DisplayNameFStr.ToString(), CurrentCID->GetPathName());
}
}
}
if (ImGui::Button("Dump Playlists (Playlists.txt)"))
{
std::ofstream PlaylistsFile("Playlists.txt");
if (PlaylistsFile.is_open())
{
PlaylistsFile << FortniteVersionStr;
static auto FortPlaylistClass = FindObject<UClass>("/Script/FortniteGame.FortPlaylist");
// static auto FortPlaylistClass = FindObject("Class /Script/FortniteGame.FortPlaylistAthena");
auto AllObjects = GetAllObjectsOfClass(FortPlaylistClass);
for (int i = 0; i < AllObjects.size(); i++)
{
auto Object = AllObjects.at(i);
static auto UIDisplayNameOffset = Object->GetOffset("UIDisplayName");
FString PlaylistNameFStr = UKismetTextLibrary::Conv_TextToString(Object->Get<FText>(UIDisplayNameOffset));
if (!PlaylistNameFStr.Data.Data)
continue;
std::string PlaylistName = PlaylistNameFStr.ToString();
PlaylistsFile << std::format("[{}] {}\n", PlaylistName, Object->GetPathName());
}
}
else
std::cout << "Failed to open playlist file!\n";
}
if (ImGui::Button("Dump Weapons (Weapons.txt)"))
{
std::ofstream WeaponsFile("Weapons.txt");
if (WeaponsFile.is_open())
{
WeaponsFile << FortniteVersionStr;
auto DumpItemDefinitionClass = [&WeaponsFile](UClass* Class) {
auto AllObjects = GetAllObjectsOfClass(Class);
for (int i = 0; i < AllObjects.size(); i++)
{
auto Object = AllObjects.at(i);
static auto DisplayNameOffset = Object->GetOffset("DisplayName");
FString ItemDefinitionFStr = UKismetTextLibrary::Conv_TextToString(Object->Get<FText>(DisplayNameOffset));
if (!ItemDefinitionFStr.Data.Data)
continue;
std::string ItemDefinitionName = ItemDefinitionFStr.ToString();
// check if it contains gallery or playset and just ignore?
WeaponsFile << std::format("[{}] {}\n", ItemDefinitionName, Object->GetPathName());
}
};
DumpItemDefinitionClass(UFortWeaponItemDefinition::StaticClass());
DumpItemDefinitionClass(UFortGadgetItemDefinition::StaticClass());
DumpItemDefinitionClass(FindObject<UClass>("/Script/FortniteGame.FortAmmoItemDefinition"));
}
else
std::cout << "Failed to open playlist file!\n";
}
}
else if (Tab == UNBAN_TAB)
{
}
else if (Tab == DEVELOPER_TAB)
{
static std::string ClassNameToDump;
static std::string FunctionNameToDump;
static std::string ObjectToDump;
static std::string FileNameToDumpTo;
static bool bExcludeUnhandled;
ImGui::Checkbox("Fill Vending Machines", &Globals::bFillVendingMachines);
ImGui::Checkbox("Enable Bot Tick", &bEnableBotTick);
ImGui::Checkbox("Enable Combine Pickup", &bEnableCombinePickup);
ImGui::InputText("Class Name to mess with", &ClassNameToDump);
ImGui::InputText("Object to dump", &ObjectToDump);
ImGui::InputText("Function Name to mess with", &FunctionNameToDump);
ImGui::InputText("File name to dump to", &FileNameToDumpTo);
ImGui::Checkbox("Exclude unhandled", &bExcludeUnhandled);
if (ImGui::Button("Dump Object Info"))
{
auto Object = FindObject(ObjectToDump);
LOG_INFO(LogDev, "r: {}", __int64(Object));
// null check is already handled
ObjectViewer::DumpContentsToFile(Object, FileNameToDumpTo, bExcludeUnhandled);
}
if (ImGui::Button("Print Class VFT"))
{
auto Class = FindObject<UClass>(ClassNameToDump);
if (Class)
{
auto ClassToDump = Class->CreateDefaultObject();
if (ClassToDump)
{
LOG_INFO(LogDev, "{} VFT: 0x{:x}", ClassToDump->GetName(), __int64(ClassToDump->VFTable) - __int64(GetModuleHandleW(0)));
}
}
}
if (ImGui::Button("Print Function Exec Addr"))
{
auto Function = FindObject<UFunction>(FunctionNameToDump);
if (Function)
{
LOG_INFO(LogDev, "{} Exec: 0x{:x}", Function->GetName(), __int64(Function->GetFunc()) - __int64(GetModuleHandleW(0)));
}
}
/* if (ImGui::Button("Load BGA Class (and spawn so no GC)"))
{
static auto BGAClass = FindObject<UClass>("/Script/Engine.BlueprintGeneratedClass");
auto Class = LoadObject<UClass>(ClassNameToDump, BGAClass);
if (Class)
{
GetWorld()->SpawnActor<AActor>(Class, FVector());
}
} */
/*
ImGui::Text(std::format("Amount of hooks {}", AllFunctionHooks.size()).c_str());
for (auto& FunctionHook : AllFunctionHooks)
{
if (ImGui::Button(std::format("{} {} (0x{:x})", (FunctionHook.IsHooked ? "Unhook" : "Hook"), FunctionHook.Name, (__int64(FunctionHook.Original) - __int64(GetModuleHandleW(0)))).c_str()))
{
if (FunctionHook.IsHooked)
{
if (!FunctionHook.VFT || FunctionHook.Index == -1)
{
Hooking::MinHook::Unhook(FunctionHook.Original);
}
else
{
VirtualSwap(FunctionHook.VFT, FunctionHook.Index, FunctionHook.Original);
}
}
else
{
Hooking::MinHook::Hook(FunctionHook.Original, FunctionHook.Detour, nullptr, FunctionHook.Name);
}
FunctionHook.IsHooked = !FunctionHook.IsHooked;
}
}
*/
}
else if (Tab == DEBUGLOG_TAB)
{
ImGui::Checkbox("Looting Debug Log", &bDebugPrintLooting);
ImGui::Checkbox("Swapping Debug Log", &bDebugPrintSwapping);
}
else if (Tab == SETTINGS_TAB)
{
// ImGui::Checkbox("Use custom lootpool (from Win64/lootpool.txt)", &Defines::bCustomLootpool);
}
}
}
static inline void PregameUI()
{
StaticUI();
if (Engine_Version >= 422 && Engine_Version < 424)
{
ImGui::Checkbox("Creative", &Globals::bCreative);
}
if (Addresses::SetZoneToIndex)
{
bool bWillBeLategame = Globals::bLateGame.load();
ImGui::Checkbox("Lategame", &bWillBeLategame);
Globals::bLateGame.store(bWillBeLategame);
}
if (HasEvent())
{
ImGui::Checkbox("Play Event", &Globals::bGoingToPlayEvent);
}
if (!bSwitchedInitialLevel)
ImGui::SliderInt("Seconds until load into map", &SecondsUntilTravel, 1, 100);
if (!Globals::bCreative)
ImGui::InputText("Playlist", &PlaylistName);
}
static inline DWORD WINAPI GuiThread(LPVOID)
{
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, L"RebootClass", NULL };
::RegisterClassEx(&wc);
HWND hwnd = ::CreateWindowExW(0L, wc.lpszClassName, L"Project Reboot", (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX), 100, 100, Width, Height, NULL, NULL, wc.hInstance, NULL);
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, sizeof(reboot_icon_data));
if (!hGlobal)
{
LOG_WARN(LogDev, "Failed to allocate global icon data!");
}
else
{
void* data = GlobalLock(hGlobal);
memcpy(data, reboot_icon_data, sizeof(reboot_icon_data));
GlobalUnlock(hGlobal);
IStream* stream;
HRESULT hr = CreateStreamOnHGlobal(hGlobal, FALSE, &stream);
if (hr != S_OK)
{
// Handle error
}
HBITMAP hBitmap{};
HRESULT hr1 = CoInitialize(NULL);
hr1 = OleLoadPicture(stream, sizeof(reboot_icon_data), FALSE, IID_IPicture, (void**)&hBitmap);
stream->Release();
GlobalFree(hGlobal);
CoUninitialize();
if (hr1 != S_OK)
{
// Handle error
}
// Create the icon from the bitmap
ICONINFO iconInfo{};
iconInfo.fIcon = TRUE;
iconInfo.xHotspot = 0;
iconInfo.yHotspot = 0;
iconInfo.hbmMask = NULL;
iconInfo.hbmColor = hBitmap;
HICON hIcon = CreateIconIndirect(&iconInfo);
SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
// Cleanup the resources
DeleteObject(iconInfo.hbmColor);
}
// HANDLE hIcon = LoadImageW(wc.hInstance, L"Reboot Resources/images/reboot.ico", IMAGE_ICON, 48, 48, LR_LOADFROMFILE);
// SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
// SetWindowLongPtrW(hwnd, GWL_STYLE, WS_POPUP); // Disables windows title bar at the cost of dragging and some quality
// Initialize Direct3D
if (!CreateDeviceD3D(hwnd))
{
CleanupDeviceD3D();
::UnregisterClass(wc.lpszClassName, wc.hInstance);
return 1;
}
// Show the window
::ShowWindow(hwnd, SW_SHOWDEFAULT);
::UpdateWindow(hwnd);
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.IniFilename = NULL; // Disable imgui.ini generation.
io.DisplaySize = ImGui::GetMainViewport()->Size;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// io.Fonts->AddFontFromFileTTF("../vendor/fonts/Aller_Bd.ttf", 17);
// Setup Dear ImGui style
InitStyle();
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX9_Init(g_pd3dDevice);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
ImFontConfig config;
config.MergeMode = true;
config.GlyphMinAdvanceX = 13.0f; // Use if you want to make the icon monospaced
// static const ImWchar icon_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
// io.Fonts->AddFontFromFileTTF("Reboot Resources/fonts/fontawesome-webfont.ttf", 13.0f, &config, icon_ranges);
bool done = false;
while (!done)
{
MSG msg;
while (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
if (msg.message == WM_QUIT)
{
// done = true;
break;
}
}
ImGui_ImplDX9_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
auto WindowSize = ImGui::GetMainViewport()->Size;
// ImGui::SetNextWindowPos(ImVec2(WindowSize.x * 0.5f, WindowSize.y * 0.5f), ImGuiCond_Always, ImVec2(0.5f, 0.5f)); // Center
ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
tagRECT rect;
if (GetWindowRect(hwnd, &rect))
{
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
ImGui::SetNextWindowSize(ImVec2(width, height), ImGuiCond_Always);
}
if (!ImGui::IsWindowCollapsed())
{
ImGui::Begin("Project Reboot 3.0", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoTitleBar);
Globals::bInitializedPlaylist ? MainUI() : PregameUI();
ImGui::End();
}
// Rendering
ImGui::EndFrame();
g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
D3DCOLOR clear_col_dx = D3DCOLOR_RGBA((int)(clear_color.x * clear_color.w * 255.0f), (int)(clear_color.y * clear_color.w * 255.0f), (int)(clear_color.z * clear_color.w * 255.0f), (int)(clear_color.w * 255.0f));
g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, clear_col_dx, 1.0f, 0);
if (g_pd3dDevice->BeginScene() >= 0)
{
ImGui::Render();
ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
g_pd3dDevice->EndScene();
}
HRESULT result = g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
// Handle loss of D3D9 device
if (result == D3DERR_DEVICELOST && g_pd3dDevice->TestCooperativeLevel() == D3DERR_DEVICENOTRESET)
ResetDevice();
}
ImGui_ImplDX9_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
CleanupDeviceD3D();
::DestroyWindow(hwnd);
::UnregisterClass(wc.lpszClassName, wc.hInstance);
return 0;
}
// Helper functions
static inline bool CreateDeviceD3D(HWND hWnd)
{
if ((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
return false;
// Create the D3DDevice
ZeroMemory(&g_d3dpp, sizeof(g_d3dpp));
g_d3dpp.Windowed = TRUE;
g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
g_d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; // Need to use an explicit format with alpha if needing per-pixel alpha composition.
g_d3dpp.EnableAutoDepthStencil = TRUE;
g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // Present with vsync
//g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // Present without vsync, maximum unthrottled framerate
if (g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &g_d3dpp, &g_pd3dDevice) < 0)
return false;
return true;
}
static inline void CleanupDeviceD3D()
{
if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
if (g_pD3D) { g_pD3D->Release(); g_pD3D = NULL; }
}
static inline void ResetDevice()
{
ImGui_ImplDX9_InvalidateDeviceObjects();
HRESULT hr = g_pd3dDevice->Reset(&g_d3dpp);
if (hr == D3DERR_INVALIDCALL)
IM_ASSERT(0);
ImGui_ImplDX9_CreateDeviceObjects();
}
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
static inline LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
// my implementation of window dragging..
/* {
static int dababy = 0;
if (dababy > 100) // wait until gui is initialized ig?
{
if (ImGui::IsMouseDragging(ImGuiMouseButton(0)))
{
// if (LOWORD(lParam) > 255 && HIWORD(lParam) > 255)
{
POINT p;
GetCursorPos(&p);
SetWindowPos(hWnd, nullptr, p.x, p.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}
}
}
dababy++;
} */
if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
return true;
switch (msg)
{
case WM_SIZE:
if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
{
g_d3dpp.BackBufferWidth = LOWORD(lParam);
g_d3dpp.BackBufferHeight = HIWORD(lParam);
ResetDevice();
}
return 0;
case WM_SYSCOMMAND:
if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
return 0;
break;
case WM_DESTROY:
::PostQuitMessage(0);
return 0;
}
return ::DefWindowProc(hWnd, msg, wParam, lParam);
}
Reference in New Issue View Git Blame Copy Permalink