Backups/EscapeTheBackrooms_Internal
1
0
Fork 0
mirror of https://github.com/DumbDev69420/EscapeTheBackrooms_Internal.git synced 2024-12-22 22:47:30 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
7445db5af8
EscapeTheBackrooms_Internal/EscapeTheBackroomsGUiTest/Cheat.h

2845 lines
75 KiB
C
Raw Normal View History

Projektdateien hinzufügen.
2024-04-20 20:19:09 +08:00
#pragma once
#include <Windows.h>
#include <iostream>
#include "SDK/SDK.hpp"
#include <format>
#include <vector>
#include "Settings.h"
#define DEBUG
#define Gatekeep
void RunMainHost();
namespace Functions {
static void memcpy_(void* _Dst, void const* _Src, size_t _Size)
{
auto csrc = (char*)_Src;
auto cdest = (char*)_Dst;
for (int i = 0; i < _Size; i++)
{
cdest[i] = csrc[i];
}
}
//Generally just for checking dont call raw
DWORD GetMemoryProtection(LPVOID address)
{
MEMORY_BASIC_INFORMATION memInfo;
VirtualQuery(address, &memInfo, sizeof(memInfo));
return memInfo.Protect;
}
bool ShouldUsePointer64(void* ptrF) {
uintptr_t ptr = (uintptr_t)ptrF;
if (ptr == 0x0 || ptr < 0x10000000 || ptr > 0x7fffffffffff || GetMemoryProtection(reinterpret_cast<LPVOID>(ptr)) == PAGE_NOACCESS) return false;
return true;
}
template<typename T4>
bool WriteMemW(uintptr_t ptr, T4 const& Value) {
if (ptr < 0x10000000 || ptr > 0x7fffffffffff) return false;
DWORD d, ds;
int val2;
VirtualProtect((LPVOID)ptr, sizeof(Value), PAGE_EXECUTE_READWRITE, &d);
*reinterpret_cast<T4*>(ptr) = Value;
VirtualProtect((LPVOID)ptr, sizeof(Value), d, &ds);
return true;
}
uintptr_t ChangePointer(uintptr_t ptr, int Index, uintptr_t Value) {
uintptr_t ptrAddr = ptr + (0x8 * Index);
uintptr_t* blabla = (uintptr_t*)ptrAddr;
uintptr_t AddressBefore = *blabla;
WriteMemW(ptrAddr, Value);
return AddressBefore;
}
}
namespace Cheat {
SDK::UEngine* Engine = 0x0;
SDK::UWorld* WorldP = 0x0;
SDK::UKismetMathLibrary* MathLib = 0x0;
SDK::UKismetSystemLibrary* SystemLib = 0x0;
SDK::UKismetStringLibrary* StringLib = 0x0;
SDK::UKismetTextLibrary* TextLib = 0x0;
SDK::UGameplayStatics* GPStatics = 0x0;
SDK::AMP_PlayerController_C* PlayerController = 0x0;
SDK::ULocalPlayer* LocalPlayer = 0x0;
SDK::ULevel* CurLevel = 0x0;
SDK::APawn* Pawn = 0x0;
bool Initialized = false;
struct FStaticConstructObjectParameters
{
/** The class of the object to create */
const SDK::UClass* Class;
/** The object to create this object within (the Outer property for the new object will be set to the value specified here). */
SDK::UObject* Outer;
/** The name to give the new object.If no value(NAME_None) is specified, the object will be given a unique name in the form of ClassName_#. */
SDK::FName Name;
/** The ObjectFlags to assign to the new object. some flags can affect the behavior of constructing the object. */
int SetFlags;
/** The InternalObjectFlags to assign to the new object. some flags can affect the behavior of constructing the object. */
unsigned int InternalSetFlags;
/** If true, copy transient from the class defaults instead of the pass in archetype ptr(often these are the same) */
bool bCopyTransientsFromClassDefaults = false;
/** If true, Template is guaranteed to be an archetype */
bool bAssumeTemplateIsArchetype = false;
/**
* If specified, the property values from this object will be copied to the new object, and the new object's ObjectArchetype value will be set to this object.
* If nullptr, the class default object is used instead.
*/
SDK::UObject* Template = nullptr;
/** Contains the mappings of instanced objects and components to their templates */
void* InstanceGraph = nullptr;
/** Assign an external Package to the created object if non-null */
SDK::UPackage* ExternalPackage = nullptr;
};
class AudioData : public SDK::TArray<int8>
{
public:
AudioData(std::vector<int8> Bytes) {
TArray(Bytes.size());
if (Data) {
std::memcpy(Data, Bytes.data(), (sizeof(int8) * this->MaxElements));
}
}
~AudioData() {
if (Data)
delete[] Data;
}
};
typedef SDK::UObject* (__fastcall* fStaticConstructObject_Internal)
(
FStaticConstructObjectParameters* Params
);
static fStaticConstructObject_Internal StaticConstructObject_Internal;
static SDK::UConsole* ConstructConsole(SDK::UClass* ConsoleClass, SDK::UObject* outer)
{
FStaticConstructObjectParameters params = { ConsoleClass, outer, SDK::FName{0,0}, 0, 0, false, false, nullptr, nullptr, nullptr };
return reinterpret_cast<SDK::UConsole*>(StaticConstructObject_Internal(&params));
}
bool Ini() {
SDK::InitGObjects();
if (!Functions::ShouldUsePointer64(SDK::UObject::GObjects) || !Functions::ShouldUsePointer64(SDK::UObject::GObjects->Objects[0])) return false;
SDK::FName::InitGNames();
Engine = SDK::UEngine::GetEngine();
MathLib = (SDK::UKismetMathLibrary*)SDK::UObject::FindClassFast("KismetMathLibrary")->DefaultObject;
SystemLib = (SDK::UKismetSystemLibrary*)SDK::UObject::FindClassFast("KismetSystemLibrary")->DefaultObject;
StringLib = (SDK::UKismetStringLibrary*)SDK::UObject::FindClassFast("KismetStringLibrary")->DefaultObject;
TextLib = (SDK::UKismetTextLibrary*)SDK::UObject::FindClassFast("KismetTextLibrary")->DefaultObject;
GPStatics = (SDK::UGameplayStatics*)SDK::UObject::FindClassFast("GameplayStatics")->DefaultObject;
CWINGui::Font = SDK::UObject::FindObject<SDK::UFont>("Font Roboto.Roboto");
Rewrote some stuff to make it more clearer
2024-04-20 21:04:09 +08:00
StaticConstructObject_Internal = (fStaticConstructObject_Internal)((uintptr_t)GetModuleHandle(0) + Offsets::StaticConstructObject_Internal);
Projektdateien hinzufügen.
2024-04-20 20:19:09 +08:00
Initialized = true;
return true;
}
bool IniConsoleHook;
HANDLE hStdout;
bool IsInput = false;
struct Message_ {
enum MsgType {
None,
charptr,
string,
wcharptr,
wstring
};
void* msg = nullptr;
DWORD Color = FOREGROUND_RED;
MsgType msgtype = None;
void PassMessage();
Message_(const char* msg_, DWORD Color_ = FOREGROUND_RED) {
msgtype = MsgType::charptr;
size_t strlencc = strnlen_s(msg_, 1000);
char* str = new char[strlencc];
for (size_t i = 0; i < strlencc; i++)
{
str[i] = msg_[i];
}
this->msg = (void*)str;
this->Color = Color_;
}
Message_(std::string msg_, DWORD Color_ = FOREGROUND_RED) {
msgtype = MsgType::string;
std::string* str = new std::string();
for (size_t i = 0; i < msg_.length(); i++)
{
str[0][i] = msg_[i];
}
this->msg = (void*)str;
this->Color = Color_;
}
Message_(std::wstring msg_, DWORD Color_ = FOREGROUND_RED) {
msgtype = MsgType::wstring;
std::wstring* str = new std::wstring();
for (size_t i = 0; i < msg_.length(); i++)
{
str[0][i] = msg_[i];
}
this->msg = (void*)str;
this->Color = Color_;
}
Message_(const wchar_t* msg_, DWORD Color_ = FOREGROUND_RED) {
msgtype = MsgType::wcharptr;
size_t strlencc = wcslen(msg_);
wchar_t* str = new wchar_t[strlencc];
for (size_t i = 0; i < strlencc; i++)
{
str[i] = msg_[i];
}
this->msg = (void*)str;
this->Color = Color_;
}
};
std::vector<Message_> MessageList;
void EmptyQueue() {
for (size_t i = 0; i < MessageList.size(); i++)
{
MessageList[i].PassMessage();
}
MessageList.clear();
}
void Message(const char* msg, DWORD Color = FOREGROUND_RED) {
if (!IniConsoleHook) {
IniConsoleHook = true;
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
}
if (IsInput) {
MessageList.push_back(Message_(msg, Color));
return;
}
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
GetConsoleScreenBufferInfo(hStdout, &consoleInfo);
WORD originalAttributes = consoleInfo.wAttributes;
std::cout << "[*] ";
SetConsoleTextAttribute(hStdout, Color | FOREGROUND_INTENSITY);
std::cout << msg << "\n";
SetConsoleTextAttribute(hStdout, originalAttributes);
}
void Message(std::string msg, DWORD Color = FOREGROUND_RED) {
if (!IniConsoleHook) {
IniConsoleHook = true;
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
}
if (IsInput) {
MessageList.push_back(Message_(msg, Color));
return;
}
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
GetConsoleScreenBufferInfo(hStdout, &consoleInfo);
WORD originalAttributes = consoleInfo.wAttributes;
std::cout << "[*] ";
SetConsoleTextAttribute(hStdout, Color | FOREGROUND_INTENSITY);
std::cout << msg.c_str() << "\n";
SetConsoleTextAttribute(hStdout, originalAttributes);
}
void MessageW(std::wstring msg, DWORD Color = FOREGROUND_RED) {
if (!IniConsoleHook) {
IniConsoleHook = true;
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
}
if (IsInput) {
MessageList.push_back(Message_(msg, Color));
return;
}
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
GetConsoleScreenBufferInfo(hStdout, &consoleInfo);
WORD originalAttributes = consoleInfo.wAttributes;
SetConsoleTextAttribute(hStdout, Color | FOREGROUND_INTENSITY);
std::wcout << "[*] ";
SetConsoleTextAttribute(hStdout, originalAttributes);
std::wcout << msg.c_str() << "\n";
}
void MessageW(const wchar_t* msg, DWORD Color = FOREGROUND_RED) {
if (!IniConsoleHook) {
IniConsoleHook = true;
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
}
if (IsInput) {
MessageList.push_back(Message_(msg, Color));
return;
}
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
GetConsoleScreenBufferInfo(hStdout, &consoleInfo);
WORD originalAttributes = consoleInfo.wAttributes;
SetConsoleTextAttribute(hStdout, Color | FOREGROUND_INTENSITY);
std::wcout << "[*] ";
SetConsoleTextAttribute(hStdout, originalAttributes);
std::wcout << msg << "\n";
}
void Message_::PassMessage()
{
switch (msgtype)
{
case charptr:
Message((const char*)msg, Color);
delete[](msg);
break;
case string:
Message(*(std::string*)msg, Color);
delete (std::string*)msg;
break;
case wstring:
MessageW(*(std::wstring*)msg, Color);
delete (std::wstring*)msg;
break;
case wcharptr:
MessageW((const wchar_t*)msg, Color);
delete[](msg);
break;
default:
return;
break;
}
}
void MoveCursorConsole(int x, int y) {
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
GetConsoleScreenBufferInfo(hStdout, &consoleInfo);
COORD newPosition;
newPosition.X = consoleInfo.dwCursorPosition.X + x;
newPosition.Y = consoleInfo.dwCursorPosition.Y + y;
SetConsoleCursorPosition(hStdout, newPosition);
}
//void GetInput(std::string Text, std::string& Output, bool& hasFinished) {
// IsInput = true;
// std::cout << Text;
// std::cin >> Output;
// size_t lengthLine = Text.length() + Output.length();
// std::cout << "\r";
// std::cout << "\033[K";
// EmptyQueue();
// hasFinished = true;
//}
void GetInputW(std::string Text, std::wstring& Output, bool& hasFinished) {
if (IsInput)return;
IsInput = true;
std::cout.clear();
std::cin.clear();
std::fflush(stdin);
Text = "[Input] " + Text;
std::cout << Text;
std::getline(std::wcin, Output);
int lengthLine = Text.length() + Output.length();
MoveCursorConsole(0, -1);
MoveCursorConsole(-lengthLine, 0);
for (size_t i = 0; i < lengthLine; i++)
{
std::cout << " ";
}
MoveCursorConsole(-lengthLine, 0);
IsInput = false;
EmptyQueue();
hasFinished = true;
}
void DrawTextRGBWithFString(SDK::UCanvas* canvas, SDK::FString text, SDK::FVector2D Screenpos, SDK::FLinearColor color, bool CenterX, float size);
int Stages = 0; // Stages is for stuff that im to lazy to explain
namespace UsefullFuncs {
DWORD GetMemoryProtection(LPVOID address)
{
MEMORY_BASIC_INFORMATION memInfo;
VirtualQuery(address, &memInfo, sizeof(memInfo));
return memInfo.Protect;
}
bool ShouldUsePtr(void* ptrF) {
uintptr_t ptr = (uintptr_t)ptrF;
if (ptr == 0x0 || ptr < 0x10000000 || ptr > 0x7fffffffffff || GetMemoryProtection(reinterpret_cast<LPVOID>(ptr)) == PAGE_NOACCESS) return false;
return true;
}
bool IniObjects() {
Stages = 0;
if (!ShouldUsePtr(Engine) && (Engine = SDK::UEngine::GetEngine()) == nullptr) { return false; }
Stages++;
if (!Engine->GameViewport) { return false; }
Stages++;
WorldP = Engine->GameViewport->World;
if (!ShouldUsePtr(WorldP)) { return false; }
Stages++;
bool Changedlvl = false;
if (CurLevel != WorldP->PersistentLevel) {
CurLevel = WorldP->PersistentLevel;
Changedlvl = true;
for (size_t i = 0; i < sizeof(Settings::IniShitsLevel); i++)
{
Settings::IniShitsLevel[i] = false;
}
Backend::LevelName = GPStatics->GetCurrentLevelName(WorldP, true).ToString();
Backend::DefineEnum();
Backend::CallbackNewLevel();
Message(std::string("Current Level: " + Backend::LevelName).c_str(), FOREGROUND_BLUE);
if (WorldP->NetDriver && WorldP->NetDriver->ServerConnection)
{
WorldP->NetDriver->ConnectionTimeout = 10.0f;
Backend::HostSteamID = WorldP->NetDriver->ServerConnection->URL_.Host.ToString();
Backend::CleanSteamID();
Message(std::string("Host SteamID: " + Backend::HostSteamID).c_str(), FOREGROUND_RED);
if (WorldP->GameState) {
auto playerArray = WorldP->GameState->PlayerArray;
if (playerArray.IsValid()) {
for (size_t i = 0; i < playerArray.Num(); i++)
{
auto Owner_ = (SDK::APlayerController*)playerArray[i]->GetOwner();
if (Owner_) {
Message(std::string("Connected Clients SteamID: " + Owner_->NetConnection->URL_.Host.ToString()).c_str(), FOREGROUND_RED);
}
}
}
}
}
else
{
Backend::HostSteamID = "";
Backend::HostSteamID_Clean = "";
}
}
if (!WorldP->OwningGameInstance || !ShouldUsePtr(&WorldP->OwningGameInstance->LocalPlayers) || !ShouldUsePtr(WorldP->OwningGameInstance->LocalPlayers[0])) { return false; }
Stages++;
LocalPlayer = WorldP->OwningGameInstance->LocalPlayers[0];
PlayerController = (SDK::AMP_PlayerController_C*)LocalPlayer->PlayerController;
if (!ShouldUsePtr(PlayerController)) { return false; }
Stages++;
if (Changedlvl) {
if (auto playerState = PlayerController->PlayerState; playerState)
Settings::OriginalName = playerState->PlayerNamePrivate.ToWString();
}
Pawn = LocalPlayer->PlayerController->AcknowledgedPawn;
if (!ShouldUsePtr(Pawn)) { return false; }
Stages++;
static SDK::APawn* pawnPlayer = nullptr;
if (Pawn != pawnPlayer) {
pawnPlayer = Pawn;
for (size_t i = 0; i < sizeof(Settings::IniShitsPlayer); i++)
{
Settings::IniShitsPlayer[i] = false;
}
}
return true;
}
typedef struct
{
DWORD R;
DWORD G;
DWORD B;
DWORD A;
}RGBA;
int Rainbowify(RGBA* Color) {
if (Color->B != 255 && Color->G == 0) {
Color->B++;
}
if (Color->B == 255 && Color->R != 0) {
Color->R--;
}
if (Color->B == 255 && Color->G != 255 && Color->R == 0) {
Color->G++;
}
if (Color->G == 255 && Color->B != 0) {
Color->B--;
}
if (Color->B == 0 && Color->R != 255) {
Color->R++;
}
if (Color->R == 255 && Color->G != 0) {
Color->G--;
}
return 1;
}
constexpr SDK::FLinearColor RGBATOFLinear_(DWORD R, DWORD G, DWORD B, DWORD A) {
SDK::FLinearColor Color;
Color.R = R / 255.0f;
Color.G = G / 255.0f;
Color.B = B / 255.0f;
Color.A = A / 255.0f;
return Color;
}
SDK::FLinearColor RGBATOFLinear(DWORD R, DWORD G, DWORD B, DWORD A) {
static SDK::FLinearColor Color;
Color.R = R / 255.0f;
Color.G = G / 255.0f;
Color.B = B / 255.0f;
Color.A = A / 255.0f;
return Color;
}
std::string wstringToString(const std::wstring& wstr)
{
std::string str;
for (wchar_t c : wstr) {
str += static_cast<char>(c);
}
return str;
}
std::wstring stringToWideString(const std::string& str)
{
std::wstring wstr(str.length(), L' ');
std::copy(str.begin(), str.end(), wstr.begin());
return wstr;
}
void DrawLine(SDK::UCanvas* Canvas, SDK::FVector2D position1, SDK::FVector2D position2, SDK::FLinearColor color, int thickness = 1)
{
Canvas->K2_DrawLine(position1, position2, thickness, color);
}
void DrawCircle(SDK::UCanvas* Canvas, SDK::FVector2D pos, int radius, int numSides, SDK::FLinearColor Color)
{
float PI = 3.1415927f;
float Step = PI * 2.0 / numSides;
int Count = 0;
SDK::FVector2D V[128];
for (float a = 0; a < PI * 2.0; a += Step) {
float X1 = radius * cos(a) + pos.X;
float Y1 = radius * sin(a) + pos.Y;
float X2 = radius * cos(a + Step) + pos.X;
float Y2 = radius * sin(a + Step) + pos.Y;
V[Count].X = X1;
V[Count].Y = Y1;
V[Count + 1].X = X2;
V[Count + 1].Y = Y2;
//Draw_Line(FVector2D{ pos.X, pos.Y }, FVector2D{ X2, Y2 }, 1.0f, Color); // Points from Centre to ends of circle
DrawLine(Canvas, SDK::FVector2D{ V[Count].X, V[Count].Y }, SDK::FVector2D{ X2, Y2 }, Color, 1.0f);// Circle Around
}
}
void DrawBox(SDK::UCanvas* Canvas, SDK::FVector2D position, SDK::FVector2D size, int thickness, SDK::FLinearColor color) {
SDK::FVector2D BoxShit1;
DrawLine(Canvas, (BoxShit1 = { position.X - (size.X / 2), position.Y }), (BoxShit1 = { position.X + (size.X / 2), position.Y }), color);
DrawLine(Canvas, (BoxShit1 = { position.X - (size.X / 2), position.Y + (size.Y) }), (BoxShit1 = { position.X + (size.X / 2), position.Y + (size.Y) }), color);
//Left and Right
DrawLine(Canvas, (BoxShit1 = { position.X - (size.X / 2), position.Y }), (BoxShit1 = { position.X - (size.X / 2), position.Y + (size.Y) }), color);
DrawLine(Canvas, (BoxShit1 = { position.X + (size.X / 2), position.Y }), (BoxShit1 = { position.X + (size.X / 2), position.Y + (size.Y) }), color);
}
void DrawBoxOnActor(SDK::UCanvas* Canvas, SDK::AActor* Actor, SDK::FLinearColor Color, bool Name = false, std::wstring name = L"") {
SDK::FVector xLocation;
SDK::FVector xBoxExtent;
Actor->GetActorBounds(true, &xLocation, &xBoxExtent, false);
auto Location = Actor->K2_GetActorLocation();
SDK::FVector HeadLocation = { Location.X, Location.Y, Location.Z + (xBoxExtent.Z) };
SDK::FVector FootLocation = { Location.X, Location.Y, Location.Z - (xBoxExtent.Z) };
SDK::FVector2D HeadScreen;
SDK::FVector2D FootScreen;
if (!GPStatics->ProjectWorldToScreen(PlayerController, HeadLocation, &HeadScreen, true))return;
if (!GPStatics->ProjectWorldToScreen(PlayerController, FootLocation, &FootScreen, true))return;
const float height = abs(HeadScreen.Y - FootScreen.Y);
const float width = height * 0.6f;
if (Name) {
DrawTextRGBWithFString(Canvas, SDK::FString(name.c_str()), { HeadScreen.X - (name.length() * 5), HeadScreen.Y }, Color, false, 1.1f);
}
DrawBox(Canvas, SDK::FVector2D(HeadScreen.X, HeadScreen.Y), SDK::FVector2D(width, height), 1, Color);
}
}
std::string strToLower(std::string Text) {
std::string Output = "";
for (size_t i = 0; i < Text.length(); i++)
{
Output += std::tolower(Text[i]);
}
return Output;
}
void DrawText_Canvas(SDK::UCanvas* Canvas, SDK::FString RenderText, SDK::FVector2D ScreenPosition, SDK::FVector2D Scale, SDK::FLinearColor RenderColor, float Kerning, SDK::FLinearColor ShadowColor, SDK::FVector2D ShadowOffset, bool bCentreX, bool bCentreY, bool bOutlined, SDK::FLinearColor OutlineColor)
{
static SDK::UFunction* fn = NULL;
if (!fn)
fn = SDK::UObject::FindObject<SDK::UFunction>("Function Engine.Canvas.K2_DrawText");
if (!UsefullFuncs::ShouldUsePtr(CWINGui::Font))
CWINGui::Font = SDK::UObject::FindObject<SDK::UFont>("Font Roboto.Roboto");
struct {
SDK::UObject* RenderFont;
SDK::FString RenderText;
SDK::FVector2D ScreenPosition;
SDK::FVector2D Scale;
SDK::FLinearColor RenderColor;
float Kerning;
SDK::FLinearColor ShadowColor;
SDK::FVector2D ShadowOffset;
bool bCentreX;
bool bCentreY;
bool bOutlined;
SDK::FLinearColor OutlineColor;
}Args;
Args.RenderFont = CWINGui::Font;
Args.RenderText = RenderText;
Args.ScreenPosition = ScreenPosition;
Args.Scale = Scale;
Args.RenderColor = RenderColor;
Args.Kerning = Kerning;
Args.ShadowColor = ShadowColor;
Args.ShadowOffset = ShadowOffset;
Args.bCentreX = bCentreX;
Args.bCentreY = bCentreY;
Args.bOutlined = bOutlined;
Args.OutlineColor = OutlineColor;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
Canvas->ProcessEvent(fn, &Args);
fn->FunctionFlags = flags;
}
void DrawTextRGBWithFString(SDK::UCanvas* canvas, SDK::FString text, SDK::FVector2D Screenpos, SDK::FLinearColor color, bool CenterX = 0, float size = 1.1f)
{
DrawText_Canvas(canvas, text, Screenpos, { size, size }, color, 0.f, { 0, 0, 0, 1 }, { 0, 0 }, 0, 0, 0, { 0, 0, 0, 1 });
}
typedef void (*Process_Event_FN)(SDK::UObject* Caller, SDK::UFunction* Func, void* Params);
Process_Event_FN origin_Process_Event_FN;
void* ProcEventBefore = 0x0;
void** VTableBefore = 0x0;
void HookProcEvent(SDK::UObject* _thiss, void* Funcptr) {
static SDK::UObject* ObjectBefore = 0x0;
if (ObjectBefore != _thiss) {
ObjectBefore = _thiss;
if (ProcEventBefore != nullptr && VTableBefore != nullptr) {
Functions::ChangePointer((uintptr_t)VTableBefore, Offsets::ProcessEventIdx, (uintptr_t)ProcEventBefore);
}
auto vTable = *(void***)(_thiss);
VTableBefore = vTable;
ProcEventBefore = (void*)Functions::ChangePointer((uintptr_t)vTable, Offsets::ProcessEventIdx, (uintptr_t)Funcptr);
origin_Process_Event_FN = (Process_Event_FN)ProcEventBefore;
}
}
SDK::UObject* FindInstance(SDK::UClass* Class) {
static SDK::UObject* Object = nullptr;
if (!Object)
{
for (int i = 0; i < SDK::UObject::GObjects->Num(); i++)
{
SDK::UObject* Obj = SDK::UObject::GObjects->GetByIndex(i);
if (!Obj)
continue;
if (Obj->IsA(Class) && !Obj->IsDefaultObject())
{
Object = Obj;
break;
}
}
}
return Object;
}
std::vector<SDK::UObject*> FindInstances(SDK::UClass* Class) {
static std::vector<SDK::UObject*> Objects;
for (int i = 0; i < SDK::UObject::GObjects->Num(); i++)
{
SDK::UObject* Obj = SDK::UObject::GObjects->GetByIndex(i);
if (!Obj || (uintptr_t)Obj == 0xffffffffffffffff)
continue;
if (Obj->IsA(Class) && !Obj->IsDefaultObject())
{
Objects.push_back(Obj);
continue;
}
}
return Objects;
}
std::vector<std::string> FuncsNames;
void GodMode(SDK::UObject* Caller, SDK::UFunction* Func, void* Params) {
//if (Settings::Godmode && Func->Name.ToString().find("Kill") == std::string::npos)return;
bool Found = false;
auto NameFunc = Func->Name.ToString();
for (size_t i = 0; i < FuncsNames.size(); i++)
{
if (NameFunc == FuncsNames[i]) Found = true;
}
if (Found == false) {
FuncsNames.push_back(NameFunc);
std::cout << NameFunc << "\n";
}
return origin_Process_Event_FN(Caller, Func, Params);
}
namespace defines {
enum Stages_
{
Engine = 1,
ViewPort = 2,
World = 3,
LocalPlayer = 4,
PlayerController = 5,
Pawn = 6
};
}
void MainRun(SDK::UCanvas* Canvas) {
bool Ok = UsefullFuncs::IniObjects();
if (Stages == 0)return;
auto TickCount = GetTickCount64();
if (Stages >= defines::PlayerController) {
if (Settings::wtf_) {
Settings::wtf_ = false;
if (!Engine->GameViewport->ViewportConsole) {
auto Console = ConstructConsole(Engine->ConsoleClass, Engine->GameViewport);
//GPStatics->SpawnObject(classConsole, nullptr);
if (Console) {
Message("Console Constructed!. Btw Console Constructs, but wont open yet :( ");
Engine->GameViewport->ViewportConsole = Console;
SDK::UInputSettings* inputSettings = SDK::UInputSettings::GetDefaultObj()->GetInputSettings();
inputSettings->ConsoleKey.KeyName = StringLib->Conv_StringToName(SDK::FString(L"Tab"));
auto key = inputSettings->ConsoleKey;
inputSettings->SaveKeyMappings();
inputSettings->ForceRebuildKeymaps();
//Message(std::string("Key for Console:" + key.KeyName.ToString()));
}
else
{
Message("Console Couldn't be Constructed!");
}
}
else
{
Message("Console has been already constructed!");
}
//PlayerController->ServerExec()
}
#ifdef Gatekeep
{
static ULONGLONG TickCountSpoofChat = 0;
if (Settings::SpoofChatEvent) {
if (!Settings::IniShitsPlayer[2]) {
Settings::IniShitsPlayer[2] = true;
TickCountSpoofChat = TickCount + 300;
Settings::ChangeNameEvent = true;
}
if (TickCount >= TickCountSpoofChat) {
if (PlayerController->PlayerState && PlayerController->PlayerState->PlayerNamePrivate.ToWString() != PlayerStuff::PlayerList[Settings::PlayerPicked].name) {
Settings::ChangeNameEvent = true;
}
else
{
Settings::SpoofChatEvent = false;
Settings::IniShitsPlayer[2] = false;
if(PlayerController->Chat_Component)
if (auto chatwb = PlayerController->Chat_Component->WB_ChatRef; chatwb && Settings::PlayerPicked != -1)
{
SDK::FBPUniqueNetId netid;
SDK::FS_ChatMessage msgOut;
chatwb->Send_Global_Message(SDK::FString(Settings::MessageSpoof.c_str()), PlayerController, PlayerController, netid, SDK::FString(L"Niggichan"), msgOut);
Settings::PlayerPicked = -1;
Settings::ChangeNameEvent = true;
}
}
}
}
}
if (Settings::ChangeNameEvent) {
Settings::ChangeNameEvent = false;
PlayerController->ServerChangeName(SDK::FString(Settings::PlayerPicked != -1 ? PlayerStuff::PlayerList[Settings::PlayerPicked].name.c_str() : Settings::OriginalName.c_str()));
Settings::NameOfVictim = L"";
}
if (Settings::NameChanger) {
static void* AddrPlayerController = 0x0;
if (AddrPlayerController != PlayerController || !Settings::IniShitsLevel[3]) {
Settings::ChangeNameEvent = false;
Settings::IniShitsLevel[3] = true;
Settings::OriginalName = Settings::NameTo_set;
PlayerController->ServerChangeName(SDK::FString(Settings::NameTo_set.c_str()));
AddrPlayerController = PlayerController;
}
}
#endif
if (Settings::ProtectCamServer && !Settings::IniShitsPlayer[0]) {
Settings::IniShitsPlayer[0] = true;
PlayerController->PlayerCameraManager->SetReplicates(false);
}
//static ULONGLONG TickCountGameModeCurrent = 0;
//if (TickCount >= TickCountGameModeCurrent) {
// TickCountGameModeCurrent = TickCount + 1000;
// auto OBJ_List = FindInstances(SDK::AMP_::StaticClass());
// if (OBJ_List.size() != 0) {
// std::cout << "Found GameMode!\n";
// }
//}
if (Settings::LoadLevel_) {
static ULONGLONG TickCount_Server = 0;
if (TickCount >= TickCount_Server) {
TickCount_Server = TickCount + 800;
SDK::FName nameptrLevel = StringLib->Conv_StringToName(SDK::FString(Settings::LevelToLoad.c_str()));
std::string levelName = nameptrLevel.ToString();
if (levelName != "None") {
if (auto GameMode = (SDK::ABase_GM_C*)WorldP->AuthorityGameMode; GameMode) {
//Keep lobby open by Loading level from Lobby (Exploit 5)
if (GameMode->IsA(SDK::ABase_GM_C::StaticClass())) {
SDK::FString blabla1, blabla2;
GameMode->ServerTravel_ToGameplayMap(nameptrLevel, blabla1, blabla2);
Cheat::Message(std::string("Server Loaded Level: " + levelName));
}
else if (GameMode->IsA(SDK::AMP_GameMode_C::StaticClass())) {
auto GameModeC = (SDK::AMP_GameMode_C*)GameMode;
GameModeC->LoadLevel(nameptrLevel, false, false);
}
else
{
Cheat::Message(std::string("Client Loaded Level: " + levelName));
GPStatics->OpenLevel(WorldP, nameptrLevel, true, SDK::FString(L""));
}
}
else
{
Cheat::Message(std::string("Client Loaded Level: " + levelName));
GPStatics->OpenLevel(WorldP, nameptrLevel, true, SDK::FString(L""));
}
}
}
Settings::LoadLevel_ = false;
}
if (Settings::FovChanger) {
PlayerController->FOV(Settings::Fov);
}
static bool cleared = false;
if (true) {
PlayerStuff::PlayerList.clear();
SDK::TArray<SDK::AActor*> Players;
//SDK::TArray<SDK::AActor*> Characters;
GPStatics->GetAllActorsOfClass(WorldP, SDK::APlayerState::StaticClass(), &Players);
//GPStatics->GetAllActorsOfClass(WorldP, SDK::ABPCharacter_Demo_C::StaticClass(), &Characters);
if (Players.IsValid()) {
cleared = false;
auto bpClass = SDK::ABPCharacter_Demo_C::StaticClass();
auto AMPGamemodeClass = SDK::AMP_GameMode_C::StaticClass();
auto SpectatorPawnClass = SDK::ASpectatorPawn::StaticClass();
for (size_t i = 0; i < Players.Num(); i++)
{
auto State = (SDK::APlayerState*)Players[i];
auto contr = (SDK::AMP_PlayerController_C*)State->GetOwner();
auto StatePR = (SDK::AFancyPlayerState*)nullptr;
if (State->IsA(SDK::AFancyPlayerState::StaticClass())) {
StatePR = (SDK::AFancyPlayerState*)State;
}
auto Owner_ = State->PawnPrivate;
if (Owner_ && !contr)contr = (SDK::AMP_PlayerController_C*)Owner_->Controller;
auto Character_ = (SDK::ABPCharacter_Demo_C*)(Owner_ ? (Owner_->IsA(bpClass) ? (SDK::ABPCharacter_Demo_C*)Owner_ : nullptr) : nullptr);
bool isAlive = false;
bool isSpectating = false;
SDK::FVector pos;
if (contr) {
if (!isAlive) {
if (auto GameMode = (SDK::AMP_GameMode_C*)WorldP->AuthorityGameMode; GameMode) {
if (GameMode->IsA(AMPGamemodeClass)) {
auto GameModeC = (SDK::AMP_GameMode_C*)GameMode;
if (Settings::EventRespawnPlayer && State->PlayerId == Settings::Event_PlayerID)
{
Settings::Event_PlayerID = -1;
Settings::EventRespawnPlayer = false;
GameModeC->RestartPlayer(contr);
auto Pawn_ = GameModeC->SpawnDefaultPawnFor(contr, GameModeC->PlayerStarts[0]);
contr->AcknowledgedPawn = Pawn_;
State->PawnPrivate = Pawn_;
GameModeC->HandleStartingNewPlayer(contr);
GameModeC->RestartPlayer(contr);
}
}
}
}
}
if (Owner_) {
contr = (SDK::AMP_PlayerController_C*)Owner_->GetController();
if (!contr)
contr = (SDK::AMP_PlayerController_C*)Owner_->GetOwner();
pos = Owner_->K2_GetActorLocation();
isAlive = (Character_);
auto chara = (SDK::ABPCharacter_Demo_C*)nullptr;
//Only for Events
if (State->PlayerId == Settings::Event_PlayerID) {
if (Settings::TeleportToEventPlayer && PlayerController->Character) {
Settings::Event_PlayerID = -1;
Settings::TeleportToEventPlayer = false;
#ifdef Gatekeep
auto charc = (SDK::ABPCharacter_Demo_C*)PlayerController->Character;
if (charc && charc->Class->GetFunction("BPCharacter_Demo_C", "StartPushingActor_SERVER")) {
charc->StartPushingActor_SERVER((SDK::ABP_Pushable_C*)PlayerController->AcknowledgedPawn, pos, PlayerController->ControlRotation);
charc->StopPushingActor_SERVER((SDK::ABP_Pushable_C*)PlayerController->AcknowledgedPawn);
}
else
{
PlayerController->Pawn->K2_SetActorLocation(pos, false, 0, true);
}
#else
PlayerController->Pawn->K2_SetActorLocation(pos, false, 0, true);
#endif
}
if (Settings::UseItemEventPlayer) {
Settings::Event_PlayerID = -1;
Settings::UseItemEventPlayer = false;
if (Character_) {
auto char_ = (SDK::ABPCharacter_Demo_C*)(PlayerController->Character ? (PlayerController->Character->IsA(bpClass) ? PlayerController->Character : nullptr) : nullptr);
if (Character_->CurrentItem_Rep) {
if(char_)
char_->UseItem_SERVER((SDK::ABP_Item_C*)Character_->CurrentItem_Rep);
else
Message("LocalPlayer Character is nullptr");
}
else
Message("Slot is Empty");
}
else
{
Message("Character is nullptr");
}
}
//if (Settings::EventCollectDataPlayer) {
// Settings::EventCollectDataPlayer = false;
// if (contr) {
// if (contr->NetConnection) {
// Cheat::Message("[Player Info:] SteamID:" + contr->NetConnection->RemoteAddr.ObjectPointing->ToString(false).ToString());
// }
// else
// {
// Cheat::Message("[Player Info:] Connection was nullptr!");
// }
// }
// else
// {
// Cheat::Message("[Player Info:] PlayerController was nullptr");
// }
//}
if (Settings::TeleportEventPlayer)
{
Settings::Event_PlayerID = -1;
Settings::TeleportEventPlayer = false;
{
Owner_->K2_SetActorLocation(PlayerController->Pawn->K2_GetActorLocation(), false, 0, true);
}
}
}
}
if (State != PlayerController->PlayerState)
PlayerStuff::PlayerList.push_back(PlayerStuff::Player(State->PlayerNamePrivate.ToWString(),
(contr ? (contr->NetConnection ? contr->NetConnection->URL_.Host.ToWString() : UsefullFuncs::stringToWideString(Backend::HostSteamID) ) : UsefullFuncs::stringToWideString( Backend::HostSteamID) ),
(Character_ ? (Character_->CurrentItem_Rep ? Cheat::UsefullFuncs::stringToWideString(Character_->CurrentItem_Rep->GetName()) : L"Empty") : L"Player Dead"), State->PlayerId,
contr, Owner_, isAlive, contr, pos, StatePR ? StatePR->InventoryComponent : nullptr));
}
std::sort(PlayerStuff::PlayerList.begin(), PlayerStuff::PlayerList.end(), [](const PlayerStuff::Player& a, const PlayerStuff::Player& b) {
return a.PlayerID < b.PlayerID;
});
}
}
else
{
if (!cleared) {
cleared = true;
PlayerStuff::PlayerList.clear();
}
}
}
if (!Canvas)return;
//Esp shit, World needed obviously else crashes
if (Ok || Stages >= 6) {
if (PlayerController->SpectatorPawn) {
}
RunMainHost();
static bool WasCollide = false;
static SDK::ABoatPawn* LastBoat = 0x0;
if (Settings::BoatFly || Settings::BoatSpeedhack || Settings::BoatEsp) {
auto BoatClass = SDK::ABoatPawn::StaticClass();
if (BoatClass) {
SDK::TArray<SDK::AActor*> BoatPawns;
GPStatics->GetAllActorsOfClass(WorldP, BoatClass, &BoatPawns);
if (BoatPawns.IsValid()) {
for (size_t i = 0; i < BoatPawns.Num(); i++)
{
auto BoatPawn = (SDK::ABP_RowBoat_C*)BoatPawns[i];
if (Settings::BoatEsp) {
auto Color = UsefullFuncs::RGBATOFLinear(255, 0, 0, 255);
auto location = BoatPawn->K2_GetActorLocation();
SDK::FVector2D ScreenPos;
if (GPStatics->ProjectWorldToScreen(PlayerController, location, &ScreenPos, true))
UsefullFuncs::DrawCircle(Canvas, ScreenPos, 10.0f, 12, Color);
}
if (BoatPawn->Controller == PlayerController) {
LastBoat = BoatPawn;
//BoatPawn->LaunchPawn(SDK::FVector(0, 0, 200.5f), false, false);
if (Settings::BoatFly) {
BoatPawn->RootComponent->ComponentVelocity = { 0.0f, 0.0f, 0.0f };
BoatPawn->SceneComponent->ComponentVelocity = { 0.0f, 0.0f, 0.0f };
BoatPawn->bActorEnableCollision = false;
WasCollide = true;
if (GetAsyncKeyState(VK_LEFT)) {
SDK::FRotator rotation = BoatPawn->K2_GetActorRotation();
if (rotation.Yaw - 5.0f < -360.0f) {
rotation.Yaw = 0.0f;
}
else
{
rotation.Yaw -= 5.0f;
}
BoatPawn->K2_SetActorRotation(rotation, false);
}
if (GetAsyncKeyState(VK_RIGHT)) {
SDK::FRotator rotation = BoatPawn->K2_GetActorRotation();
if (rotation.Yaw + 5.0f > 360.0f) {
rotation.Yaw = 0.0f;
}
else
{
rotation.Yaw += 5.0f;
}
BoatPawn->K2_SetActorRotation(rotation, false);
}
if (GetAsyncKeyState(VK_SPACE)) {
auto BoatLoc = BoatPawn->K2_GetActorLocation();
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorUpVector() * Settings::PlayerFlySpeedY;
SDK::FVector PositionOut = { BoatLoc.X + ForwardCam.X, BoatLoc.Y + ForwardCam.Y, BoatLoc.Z };
BoatPawn->GetXShipComponent()->WaterWorldZ += Settings::PlayerFlySpeedY;
BoatPawn->K2_SetActorLocation(PositionOut, false, 0, true);
}
if (GetAsyncKeyState(VK_SHIFT)) {
auto BoatLoc = BoatPawn->K2_GetActorLocation();
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorUpVector() * Settings::PlayerFlySpeedY;
SDK::FVector PositionOut = { BoatLoc.X + ForwardCam.X, BoatLoc.Y + ForwardCam.Y, BoatLoc.Z};
BoatPawn->GetXShipComponent()->WaterWorldZ -= Settings::PlayerFlySpeedY;
BoatPawn->K2_SetActorLocation(PositionOut, false, 0, true);
}
if (GetAsyncKeyState('W')) {
auto BoatLoc = BoatPawn->K2_GetActorLocation();
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorForwardVector() * Settings::PlayerFlySpeedY;
SDK::FVector PositionOut = { BoatLoc.X + ForwardCam.X, BoatLoc.Y + ForwardCam.Y, BoatLoc.Z };
BoatPawn->K2_SetActorLocation(PositionOut, false, 0, true);
}
if (GetAsyncKeyState('S')) {
auto BoatLoc = BoatPawn->K2_GetActorLocation();
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorForwardVector() * Settings::PlayerFlySpeedY;
SDK::FVector PositionOut = { BoatLoc.X - ForwardCam.X, BoatLoc.Y - ForwardCam.Y, BoatLoc.Z};
BoatPawn->K2_SetActorLocation(PositionOut, false, 0, true);
}
if (GetAsyncKeyState('A')) {
auto BoatLoc = BoatPawn->K2_GetActorLocation();
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorRightVector() * Settings::PlayerFlySpeedY;
SDK::FVector PositionOut = { BoatLoc.X - ForwardCam.X, BoatLoc.Y - ForwardCam.Y, BoatLoc.Z};
BoatPawn->K2_SetActorLocation(PositionOut, false, 0, true);
}
if (GetAsyncKeyState('D')) {
auto BoatLoc = BoatPawn->K2_GetActorLocation();
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorRightVector() * Settings::PlayerFlySpeedY;
SDK::FVector PositionOut = { BoatLoc.X + ForwardCam.X, BoatLoc.Y + ForwardCam.Y, BoatLoc.Z};
BoatPawn->K2_SetActorLocation(PositionOut, false, 0, true);
}
}
if (Settings::BoatSpeedhack) {
auto ShipComponent = BoatPawn->GetXShipComponent();
for (size_t i1 = 0; i1 < ShipComponent->XShipEngines.Num(); i1++)
{
ShipComponent->XShipEngines[i1].EngineForwardForce = Settings::BoatSpeed;
}
}
break;
}
}
}
}
}
else
{
if (WasCollide) {
if (UsefullFuncs::ShouldUsePtr(LastBoat))
LastBoat->SetActorEnableCollision(true);
WasCollide = false;
}
}
auto BPCharacter = (SDK::ABPCharacter_Demo_C*)PlayerController->Character;
if (BPCharacter) {
if (Settings::OwnSelf) {
Settings::OwnSelf = false;
PlayerController->ServerAcknowledgePossession(BPCharacter);
}
//HookProcEvent(BPCharacter, GodMode);
//BPCharacter->SRV_OrientMovement();
if (Settings::InfiniteStamina) {
BPCharacter->ShouldUseStamina = false;
}
else
{
BPCharacter->ShouldUseStamina = true;
}
static bool WasNocliped = false;
if (Settings::Noclip) {
BPCharacter->CanCollide = false;
WasNocliped = true;
}
else
{
if (WasNocliped && !BPCharacter->CanCollide) {
BPCharacter->CanCollide = true;
}
}
#ifdef Gatekeep
//Spawn stuff inside your hand, that wasnt supposed to even Spawn in there (Exploit 1, Dangerous Exploit)
if (Settings::Spawner) {
if (GetAsyncKeyState('T') & 1)
{
SDK::UClass* SpawningThing = SDK::ABacteria_BP_C::StaticClass();
if (SpawningThing)
BPCharacter->SpawnEquipItem_SERVER(SpawningThing);
}
static ULONGLONG TickFindBoat = 0;
if (GetAsyncKeyState('U') & 1)
{
SDK::UClass* SpawningThing = nullptr;
SpawningThing = SDK::ABP_RowBoat_C::StaticClass();
if (SpawningThing)
BPCharacter->SpawnEquipItem_SERVER(SpawningThing);
Settings::IniShitsPlayer[5] = true;
TickFindBoat = TickCount + 100;
}
if (Settings::IniShitsPlayer[5] && TickCount >= TickFindBoat) {
TickFindBoat = TickCount + 100;
SDK::TArray<SDK::AActor*> Boats_2;
GPStatics->GetAllActorsOfClass(WorldP, SDK::ABoatPawn::StaticClass(), &Boats_2);
int Numb = Boats_2.Num();
for (size_t i = 0; i < Numb; i++)
{
auto Parent = Boats_2[i]->Instigator;
if ( Parent == BPCharacter) {
auto boat = (SDK::ABoatPawn*)Boats_2[i];
Settings::IniShitsPlayer[5] = false;
BPCharacter->K2_SetActorLocation(boat->K2_GetActorLocation(), false, 0, true);
BPCharacter->CurrentInteractingPawn = boat;
BPCharacter->Interact(boat);
}
}
}
//if (GetAsyncKeyState('O') & 1)
//{
// //BPCharacter->CrouchAmount = -1000.0f;
// //BPCharacter->Crouch(false);
// SDK::UClass* SpawningThing = SDK::::StaticClass();
//
// if (SpawningThing) {
// auto Object = (SDK::ABP_DroppedItem_Glowstick_C*)SpawningThing->DefaultObject;
// if (!Object) {
// Message("Default Object is null!");
// }
// BPCharacter->SpawnEquipItem_SERVER(SpawningThing);
// }
// else
// {
// Message("Class is null!");
// }
// //BPCharacter->CustomTimeDilation = 0.001f;
//}
//Send people into the MainMenu by spawning an DefaultExitZone with no Parameters. No fallback from host, host has to restart game (Exploit 2, very severe, any level can be loaded with the right class)
if (GetAsyncKeyState('R') & 1)
{
//BPCharacter->CrouchAmount = -1000.0f;
//BPCharacter->Crouch(false);
SDK::UClass* SpawningThing = SDK::ABP_ExitZone_C::StaticClass();
if (Functions::ShouldUsePointer64(SpawningThing)) {
BPCharacter->SpawnEquipItem_SERVER(SpawningThing);
}
else
{
Message("Couldnt Spawn ExitZone. Class Not Found");
}
//BPCharacter->CustomTimeDilation = 0.001f;
}
if (GetAsyncKeyState('7') & 1)
{
//BPCharacter->CrouchAmount = -1000.0f;
//BPCharacter->Crouch(false);
SDK::UClass* SpawningThing = SDK::ABP_Rope_C::StaticClass();
if (Functions::ShouldUsePointer64(SpawningThing)) {
BPCharacter->SpawnEquipItem_SERVER(SpawningThing);
}
else
{
Message("Couldnt Spawn Rope. Class Not Found");
}
//BPCharacter->CustomTimeDilation = 0.001f;
}
if (GetAsyncKeyState('8') & 1)
{
//BPCharacter->CrouchAmount = -1000.0f;
//BPCharacter->Crouch(false);
SDK::UClass* SpawningThing = SDK::ABP_FireworkProjectile_C::StaticClass();
if (Functions::ShouldUsePointer64(SpawningThing)) {
BPCharacter->SpawnEquipItem_SERVER(SpawningThing);
Settings::IniShitsPlayer[3] = true;
Settings::IniShitsPlayer[4] = true;
}
else
{
Message("Couldnt Spawn Rope. Class Not Found");
}
//BPCharacter->CustomTimeDilation = 0.001f;
}
if (Settings::IniShitsPlayer[3] && BPCharacter->CurrentItem_Rep) {
Settings::IniShitsPlayer[3] = false;
BPCharacter->CurrentItem_Rep->K2_DetachFromActor(SDK::EDetachmentRule::KeepRelative, SDK::EDetachmentRule::KeepRelative, SDK::EDetachmentRule::KeepRelative);
}
if (Settings::IniShitsPlayer[4] && BPCharacter->CurrentItem_Rep)
{
static LONGLONG UpdateFireWorkTick = 0;
if (TickCount >= UpdateFireWorkTick) {
UpdateFireWorkTick = TickCount + 100;
if (BPCharacter->CurrentItem_Rep->Class != SDK::ABP_FireworkProjectile_C::StaticClass()) {
Settings::IniShitsPlayer[4] = false;
}
}
if(Settings::IniShitsPlayer[4])
BPCharacter->CurrentItem_Rep->K2_SetActorLocation(PlayerController->PlayerCameraManager->GetCameraLocation() + (PlayerController->PlayerCameraManager->GetActorForwardVector() * 2), false, 0, true);
}
}
else
{
static LONGLONG UpdateStatesTick = 0;
if (TickCount >= UpdateStatesTick) {
UpdateStatesTick = TickCount + 10;
GetAsyncKeyState('T');
GetAsyncKeyState('U');
GetAsyncKeyState('O');
GetAsyncKeyState('R');
GetAsyncKeyState('7');
GetAsyncKeyState('8');
GetAsyncKeyState('9');
}
}
#endif
static SDK::FVector LastPos;
if (Settings::IniShitsPlayer[1]) {
SDK::FVector2D Pos2d;
if (GPStatics->ProjectWorldToScreen(PlayerController, LastPos, &Pos2d, true)) {
auto color = SDK::FLinearColor(0.0f, 0.0f, 1.0f, 1.0f);
DrawTextRGBWithFString(Canvas, SDK::FString(L"LocalPlayer_LastServerPos"), Pos2d, color, false, 1.1f);
UsefullFuncs::DrawCircle(Canvas, Pos2d, 1.0f, 12, color);
}
}
//FreeCam kinda
if (GetAsyncKeyState('J') & 1)
{
//PlayerController->ServerPause();
//PlayerController->ClientReset();
//PlayerController->ServerRestartPlayer();
static bool replicate = true;
LastPos = BPCharacter->K2_GetActorLocation();
PlayerController->SetReplicateMovement(replicate);
BPCharacter->SetReplicateMovement(replicate);
if (!replicate) {
Settings::PlayerFly = true;
Settings::VelocityFly = false;
Settings::IniShitsPlayer[1] = true;
}
else
{
Settings::PlayerFly = false;
Settings::VelocityFly = true;
Settings::IniShitsPlayer[1] = false;
}
replicate = !replicate;
}
//SDK::UWB_Chat_C
//Become an Omega ultra sigma and live inside your own edit, while floating elegantly through the air
if (GetAsyncKeyState(VK_RSHIFT)) {
BPCharacter->CustomTimeDilation = 0.02f;
}
else
{
static bool GetDilation = false;
static float DilationCopy = 0.0f;
if (!GetDilation) {
DilationCopy = BPCharacter->CustomTimeDilation;
GetDilation = true;
}
BPCharacter->CustomTimeDilation = DilationCopy;
}
//if (GetAsyncKeyState('P')) {
// BPCharacter->PickUp_SERVER((SDK::ADroppedItem*)BPCharacter);
// //Settings::ForceAdmin = true
//}
if (GetAsyncKeyState('Z')) {
Settings::TpEveryone = true;
}
{ // Only works as Host
BPCharacter->CanJumpscare = false;
BPCharacter->CanKill = false;
if (BPCharacter->Climb) {
BPCharacter->Climb->TheTimeline.Length = 0.0f;
}
if (BPCharacter->FallTimeline)
BPCharacter->FallTimeline->TheTimeline.Length = 0.0f;
}
//if (BPCharacter->LeanLeft) {
// BPCharacter->LeanLeft->TheTimeline.Length = 500.01f;
// BPCharacter->LeanLeft_Offset_17DE22D544C8BED35C8F5881C0002D9E = 1000000.0f;
// BPCharacter->LeanRight_Offset_C47E33074D47E917512F4F8517EDDA78 = 1000000.0f;
// BPCharacter->LeanRight->TheTimeline.Length = 500.01f;
//}
//BPCharacter->SetCanCollide(false);
auto playerState = (SDK::AMP_PS_C*)BPCharacter->PlayerState;
if (playerState) {
static bool RGBWasOn = false;
static SDK::FColor NormalRGB = { 208, 255, 255, 255 };
if (Settings::RGBFlashlight) {
if (BPCharacter->CurrentItem_Rep) {
RGBWasOn = true;
{
static SDK::FColor ColorRGB = NormalRGB;
auto Flashlight = (SDK::ABP_Item_Flashlight_C*)BPCharacter->CurrentItem_Rep;
if (Flashlight) {
if (Flashlight->IsFlashlightOn)
{
UsefullFuncs::RGBA RedGreenBlueAAAAAAAAAAA = { ColorRGB.R, ColorRGB.G, ColorRGB.B, ColorRGB.A };
Rainbowify(&RedGreenBlueAAAAAAAAAAA);
ColorRGB.R = RedGreenBlueAAAAAAAAAAA.R;
ColorRGB.G = RedGreenBlueAAAAAAAAAAA.G;
ColorRGB.B = RedGreenBlueAAAAAAAAAAA.B;
if (Flashlight->Flashlight != nullptr) {
Flashlight->Flashlight->SetLightColor(UsefullFuncs::RGBATOFLinear(ColorRGB.R, ColorRGB.G, ColorRGB.B, ColorRGB.A), true);
}
if (Flashlight->PointLight != nullptr) {
Flashlight->PointLight->SetLightColor(UsefullFuncs::RGBATOFLinear(ColorRGB.R, ColorRGB.G, ColorRGB.B, ColorRGB.A), true);
}
}
}
}
}
}
else {
if (RGBWasOn && BPCharacter->CurrentItem_Rep) {
if (BPCharacter->CurrentItem_Rep->Class->Name == SDK::ABP_Item_Flashlight_C::StaticClass()->Name) {
auto Flashlight = (SDK::ABP_Item_Flashlight_C*)BPCharacter->CurrentItem_Rep;
if (Flashlight) {
if (Flashlight->Flashlight) {
Flashlight->Flashlight->LightColor = NormalRGB;
Flashlight->Flashlight->SetLightColor(UsefullFuncs::RGBATOFLinear(NormalRGB.R, NormalRGB.G, NormalRGB.B, NormalRGB.A), true);
}
if (Flashlight->PointLight) {
Flashlight->PointLight->SetLightColor(UsefullFuncs::RGBATOFLinear(NormalRGB.R, NormalRGB.G, NormalRGB.B, NormalRGB.A), true);
}
}
RGBWasOn = false;
}
}
}
if (Settings::Rapidfire) { // only works as Host
if (BPCharacter->CurrentItem_Rep) {
auto Flaregun = (SDK::ABP_FlareGun_C*)SDK::ABP_FlareGun_C::GetDefaultObj();
if (BPCharacter->CurrentItem_Rep->ID == Flaregun->ID) {
Flaregun = (SDK::ABP_FlareGun_C*)BPCharacter->CurrentItem_Rep;
Flaregun->CanUse = true;
}
}
if (BPCharacter->CurrentItem_Rep) {
auto Flaregun = (SDK::ABP_Item_Firework_C*)SDK::ABP_Item_Firework_C::GetDefaultObj();
if (BPCharacter->CurrentItem_Rep->ID == Flaregun->ID) {
Flaregun = (SDK::ABP_Item_Firework_C*)BPCharacter->CurrentItem_Rep;
Flaregun->ThrowTime = 0.0f;
Flaregun->ExplodeTimer->TheTimeline.Length = 0.0f;
}
}
}
#ifdef Gatekeep
//Spawn ropes anywhere you want, how often you want also. (Exploit 3, severe)
if (GetAsyncKeyState(VK_F2)& 1 && BPCharacter->CurrentItem_Rep) {
auto rope = (SDK::ABP_Rope_C*)SDK::ABP_Rope_C::GetDefaultObj();
if (BPCharacter->CurrentItem_Rep->ID == rope->ID) {
rope = (SDK::ABP_Rope_C*)BPCharacter->CurrentItem_Rep;
rope->SRV_TossRope((SDK::ABP_Rope_Floor_C*)Pawn, Pawn->K2_GetActorLocation());
rope->SRV_ShowRope(Pawn, Pawn->K2_GetActorLocation());
}
}
#endif // Gatekeep
if (GetAsyncKeyState(VK_F3) & 1)
{
Settings::IniShitsPlayer[6] = !Settings::IniShitsPlayer[6];
}
if(Settings::IniShitsPlayer[6])
{
auto cam = (SDK::ABP_FlareGun_C*)BPCharacter->CurrentItem_Rep;
BPCharacter->SpawnEquipItem_SERVER(SDK::ABP_FlareGun_C::StaticClass());
if (cam)
{
BPCharacter->UseItem_SERVER(cam);
BPCharacter->DestroyEquipItem_SERVER();
}
}
Update Cheat.h
2024-04-20 21:09:57 +08:00
//if (GetAsyncKeyState(VK_F3) & 1 && BPCharacter->CurrentItem_Rep) { // actual safe item
Projektdateien hinzufügen.
2024-04-20 20:19:09 +08:00
// auto rope = (SDK::ABP_Scanner_C*)SDK::ABP_Scanner_C::GetDefaultObj();
// if (BPCharacter->CurrentItem_Rep->ID == rope->ID) {
// rope = (SDK::ABP_Scanner_C*)BPCharacter->CurrentItem_Rep;
// auto CamManager = PlayerController->PlayerCameraManager;
// SDK::TArray<SDK::AActor*> actorsToignore;
// SDK::FHitResult raycasthit;
// bool hit = SystemLib->LineTraceSingle(WorldP, CamManager->K2_GetActorLocation(), CamManager->GetActorForwardVector() * 10, SDK::ETraceTypeQuery::TraceTypeQuery1, true, actorsToignore, SDK::EDrawDebugTrace::None, &raycasthit, true, { 255, 0, 0, 255 }, { 255, 255, 0, 255 }, 5.0f);
// if (hit) {
// Message("hit something");
// rope->SRV_Lidar(raycasthit, { 255, 0, 0, 255 });
// }
// /*rope->SRV_Lidar()*/
//
// }
//}
if (Settings::SpawnItem) {
Settings::SpawnItem = false;
SDK::FName ItemName;
SDK::ABP_Item_C* Item;
SDK::ABP_DroppedItem_C* ItemDropped;
switch (Settings::ItemToSpawn)
{
case Settings::Flashlight:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Flashlight_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Flaregun:
Item = (SDK::ABP_Item_C*)SDK::ABP_FlareGun_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Crowbar:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Crowbar_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Chainsaw:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Chainsaw_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Almondwater:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_AlmondWater_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Bugspray:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_BugSpray_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Lidar:
ItemDropped = (SDK::ABP_DroppedItem_C*)SDK::ABP_DroppedItem_LiDAR_C::GetDefaultObj();
ItemName = ItemDropped->ID;
break;
case Settings::Jelly:
Item = (SDK::ABP_Item_C*)SDK::ABP_MothJelly_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Speedwateridk:
Item = (SDK::ABP_Item_C*)SDK::ABP_Juice_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Pain:
Item = (SDK::ABP_Item_C*)SDK::ABP_Liquid_Pain_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Rope:
Item = (SDK::ABP_Item_C*)SDK::ABP_Rope_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::AlmondExtract:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_AlmondBottle_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Firework:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Firework_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Ticket:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Ticket_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::DivingHelmet:
Item = (SDK::ABP_Item_C*)SDK::ABP_Diving_Helmet_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Camera:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Camera_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Glowstick:
Item = (SDK::ABP_Item_C*)SDK::ABP_Item_Glowstick_Red_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Thermometer:
Item = (SDK::ABP_Item_C*)SDK::ABP_Thermometer_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::WalkiTalkie:
Item = (SDK::ABP_Item_C*)SDK::ABP_WalkieTalkie_C::GetDefaultObj();
ItemName = Item->ID;
break;
case Settings::Test:
ItemName = SDK::ADefaultPawn::StaticClass()->Name;
break;
default:
break;
}
if (Settings::SilentItemSpawner)
{
auto Inventory = playerState->Items_Rep;
bool Full = true;
for (size_t i = 0; i < Inventory.Num(); i++)
{
if (Inventory[i].ComparisonIndex == 0) {
Full = false;
Inventory[i] = ItemName;
break;
}
}
if (Full)Inventory[Inventory.Num() - 1] = ItemName;
//BPCharacter->
}
else {
Message(std::string("Item dropped: " + ItemName.ToString()));
BPCharacter->DropItem_SERVER(ItemName);
}
}
//BPCharacter->OrientMovement();
if (Settings::LagGame) {
auto ItemClass = (SDK::ABP_DroppedItem_C*)SDK::ABP_DroppedItem_LiDAR_C::GetDefaultObj();
if (ItemClass) {
Settings::LagGame = false;
for (size_t i = 0; i < 300; i++)
{
BPCharacter->DropItem_SERVER(ItemClass->ID);
auto DeleteAbleClass = (SDK::ABP_DroppedItem_C*)GPStatics->GetActorOfClass(WorldP, SDK::ABP_DroppedItem_C::StaticClass());
if (DeleteAbleClass) {
DeleteAbleClass->K2_DestroyActor();
}
}
}
}
if (Settings::ClearItems) {
SDK::TArray<SDK::AActor*> Items;
GPStatics->GetAllActorsOfClass(WorldP, SDK::ABP_DroppedItem_C::StaticClass(), &Items);
if (Items.IsValid()) {
Settings::ClearItems = false;
for (size_t i = 0; i < Items.Num(); i++)
{
if (!Items[i])continue;
auto Item = (SDK::ABP_DroppedItem_C*)Items[i];
BPCharacter->PickUp_SERVER(Item);
}
}
}
#ifdef Gatekeep
if (Settings::UnpossePawns) {
Settings::UnpossePawns = false;
SDK::TArray<SDK::AActor*> Pawns;
GPStatics->GetAllActorsOfClass(WorldP, SDK::AActor::StaticClass(), &Pawns);
if (Pawns.IsValid()) {
for (size_t i = 0; i < Pawns.Num(); i++)
{
auto pawn = Pawns[i];
//BPCharacter->PickUp_SERVER((SDK::ADroppedItem*)Pawns[i]);
//BPCharacter->StartPushingActor_SERVER((SDK::ABP_Pushable_C*)Pawns[i], Pawns[i]->K2_GetActorLocation(), PlayerController->ControlRotation);
//BPCharacter->StopPushingActor_SERVER((SDK::ABP_Pushable_C*)Pawns[i]);
}
}
}
#endif
if (Settings::Kys) {
Settings::Kys = false;
BPCharacter->KillServer();
BPCharacter->KillClient();
}
if (Settings::InfiniteSanity) {
static ULONGLONG TickCountSanity = 0;
static ULONGLONG TickCountSanitybefore = 0;
TickCountSanity = GetTickCount64();
if (TickCountSanity >= TickCountSanitybefore) {
TickCountSanitybefore = TickCountSanity + 1000;
playerState->SRV_AddSanity(100.0f);
playerState->AddSanity(100.0f);
//PlayerController->ServerRestartPlayer();
}
}
}
if (Settings::NoStumble) {
BPCharacter->BalanceFallTimeline->TheTimeline.Length = 0;
BPCharacter->BalanceTimeline->TheTimeline.Length = 200000000;
}
if (Settings::SpeedHack) {
static ULONGLONG TickCountSpeed = 0;
static ULONGLONG TickCountSpeedbefore = 0;
TickCountSpeed = GetTickCount64();
if (TickCountSpeed >= TickCountSpeedbefore) {
TickCountSpeedbefore = TickCountSpeed + 500;
BPCharacter->SetWalkSpeedServer(Settings::Speed);
BPCharacter->SetSprintSpeedServer(Settings::Speed);
BPCharacter->CharacterMovement->MaxWalkSpeed = Settings::Speed;
BPCharacter->CharacterMovement->MaxAcceleration = Settings::Speed;
}
}
static bool WasFlying = false;
static int State = 0;
if (Settings::PlayerFly) {
if (Settings::VelocityFly) {
if (GetAsyncKeyState(VK_SPACE)) {
BPCharacter->SRV_Launch(Settings::PlayerFlySpeedY); BPCharacter->LaunchPawn(SDK::FVector(0, 0, Settings::PlayerFlySpeedY), false, true);
}
}
else
{
WasFlying = true;
BPCharacter->CharacterMovement->MovementMode = SDK::EMovementMode::MOVE_None;
if (GetAsyncKeyState('W')) {
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorForwardVector() * Settings::PlayerFlySpeedY;
auto PlayerPos = PlayerController->AcknowledgedPawn->K2_GetActorLocation();
PlayerController->AcknowledgedPawn->K2_SetActorLocation(SDK::FVector(PlayerPos.X + ForwardCam.X, PlayerPos.Y + ForwardCam.Y, PlayerPos.Z + ForwardCam.Z), false, 0, true);
}
if (GetAsyncKeyState('S')) {
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector ForwardCam = Cam->GetActorForwardVector() * Settings::PlayerFlySpeedY;
auto PlayerPos = PlayerController->AcknowledgedPawn->K2_GetActorLocation();
PlayerController->AcknowledgedPawn->K2_SetActorLocation(SDK::FVector(PlayerPos.X - ForwardCam.X, PlayerPos.Y - ForwardCam.Y, PlayerPos.Z - ForwardCam.Z), false, 0, true);
}
if (GetAsyncKeyState('A')) {
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector RightVector = Cam->GetActorRightVector() * Settings::PlayerFlySpeedY;
auto PlayerPos = PlayerController->AcknowledgedPawn->K2_GetActorLocation();
PlayerController->AcknowledgedPawn->K2_SetActorLocation(SDK::FVector(PlayerPos.X - RightVector.X, PlayerPos.Y - RightVector.Y, PlayerPos.Z - RightVector.Z), false, 0, true);
}
if (GetAsyncKeyState('D')) {
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector RightVector = Cam->GetActorRightVector() * Settings::PlayerFlySpeedY;
auto PlayerPos = PlayerController->AcknowledgedPawn->K2_GetActorLocation();
PlayerController->AcknowledgedPawn->K2_SetActorLocation(SDK::FVector(PlayerPos.X + RightVector.X, PlayerPos.Y + RightVector.Y, PlayerPos.Z + RightVector.Z), false, 0, true);
}
if (GetAsyncKeyState(VK_SPACE)) {
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector UPVector = Cam->GetActorUpVector() * Settings::PlayerFlySpeedY;
auto PlayerPos = PlayerController->AcknowledgedPawn->K2_GetActorLocation();
PlayerController->AcknowledgedPawn->K2_SetActorLocation(SDK::FVector(PlayerPos.X + UPVector.X, PlayerPos.Y + UPVector.Y, PlayerPos.Z + UPVector.Z), false, 0, true);
}
if (GetAsyncKeyState(VK_SHIFT)) {
auto Cam = PlayerController->PlayerCameraManager;
SDK::FVector UPVector = Cam->GetActorUpVector() * Settings::PlayerFlySpeedY;
auto PlayerPos = PlayerController->AcknowledgedPawn->K2_GetActorLocation();
PlayerController->AcknowledgedPawn->K2_SetActorLocation(SDK::FVector(PlayerPos.X - UPVector.X, PlayerPos.Y - UPVector.Y, PlayerPos.Z - UPVector.Z), false, 0, true);
}
#ifdef Gatekeep
if (GetAsyncKeyState(VK_F1)) {
BPCharacter->StartPushingActor_SERVER((SDK::ABP_Pushable_C*)PlayerController->AcknowledgedPawn, PlayerController->AcknowledgedPawn->K2_GetActorLocation(), PlayerController->ControlRotation);
BPCharacter->StopPushingActor_SERVER((SDK::ABP_Pushable_C*)PlayerController->AcknowledgedPawn);
}
#endif
}
}
else
{
if (WasFlying) {
WasFlying = false;
BPCharacter->CharacterMovement->MovementMode = SDK::EMovementMode::MOVE_Walking;
}
}
}
else
{
if (Settings::UnlockPlayers) {
static ULONGLONG TickCount_CreateServer = 0;
if (TickCount >= TickCount_CreateServer) {
TickCount_CreateServer = TickCount + 800;
auto OBJ_List = FindInstances(SDK::UW_CreateServer_C::StaticClass());
for (size_t i = 0; i < OBJ_List.size(); i++)
{
auto OBJ = (SDK::UW_CreateServer_C*)OBJ_List[i];
if (Functions::ShouldUsePointer64(OBJ)) {
OBJ->MaximumPlayers = 100;
//OBJ->ServerName.Set_String(L"None");
if (Functions::ShouldUsePointer64(OBJ->Slider_MaxPlayers))
OBJ->Slider_MaxPlayers->MaxValue = 100;
/*if (Functions::ShouldUsePointer64(OBJ->ServerName.Data))
{
auto textConv = TextLib->Conv_StringToText(SDK::FString(L"AsianBaddie69's game"));
OBJ->ServerName = textConv;
}*/
}
}
/*auto OBJ_Listf = FindInstances(SDK::ALobby_GS_C::StaticClass());
for (size_t i = 0; i < OBJ_Listf.size(); i++)
{
auto OBJ = (SDK::ALobby_GS_C*)OBJ_List[i];
if (Functions::ShouldUsePointer64(OBJ)) {
OBJ->Update_ServerName(OBJ->ServerName.Set_String(L""), );
}
}*/
}
}
}
//if (true) { //Esp Start
SDK::TArray<SDK::AActor*> EnemyArray;
if (Settings::InteractablesEsp || Settings::InteractAll || Settings::InteractEvent || Settings::BringAllItems) {
GPStatics->GetAllActorsOfClass(Engine->GameViewport->World, SDK::AInteractableActor::StaticClass(), &EnemyArray);
if (EnemyArray.IsValid())
for (size_t i = 0; i < EnemyArray.Num(); i++)
{
if (!EnemyArray.IsValidIndex(i) || !EnemyArray[i])continue;
auto CurrentInteractable = (SDK::AInteractableActor*)EnemyArray[i];
/*if (CurrentInteractable->Name.ToString().find("Tape") != std::string::npos) {
CurrentInteractable->K2_SetActorLocation(PlayerController->K2_GetPawn()->K2_GetActorLocation(), false, 0, true);
}*/
if (Settings::InteractAll) {
CurrentInteractable->ResetUsage();
CurrentInteractable->IsUsable = true;
if (!Settings::InteractablesEsp)continue;
}
if (Settings::InteractEvent) {
CurrentInteractable->ResetUsage();
CurrentInteractable->IsUsable = true;
CurrentInteractable->WasUsed = false;
CurrentInteractable->OnUsedServer();
CurrentInteractable->OnRep_WasUsed();
CurrentInteractable->OnUsedAll();
CurrentInteractable->OnUsedMulticast();
CurrentInteractable->OnUsedNotify();
}
if (CurrentInteractable->IsUsable && !CurrentInteractable->WasUsed) {
SDK::FVector2D ScreenPos;
auto Location = CurrentInteractable->K2_GetActorLocation();
if (!GPStatics->ProjectWorldToScreen(PlayerController, Location, &ScreenPos, true))continue;
auto Color = UsefullFuncs::RGBATOFLinear(0, 255, 0, 255);
UsefullFuncs::DrawCircle(Canvas, ScreenPos, 10.0f, 12, Color);
std::wstring TextMsg = UsefullFuncs::stringToWideString(CurrentInteractable->Class->Name.ToString());
ScreenPos.X -= TextMsg.size() * 5.0f / 2;
ScreenPos.Y -= 30.0f;
DrawTextRGBWithFString(Canvas, SDK::FString(TextMsg.c_str()), ScreenPos, Color, false, 1.1f);
}
}
GPStatics->GetAllActorsOfClass(Engine->GameViewport->World, SDK::AInteractablePawn::StaticClass(), &EnemyArray);
if (EnemyArray.IsValid()) {
for (size_t i = 0; i < EnemyArray.Num(); i++)
{
if (!EnemyArray.IsValidIndex(i) || !EnemyArray[i])continue;
auto CurrentInteractable = (SDK::AInteractablePawn*)EnemyArray[i];
if (Settings::InteractAll) {
CurrentInteractable->ResetUsage();
CurrentInteractable->IsUsable = true;
if (!Settings::InteractablesEsp)continue;
}
if (CurrentInteractable->IsUsable && !CurrentInteractable->WasUsed) {
SDK::FVector2D ScreenPos;
auto Location = CurrentInteractable->K2_GetActorLocation();
if (!GPStatics->ProjectWorldToScreen(PlayerController, Location, &ScreenPos, true))continue;
auto Color = UsefullFuncs::RGBATOFLinear(0, 255, 0, 255);
UsefullFuncs::DrawCircle(Canvas, ScreenPos, 10.0f, 12, Color);
std::wstring TextMsg = UsefullFuncs::stringToWideString(CurrentInteractable->Class->Name.ToString());
ScreenPos.X -= TextMsg.size() * 5.0f / 2;
ScreenPos.Y -= 30.0f;
DrawTextRGBWithFString(Canvas, SDK::FString(TextMsg.c_str()), ScreenPos, Color, false, 1.1f);
}
}
}
if (Settings::InteractEvent)Settings::InteractEvent = false;
if (Settings::BringAllItems)Settings::BringAllItems = false;
}
if (EnemyArray.IsValid() && Settings::PeacefullMode || Settings::PlayerEsp || Settings::RandomName || Settings::Godmode || Settings::EnemyEsp || Settings::ForceAdmin || Settings::TpEveryone) {
GPStatics->GetAllActorsOfClass(Engine->GameViewport->World, SDK::ACharacter::StaticClass(), &EnemyArray);
SDK::UClass* StaticSkinMf = nullptr;
SDK::UClass* StaticBacteriaMf = nullptr;
SDK::UClass* StaticHowlerMf = nullptr;
static bool HideActors = false;
if (Settings::PeacefullMode) { HideActors = true; StaticSkinMf = SDK::ABP_SkinStealer_C::StaticClass(); StaticBacteriaMf = SDK::ABacteria_BP_C::StaticClass(); StaticHowlerMf = SDK::AHowler_BP_C::StaticClass(); }
if (Settings::RandomName)
srand(time(NULL));
for (size_t i = 0; i < EnemyArray.Num(); i++)
{
if (!EnemyArray.IsValidIndex(i) || !EnemyArray[i] || EnemyArray[i] == PlayerController->Character)continue;
auto CurrentEnemy = (SDK::ACharacter*)EnemyArray[i];
auto Name = CurrentEnemy->Name.ToString();
if (Name.find("BPCharacter_Demo_C") != std::string::npos) {
auto CharacterBP = (SDK::ABPCharacter_Demo_C*)CurrentEnemy;
auto StateBP = (SDK::AMP_PS_C*)CharacterBP->PlayerState;
if (CharacterBP) {
#ifdef Gatekeep
if (Settings::ForceAdmin)
{
//BPCharacter->PickUp_SERVER((SDK::ADroppedItem*)CharacterBP);
//StateBP->SRV_AddSanity(-100.0f);
//CharacterBP->ShockedServer();
if (BPCharacter->GetOwner() == StateBP)
PlayerController->ServerAcknowledgePossession(CharacterBP);
//CharacterBP->ShockedClient();
}
/*if (Settings::RandomName && StateBP) {
auto numb = rand() % 50 + 1;
if (numb == 25) {
PlayerController->ServerChangeName(StateBP->PlayerNamePrivate);
}
}*/
#endif
if (Settings::TpEveryone) {
CharacterBP->Mesh->SetCollisionResponseToChannel(SDK::ECollisionChannel::ECC_Pawn, SDK::ECollisionResponse::ECR_Ignore);
CharacterBP->CapsuleComponent->SetCollisionResponseToChannel(SDK::ECollisionChannel::ECC_Pawn, SDK::ECollisionResponse::ECR_Ignore);
//CharacterBP->CharacterMovement->MaxWalkSpeed = 20000.0f;
//CharacterBP->CharacterMovement->MaxAcceleration = 20000.0f;
CharacterBP->CharacterMovement->GravityScale = 0.5f;
CharacterBP->K2_SetActorLocation(BPCharacter->K2_GetActorLocation(), false, 0, true);
}
if (Settings::PlayerEsp) {
if (StateBP)
{
//auto Controller = CharacterBP->Controller;
int isOwner = StateBP->PlayerId == PlayerStuff::PlayerList[0].PlayerID && StateBP->PlayerId < PlayerController->PlayerState->PlayerId;
std::string Role = isOwner ? " (Owner)" : "";
UsefullFuncs::DrawBoxOnActor(Canvas, CurrentEnemy, isOwner ? UsefullFuncs::RGBATOFLinear(0, 255, 255, 255) : UsefullFuncs::RGBATOFLinear(0, 255, 0, 255), true, UsefullFuncs::stringToWideString(std::string(StateBP->PlayerNamePrivate.ToString() + Role)).c_str());
}
}
}
}
else {
if (Settings::PeacefullMode) {
CurrentEnemy->SetActorHiddenInGame(true);
CurrentEnemy->SetActorEnableCollision(false);
continue;
}
else
{
if (HideActors == true) {
CurrentEnemy->SetActorHiddenInGame(false);
CurrentEnemy->SetActorEnableCollision(true);
}
}
if (Settings::Godmode) {
auto Name = CurrentEnemy->Class->Name;
if (StaticSkinMf && Name == StaticSkinMf->Name) {
auto SkinNigga = (SDK::ABP_SkinStealer_C*)CurrentEnemy;
if (Settings::Godmode)
SkinNigga->CanAttack = false;
}
else
if (StaticBacteriaMf && Name == StaticBacteriaMf->Name) {
auto BacteriaNigga = (SDK::ABacteria_BP_C*)CurrentEnemy;
if (Settings::Godmode)
BacteriaNigga->CanAttack = false;
}
else
if (StaticHowlerMf && Name == StaticHowlerMf->Name) {
auto HowlerNigga = (SDK::AHowler_BP_C*)CurrentEnemy;
//if (Settings::Godmode)
// HowlerNigga->CanAttack = false;
}
}
if (Settings::EnemyEsp) {
UsefullFuncs::DrawBoxOnActor(Canvas, CurrentEnemy, UsefullFuncs::RGBATOFLinear(255, 0, 0, 255));
}
}
}
if (HideActors)HideActors = false;
if (Settings::ForceAdmin)Settings::ForceAdmin = false;
if (Settings::TpEveryone)Settings::TpEveryone = false;
}
if (Settings::ItemEsp) {
GPStatics->GetAllActorsOfClass(Engine->GameViewport->World, SDK::ABP_DroppedItem_C::StaticClass(), &EnemyArray);
if (EnemyArray.IsValid()) {
for (size_t i = 0; i < EnemyArray.Num(); i++)
{
if (!EnemyArray.IsValidIndex(i) || !EnemyArray[i])continue;
auto CurrentThing = (SDK::ABP_DroppedItem_C*)EnemyArray[i];
//UsefullFuncs::DrawBoxOnActor(Canvas, CurrentEnemy, UsefullFuncs::RGBATOFLinear(255, 0, 0, 255));
SDK::FVector2D ScreenPos;
auto Location = CurrentThing->K2_GetActorLocation();
if (!GPStatics->ProjectWorldToScreen(PlayerController, Location, &ScreenPos, true))continue;
auto Color = UsefullFuncs::RGBATOFLinear(0, 255, 255, 255);
UsefullFuncs::DrawCircle(Canvas, ScreenPos, 10.0f, 12, Color);
std::wstring TextMsg = L"Item_" + UsefullFuncs::stringToWideString(CurrentThing->ID.ToString());
ScreenPos.X -= TextMsg.size() * 5.0f / 2;
ScreenPos.Y -= 30.0f;
DrawTextRGBWithFString(Canvas, SDK::FString(TextMsg.c_str()), ScreenPos, Color, false, 1.1f);
}
}
}
static bool CamsOff = false;
static ULONGLONG CamsTickCurrent = 0;
static ULONGLONG CamsTickBefore = 0;
if (Settings::NoCams) {
CamsTickCurrent = GetTickCount64();
if (CamsTickCurrent >= CamsTickBefore) {
CamsTickBefore = CamsTickCurrent + 2000;
CamsOff = true;
}
else
CamsOff = false;
}
if (Settings::TpToExit) {
Settings::TpToExit = false;
if (SDK::ABP_ExitZone_C::StaticClass()) {
auto ExitZone = GPStatics->GetActorOfClass(Engine->GameViewport->World, SDK::ABP_ExitZone_C::StaticClass());
if (ExitZone && PlayerController->Pawn) {
PlayerController->Pawn->K2_SetActorLocation(ExitZone->K2_GetActorLocation(), false, 0, true);
}
else
{
if (!ExitZone)Message("Found the ExitZone Class but no Actor");
if (!PlayerController->Pawn)Message("Player Pawn is Invalid cant Teleport ya");
}
}
else
{
Message("Cant find an ExitZone!, probly some cutscene level shit.");
}
}
if (Settings::ActorEsp || Settings::ActorEvent || CamsOff) {
GPStatics->GetAllActorsOfClass(Engine->GameViewport->World, SDK::AActor::StaticClass(), &EnemyArray);
if (EnemyArray.IsValid()) {
static bool WallsHidden = false;
for (size_t i = 0; i < EnemyArray.Num(); i++)
{
if (!EnemyArray.IsValidIndex(i) || !UsefullFuncs::ShouldUsePtr(EnemyArray[i]))continue;
auto CurrentEnemy = EnemyArray[i];
if (CamsOff) {
if (strToLower(CurrentEnemy->Name.ToString()).find("securitycam") != std::string::npos) {
CurrentEnemy->SetActorHiddenInGame(true);
CurrentEnemy->SetActorEnableCollision(false);
}
if (!Settings::ActorEsp)continue;
}
if (Settings::ActorEvent) {
if (Settings::HideWalls) {
if (WallsHidden) {
if (strToLower(CurrentEnemy->Name.ToString()).find("door") != std::string::npos) {
CurrentEnemy->SetActorHiddenInGame(false);
CurrentEnemy->SetActorEnableCollision(true);
}
}
else
{
if (strToLower(CurrentEnemy->Name.ToString()).find("door") != std::string::npos) {
CurrentEnemy->SetActorHiddenInGame(true);
CurrentEnemy->SetActorEnableCollision(false);
}
}
}
if (!Settings::ActorEsp)continue;
}
if (CurrentEnemy->Name.ToString().find(Settings::ActorFilter) == std::string::npos)continue;
SDK::FVector2D ScreenPos;
auto Location = CurrentEnemy->K2_GetActorLocation();
if (!GPStatics->ProjectWorldToScreen(PlayerController, Location, &ScreenPos, true))continue;
auto Color = UsefullFuncs::RGBATOFLinear(255, 0, 0, 255);
UsefullFuncs::DrawCircle(Canvas, ScreenPos, 10.0f, 12, Color);
std::wstring TextMsg = UsefullFuncs::stringToWideString(CurrentEnemy->Class->GetName());
ScreenPos.X -= TextMsg.size() * 5.0f / 2;
ScreenPos.Y -= 30.0f;
DrawTextRGBWithFString(Canvas, SDK::FString(TextMsg.c_str()), ScreenPos, Color, false, 1.1f);
}
if (Settings::ActorEvent) {
Settings::ActorEvent = false;
if (Settings::HideWalls)
WallsHidden = !WallsHidden;
}
}
}
// }//Esp End
}
}
}
#include "HostModifiers.h"
void RunMainHost()
{
HostOptions::Mainrun_Host();
Update Cheat.h
2024-04-20 21:09:57 +08:00
}
Reference in New Issue Copy Permalink