#include "imgui/imgui.h"
#include "imgui/backends/imgui_impl_android.h"
#include "imgui/backends/imgui_impl_opengl3.h"
#include "Iconcpp.h"
#include "ImguiPP.h"
#include "Menu.h"
#include "Font.h"
#include "Icon.h"
#include "Helper/fake_dlfcn.h"
#include "Helper/Includes.h"
#include "Helper/plthook.h"
#include "Helper/json.hpp"
#include "Helper/Items.h"
#include "StrEnc.h"
#include "Spoof.h"
#include "Tools.h"
#include "SDK.hpp"
#include "base64/base64.h"
#include "obfuscate.h"
bool WriteAddr(void *addr, void *buffer, size_t length) {
unsigned long page_size = sysconf(_SC_PAGESIZE);
unsigned long size = page_size * sizeof(uintptr_t);
return mprotect((void *) ((uintptr_t) addr - ((uintptr_t) addr % page_size) - page_size), (size_t) size, PROT_EXEC | PROT_READ | PROT_WRITE) == 0 && memcpy(addr, buffer, length) != 0;
}
template<typename T>
void Write(uintptr_t addr, T value) {
WriteAddr((void *) addr, &value, sizeof(T));
}
using json = nlohmann::json;
using namespace SDK;
#include <curl/curl.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
// ======================================================================== //
bool WideView = false;
bool FlashSdk = false;
bool Bypass = true;
bool initImGui = false;
int screenWidth = -1, glWidth, screenHeight = -1, glHeight;
float density = -1;
json items_data;
static std::string EXP = "00:00:00:00:00:00:00";
std::string name ="";
std::string device = "";
std::string status = "";
std::string floating ="";
//add std your panel
std::string g_Token, g_Auth;
bool bValid = false;
#define SLEEP_TIME 1000LL / 120LL
uintptr_t tersafe;
// ======================================================================== //
enum EAim {
Distance = 0,
Croshhair = 1
};
enum EAimTarget {
Head = 0,
Chest = 1
};
enum EAimTrigger {
None = 0,
Shooting = 1,
Scoping = 2,
Both = 3,
Any = 4
};
std::map<int, bool> Items;
std::map<int, float *> ItemColors;
struct sConfig {
bool Bypass;
/*bool Ipad;*/
struct sESPMenu {
bool Line;
bool Box;
bool Skeleton;
bool Health;
bool Name;
bool AutoFire;
/* bool Ipad;*/
bool Distance;
/*bool LootBox;*/
bool TeamID;
bool NoBot;
/*bool Vehicle;
bool Grenade;*/
};
sESPMenu ESPMenu;
struct smemory {
bool Shake;
bool Recoil;
bool Instant;
bool HitEffect;
bool Wall;
bool View;
bool Flash;
bool Wal;
bool AutoFire;
};
smemory memory{0};
struct sVehicleESP {
bool ShowVehicle;
bool ShowDistance;
};
sVehicleESP VehicleESP{0};
struct sWeaponAim {
float Cross;
bool Enable;
EAimTarget Target;
EAimTrigger Trigger;
bool IgnoreKnocked;
bool VisCheck;
bool IgnoreBot;
};
sWeaponAim BulletTracking{0};
struct sOTHER {
bool FPS;
};
sOTHER OTHER{0};
struct sColorsESP {
float *Text;
float *Line;
float *Box;
float *Name;
float *Distance;
float *Skeleton;
float *Vehicle;
float *Menucolour;
float *Fov;
float *Cross;
float *Linebot;
float *Boxbot;
float *Count;
float *Skeletonbot;
};
sColorsESP ColorsESP{0};
};
sConfig Config{0};
#define CREATE_COLOR(r, g, b, a) new float[4] {(float)r, (float)g, (float)b, (float)a};
uintptr_t g_UE4;
uintptr_t Anogs;
uintptr_t g_gcloud;
uintptr_t g_swappy;
uintptr_t g_TDataMaster;
uintptr_t AimBullet_Offset;
uintptr_t GWorld_Offset, GUObjectArray_Offset, SilentAim_Offset;
android_app *g_App = 0;
ASTExtraPlayerCharacter *g_LocalPlayer = 0;
ASTExtraPlayerController *g_LocalController = 0;
#define ProcessEvent_Offset 0x7A51ED0 // я ебал собак
#define GEngine_Offset 0x7583B08 //
#define GNames_Offset 0x2AC7B4C //
#define GUObject_Offset 0x78F4120 //
#define GNativeAndroidApp_Offset 0x7579318 //
#define Actors_Offset 0x70
struct sRegion {
uintptr_t start, end;
};
std::vector<sRegion> trapRegions;
bool isObjectInvalid(UObject *obj) {
if (!Tools::IsPtrValid(obj)) {
return true;
}
if (!Tools::IsPtrValid(obj->ClassPrivate)) {
return true;
}
if (obj->InternalIndex <= 0) {
return true;
}
if (obj->NamePrivate.ComparisonIndex <= 0) {
return true;
}
if ((uintptr_t)(obj) % sizeof(uintptr_t) != 0x0 && (uintptr_t)(obj) % sizeof(uintptr_t) != 0x4) {
return true;
}
if (std::any_of(trapRegions.begin(), trapRegions.end(), [obj](sRegion region) { return ((uintptr_t) obj) >= region.start && ((uintptr_t) obj) <= region.end; }) ||
std::any_of(trapRegions.begin(), trapRegions.end(), [obj](sRegion region) { return ((uintptr_t) obj->ClassPrivate) >= region.start && ((uintptr_t) obj->ClassPrivate) <= region.end; })) {
return true;
}
return false;
}
UWorld *GetWorld() {
auto GEngine = *(UEngine **) (g_UE4 + GEngine_Offset);;
if (GEngine) {
auto ViewPort = GEngine->GameViewport;
if (ViewPort) {
return ViewPort->World;
}
}
return 0;
}
TNameEntryArray *GetGNames() {
return ((TNameEntryArray *(*)()) (g_UE4 + GNames_Offset))();
}
TArray<AActor *> getActors() {
auto World = GetWorld();
if (World) {
auto PersistentLevel = World->PersistentLevel;
if (PersistentLevel) {
return *(TArray<AActor *> *) ((uintptr_t) PersistentLevel + Actors_Offset);
}
}
return TArray<AActor *>();
}
bool UObject::IsA(UClass *cmp) const {
for (auto super = ClassPrivate; !isObjectInvalid(super); super = static_cast<UClass *>(super->SuperStruct)) {
if (super == cmp) {
return true;
}
}
return false;
}
// ======================================================================== //
std::string getObjectPath(UObject *Object) {
std::string s;
for (auto super = Object->ClassPrivate; super; super = (UClass *) super->SuperStruct) {
if (!s.empty())
s += ".";
s += super->NamePrivate.GetName();
}
return s;
}
// ======================================================================== //
int32_t ToColor(float *col) {
return ImGui::ColorConvertFloat4ToU32(*(ImVec4 *) (col));
}
//==//
FRotator ToRotator(FVector local, FVector target) {
FVector rotation = UKismetMathLibrary::Subtract_VectorVector(local, target);
float hyp = sqrt(rotation.X * rotation.X + rotation.Y * rotation.Y);
FRotator newViewAngle = {0};
newViewAngle.Pitch = -atan(rotation.Z / hyp) * (180.f / (float) 3.14159265358979323846);
newViewAngle.Yaw = atan(rotation.Y / rotation.X) * (180.f / (float) 3.14159265358979323846);
newViewAngle.Roll = (float) 0.f;
if (rotation.X >= 0.f)
newViewAngle.Yaw += 180.0f;
return newViewAngle;
}
#define W2S(w, s) UGameplayStatics::ProjectWorldToScreen(localController, w, true, s)
//=====BukketTrack======//
auto GetTargetForBT() {
ASTExtraPlayerCharacter *result = 0;
float max = std::numeric_limits<float>::infinity();
auto GWorld = GetWorld();
if (GWorld) {
ULevel *PersistentLevel = GWorld->PersistentLevel;
if (PersistentLevel) {
TArray<AActor *> Actors = *(TArray<AActor *> *) ((uintptr_t) PersistentLevel +
Actors_Offset);
auto localPlayer = g_LocalPlayer;
auto localController = g_LocalController;
if (localPlayer) {
for (int i = 0; i < Actors.Num(); i++) {
auto Actor = Actors[i];
if (isObjectInvalid(Actor))
continue;
if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass())) {
auto Player = (ASTExtraPlayerCharacter *) Actor;
if (Player->PlayerKey == localPlayer->PlayerKey)
continue;
if (Player->TeamID == localPlayer->TeamID)
continue;
if (Player->bDead)
continue;
if (Config.BulletTracking.IgnoreKnocked) {
if (Player->Health == 0.0f)
continue;
}
if (Config.BulletTracking.VisCheck) {
if (!localController->LineOfSightTo(Player, {0, 0, 0}, true))
continue;
}
/* if (Config.BulletTracking.Enable) {
if (Player->bIsAI)
continue;
}*/
auto Root = Player->GetBonePos("Root", {});
auto Head = Player->GetBonePos("Head", {});
FVector2D RootSc, HeadSc;
if (W2S(Root, &RootSc) && W2S(Head, &HeadSc)) {
float height = abs(HeadSc.Y - RootSc.Y);
float width = height * 0.65f;
FVector middlePoint = {HeadSc.X + (width / 2), HeadSc.Y + (height / 2),
0};
if ((middlePoint.X >= 0 && middlePoint.X <= glWidth) &&
(middlePoint.Y >= 0 && middlePoint.Y <= glHeight)) {
FVector2D v2Middle = FVector2D((float) (glWidth / 2),
(float) (glHeight / 2));
FVector2D v2Loc = FVector2D(middlePoint.X, middlePoint.Y);
float dist = FVector2D::Distance(v2Middle, v2Loc);
if (dist < max) {
max = dist;
result = Player;
}
}
}
}
}
}
return result;
}
}
}
//=======//
auto GetTargetByCrossDist() {
ASTExtraPlayerCharacter *result = 0;
float max = std::numeric_limits<float>::infinity();
auto GWorld = GetWorld();
if (GWorld) {
ULevel *PersistentLevel = GWorld->PersistentLevel;
if (PersistentLevel) {
TArray<AActor *> Actors = *(TArray<AActor *> *) ((uintptr_t) PersistentLevel + Actors_Offset);
auto localPlayer = g_LocalPlayer;
auto localController = g_LocalController;
if (localPlayer) {
for (int i = 0; i < Actors.Num(); i++) {
auto Actor = Actors[i];
if (isObjectInvalid(Actor))
continue;
if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass())) {
auto Player = (ASTExtraPlayerCharacter *) Actor;
if (Player->PlayerKey == localPlayer->PlayerKey)
continue;
if (Player->bDead)
continue;
if (Config.BulletTracking.VisCheck) {
if (!localController->LineOfSightTo(Player, {0, 0, 0}, true))
continue;
}
auto Root = Player->GetBonePos("Root", {});
auto Head = Player->GetBonePos("Head", {});
FVector2D RootSc, HeadSc;
if (W2S(Root, &RootSc) && W2S(Head, &HeadSc)) {
float height = abs(HeadSc.Y - RootSc.Y);
float width = height * 0.65f;
FVector middlePoint = {HeadSc.X + (width / 2), HeadSc.Y + (height / 2), 0};
if ((middlePoint.X >= 0 && middlePoint.X <= glWidth) && (middlePoint.Y >= 0 && middlePoint.Y <= glHeight)) {
FVector2D v2Middle = FVector2D((float) (glWidth / 2), (float) (glHeight / 2));
FVector2D v2Loc = FVector2D(middlePoint.X, middlePoint.Y);
float dist = FVector2D::Distance(v2Middle, v2Loc);
if (dist < max) {
max = dist;
result = Player;
}
}
}
}
}
}
}
}
return result;
}
const char *GetVehicleName(ASTExtraVehicleBase *Vehicle) {
switch (Vehicle->VehicleShapeType) {
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Motorbike:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Motorbike_SideCart:
return "Motorbike";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Dacia:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_HeavyDacia:
return "Dacia";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_MiniBus:
return "Mini Bus";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_PickUp:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_PickUp01:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_HeavyPickup:
return "Pick Up";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Buggy:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_HeavyBuggy:
return "Buggy";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_UAZ:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_UAZ01:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_UAZ02:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_UAZ03:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_HeavyUAZ:
return "UAZ";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_PG117:
return "PG117";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Aquarail:
return "Aquarail";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Mirado:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Mirado01:
return "Mirado";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Rony:
return "Rony";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Scooter:
return "Scooter";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_SnowMobile:
return "Snow Mobile";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_TukTukTuk:
return "Tuk Tuk";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_SnowBike:
return "Snow Bike";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Surfboard:
return "Surf Board";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Snowboard:
return "Snow Board";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Amphibious:
return "Amphibious";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_LadaNiva:
return "Lada Niva";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_UAV:
return "UAV";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_MegaDrop:
return "Mega Drop";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Lamborghini:
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_Lamborghini01:
return "Lamborghini";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_GoldMirado:
return "Gold Mirado";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_BigFoot:
return "Big Foot";
break;
case ESTExtraVehicleShapeType::ESTExtraVehicleShapeType__VST_HeavyUH60:
return "UH60";
break;
default:
return "Vehicle";
break;
}
return "Vehicle";
}
void (*orig_shoot_event)(USTExtraShootWeaponComponent *thiz, FVector start, FRotator rot, void *unk1, int unk2) = 0;
void shoot_event(USTExtraShootWeaponComponent *thiz, FVector start, FRotator rot, ASTExtraShootWeapon *weapon, int unk1) {
//=================///
if (Config.BulletTracking.Enable) {
ASTExtraPlayerCharacter *Target = GetTargetForBT();
if (Target) {
bool triggerOk = false;
if (Config.BulletTracking.Trigger != EAimTrigger::None) {
if (Config.BulletTracking.Trigger == EAimTrigger::Shooting) {
triggerOk = g_LocalPlayer->bIsWeaponFiring;
} else if (Config.BulletTracking.Trigger == EAimTrigger::Scoping) {
triggerOk = g_LocalPlayer->bIsGunADS;
} else if (Config.BulletTracking.Trigger == EAimTrigger::Both) {
triggerOk = g_LocalPlayer->bIsWeaponFiring && g_LocalPlayer->bIsGunADS;
} else if (Config.BulletTracking.Trigger == EAimTrigger::Any) {
triggerOk = g_LocalPlayer->bIsWeaponFiring || g_LocalPlayer->bIsGunADS;
}
} else triggerOk = true;
if (triggerOk) {
FVector targetAimPos = Target->GetBonePos("Head", {});
if (Config.BulletTracking.Target == EAimTarget::Chest) {
targetAimPos.Z -= 25.0f;
}
UShootWeaponEntity *ShootWeaponEntityComponent = thiz->ShootWeaponEntityComponent;
if (ShootWeaponEntityComponent) {
ASTExtraVehicleBase *CurrentVehicle = Target->CurrentVehicle;
if (CurrentVehicle) {
FVector LinearVelocity = CurrentVehicle->ReplicatedMovement.LinearVelocity;
float dist = g_LocalPlayer->GetDistanceTo(Target);
auto timeToTravel = dist / ShootWeaponEntityComponent->BulletFireSpeed;
targetAimPos = UKismetMathLibrary::Add_VectorVector(targetAimPos, UKismetMathLibrary::Multiply_VectorFloat(LinearVelocity, timeToTravel));
} else {
FVector Velocity = Target->GetVelocity();
float dist = g_LocalPlayer->GetDistanceTo(Target);
auto timeToTravel = dist / ShootWeaponEntityComponent->BulletFireSpeed;
targetAimPos = UKismetMathLibrary::Add_VectorVector(targetAimPos, UKismetMathLibrary::Multiply_VectorFloat(Velocity, timeToTravel));
}
rot = ToRotator(g_LocalController->PlayerCameraManager->CameraCache.POV.Location, targetAimPos);
}
}
}
}
return orig_shoot_event(thiz, start, rot, weapon, unk1);
}
class FPSCounter {
protected:
unsigned int m_fps;
unsigned int m_fpscount;
long m_fpsinterval;
public:
FPSCounter() : m_fps(0), m_fpscount(0), m_fpsinterval(0) {
}
void update() {
m_fpscount++;
if (m_fpsinterval < time(0)) {
m_fps = m_fpscount;
m_fpscount = 0;
m_fpsinterval = time(0) + 1;
}
}
unsigned int get() const {
return m_fps;
}
};
FPSCounter fps;
void DrawBoxEnemy(ImDrawList *draw, ImVec2 X, ImVec2 Y, float thicc, int color) {
draw->AddLine({X.x, X.y}, {Y.x, Y.y}, color, thicc);
}
//===================== ESP DRAW =====================//
void DrawESP(ImDrawList *draw) {
//bypass
auto GWorld = GetWorld();
if (GWorld) {
if (GWorld->PersistentLevel) {
auto Actors = *(TArray<AActor *> *) ((uintptr_t) GWorld->PersistentLevel + Actors_Offset);
int totalEnemies = 0, totalBots = 0;
ASTExtraPlayerCharacter *localPlayer = 0;
ASTExtraPlayerController *localController = 0;
draw->AddText(NULL, ((float) density / 10.0f),{(float) glWidth / 150 + glWidth / 40,640},IM_COL32(255, 0, 0, 255),
" DCX CHEATS 2.1 ");
//add yourr text
std::string sFPS = "\n\nFPS : ";
sFPS += std::to_string(fps.get());
if (Config.OTHER.FPS) {
draw->AddText({((float) density / 10.0f), 40},IM_COL32(255,255,0, 255),sFPS.c_str());
}
for (int i = 0; i < Actors.Num(); i++) {
auto Actor = Actors[i];
if (isObjectInvalid(Actor))
continue;
if (Actor->IsA(ASTExtraPlayerController::StaticClass())) {
localController = (ASTExtraPlayerController *) Actor;
break;
}
}
if (localController) {
for (int i = 0; i < Actors.Num(); i++) {
auto Actor = Actors[i];
if (isObjectInvalid(Actor))
continue;
if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass())) {
if (((ASTExtraPlayerCharacter *) Actor)->PlayerKey == localController->PlayerKey) {
localPlayer = (ASTExtraPlayerCharacter *) Actor;
break;
}
}
}
if (localPlayer) {
if (localPlayer->PartHitComponent) {
auto ConfigCollisionDistSqAngles = localPlayer->PartHitComponent->ConfigCollisionDistSqAngles;
for (int j = 0; j < ConfigCollisionDistSqAngles.Num(); j++) {
ConfigCollisionDistSqAngles[j].Angle = 90.0f;
}
localPlayer->PartHitComponent->ConfigCollisionDistSqAngles = ConfigCollisionDistSqAngles;
}
if (Config.BulletTracking.Enable) {
auto WeaponManagerComponent = localPlayer->WeaponManagerComponent;
if (WeaponManagerComponent) {
auto propSlot = WeaponManagerComponent->GetCurrentUsingPropSlot();
if ((int) propSlot.GetValue() >= 1 && (int) propSlot.GetValue() <= 3) {
auto CurrentWeaponReplicated = (ASTExtraShootWeapon *) WeaponManagerComponent->CurrentWeaponReplicated;
if (CurrentWeaponReplicated) {
auto ShootWeaponComponent = CurrentWeaponReplicated->ShootWeaponComponent;
if (ShootWeaponComponent) {
int shoot_event_idx = 158;
auto VTable = (void **) ShootWeaponComponent->VTable;
if (VTable && (VTable[shoot_event_idx] != shoot_event)) {
orig_shoot_event = decltype(orig_shoot_event)(VTable[shoot_event_idx]);
VTable[shoot_event_idx] = (void *) shoot_event;
}
}
}
}
}
}
for (int i = 0; i < Actors.Num(); i++) {
auto Actor = Actors[i];
if (isObjectInvalid(Actor))
continue;
if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass())) {
long PlayerBoxClrCf = IM_COL32(0, 255, 47, 255);
long PlayerBoxClrCf2 = IM_COL32(0, 255, 47, 25);
auto Player = (ASTExtraPlayerCharacter *) Actor;
if (!localController->LineOfSightTo(Player, {0, 0, 0}, true)) {
PlayerBoxClrCf = IM_COL32(255, 119, 0, 255);
PlayerBoxClrCf2 = IM_COL32(255, 119, 0, 25);
}
float Distance = localPlayer->GetDistanceTo(Player) / 100.0f;
if (Distance > 500.0f)
continue;
if (Player->PlayerKey == localController->PlayerKey)
continue;
if (Player->TeamID == localController->TeamID)
continue;
if (Player->bDead)
continue;
// if (!Player->Mesh)
// continue;
if (Player->bIsAI)
totalBots++;
else totalEnemies++;
if (Config.ESPMenu.NoBot)
if (Player->bIsAI)
continue;
float magic_number = (Distance);
float mx = (glWidth / 4) / magic_number;
float healthLength = glWidth / 17;
if (healthLength < mx)
healthLength = mx;
auto HeadPos = Player->GetBonePos("Head", {});
HeadPos.Z = HeadPos.Z + 1.0f; //head se line ooper
ImVec2 headPosSC;
auto RootPos = Player->GetBonePos("Root", {});
ImVec2 RootPosSC;
if (W2S(HeadPos, (FVector2D *) &headPosSC) && W2S(RootPos, (FVector2D *) &RootPosSC)) {
if (Config.ESPMenu.Line) {
draw->AddLine({(float) glWidth / 2, 0}, headPosSC,
PlayerBoxClrCf, 0.6f);
}
/* if (Config.ESPMenu.LootBox) {
if (Actor->IsA(APickUpListWrapperActor::StaticClass())) {
auto LootBox = (APickUpListWrapperActor *) Actor;
auto RootComponent = Actor->RootComponent;
if (!RootComponent)
continue;
float Distance = LootBox->GetDistanceTo(localPlayer) / 100.f;
FVector2D lootboxPos;
if (W2S(LootBox->K2_GetActorLocation(), &lootboxPos)) {
std::string s = "LootBox";
s += "[";
s += std::to_string((int) Distance);
s += "M]";
draw->AddText(NULL, ((float) density / 26.0f),
{lootboxPos.X, lootboxPos.Y},
IM_COL32(255, 255, 000, 255), s.c_str());
}
}
}
/* if (Config.ESPMenu.Vehicle) {
if (Actors[i]->IsA(ASTExtraVehicleBase::StaticClass())) {
auto Vehicle = (ASTExtraVehicleBase *) Actors[i];
if (!Vehicle->Mesh)
continue;
float Distance = Vehicle->GetDistanceTo(localPlayer) / 100.f;
FVector2D vehiclePos;
if (W2S(Vehicle->K2_GetActorLocation(), &vehiclePos)) {
std::string s = GetVehicleName(Vehicle);
s += " [";
s += std::to_string((int) Distance);
s += "m]";
draw->AddText(NULL, ((float) density / 30.0f),
{vehiclePos.X, vehiclePos.Y},
IM_COL32(255, 255, 000, 255), s.c_str());
}
}
}*/
/* if (Config.ESPMenu.Grenade) {
if (Actor->IsA(ASTExtraGrenadeBase::StaticClass())) {
auto Grenade = (ASTExtraGrenadeBase *) Actor;
auto RootComponent = Actor->RootComponent;
if (!RootComponent)
continue;
float Distance = Grenade->GetDistanceTo(localPlayer) / 100.f;
FVector2D grenadePos;
if (W2S(Grenade->K2_GetActorLocation(), &grenadePos)) {
std::string s = "Grenade";
s += "[";
s += std::to_string((int) Distance);
s += "M]";
draw->AddText(NULL, ((float) density / 26.0f),
{grenadePos.X, grenadePos.Y},
IM_COL32(255, 255, 000, 255), s.c_str());
}
}
}*/
if (Config.ESPMenu.Box) {
float boxHeight = abs(headPosSC.y - RootPosSC.y);
float boxWidth = boxHeight * 0.65f;
ImVec2 vStart = {headPosSC.x - (boxWidth / 2), headPosSC.y};
ImVec2 vEnd = {vStart.x + boxWidth, vStart.y + boxHeight};
draw->AddRect(vStart, vEnd, PlayerBoxClrCf, 1.5f, 240, 1.7f);
draw->AddRectFilled(vStart, vEnd, PlayerBoxClrCf2, 1.5f, 240);
}
if (Config.ESPMenu.Skeleton) {
static std::vector<std::string> right_arm{"neck_01",
"clavicle_r",
"upperarm_r",
"lowerarm_r",
"hand_r", "item_r"};
static std::vector<std::string> left_arm{"neck_01",
"clavicle_l",
"upperarm_l",
"lowerarm_l",
"hand_l", "item_l"};
static std::vector<std::string> spine{"Head", "neck_01",
"spine_03",
"spine_02", "spine_01",
"pelvis"};
static std::vector<std::string> lower_right{"pelvis", "thigh_r",
"calf_r", "foot_r"};
static std::vector<std::string> lower_left{"pelvis", "thigh_l",
"calf_l", "foot_l"};
static std::vector<std::vector<std::string>> skeleton{right_arm,
left_arm,
spine,
lower_right,
lower_left};
for (auto &boneStructure: skeleton) {
std::string lastBone;
for (std::string ¤tBone: boneStructure) {
if (!lastBone.empty()) {
ImVec2 boneFrom, boneTo;
if (W2S(Player->GetBonePos(lastBone.c_str(), {}),
(FVector2D *) &boneFrom) &&
W2S(Player->GetBonePos(currentBone.c_str(), {}),
(FVector2D *) &boneTo)) {
draw->AddLine(boneFrom, boneTo,
PlayerBoxClrCf, 1.0f);
}
}
lastBone = currentBone;
}
}
}
if (Config.ESPMenu.Name || Config.ESPMenu.Distance || Config.ESPMenu.TeamID) {
DrawBoxEnemy(draw, ImVec2(headPosSC.x - healthLength, headPosSC.y - 28), ImVec2(headPosSC.x + healthLength, headPosSC.y - 28), 22, IM_COL32(0, 0, 0, 255));
}
/* if (Config.Ipad) {
Tools::WriteAddr((void *) (g_UE4 + 0x3EF90E4), (void *) "\x00\x00\x8C\x43", 4);
}*/
if (Config.ESPMenu.Name) {
std::string s;
int NameColor;
float a = 5;
if (Player->bIsAI) {
NameColor = IM_COL32(0, 255, 0, 255);
s += "[BOT] ";
s += Player->PlayerName.ToString();
} else {
NameColor = IM_COL32(255, 255, 100, 255);
s += "[";
s += std::to_string((int) Player->TeamID);
s += "] ";
s += Player->PlayerName.ToString();
}
draw->AddText(nullptr, 15.f, ImVec2(headPosSC.x - healthLength + a, headPosSC.y - 35.0f), NameColor, s.c_str());
}
if (Config.ESPMenu.Health) {
int CurHP = (int) std::max(0, std::min((int) Player->Health, (int) Player->HealthMax));
int MaxHP = (int) Player->HealthMax;
long curHP_Color = IM_COL32(std::min(((510 * (MaxHP - CurHP)) / MaxHP), 255),std::min((510 * CurHP) / MaxHP, 255), 0, 255);
if (Player->Health == 0.0f && !Player->bDead) {
curHP_Color = IM_COL32(255, 0, 0, 255);
CurHP = Player->NearDeathBreath;
if (Player->NearDeatchComponent) {
MaxHP = Player->NearDeatchComponent->BreathMax;
}
}
ImVec2 vEndFilled = ImVec2(headPosSC.x - healthLength + (2 * healthLength) * CurHP / 100, headPosSC.y - 15);
DrawBoxEnemy(draw, ImVec2(headPosSC.x - healthLength, headPosSC.y - 15), vEndFilled, 4, curHP_Color);
draw->AddRect(ImVec2(headPosSC.x - healthLength, headPosSC.y - 18), ImVec2(headPosSC.x + healthLength, headPosSC.y - 12), IM_COL32(0, 0, 0, 255));
}
if (Config.ESPMenu.AutoFire) {
if (!localController->LineOfSightTo(Actor, {0, 0, 0}, true)) {
g_LocalController->bIsPressingFireBtn = false;
}else{
g_LocalController->bIsPressingFireBtn = true;
}
}
if (Config.ESPMenu.Distance) {
std::string s;
s += std::to_string((int) Distance);
s += "M";
float a = 30;
if (Distance >= 100)
{
a = 35;
}
draw->AddText(nullptr, 16.f, ImVec2(headPosSC.x + healthLength - a, headPosSC.y - 35.0f), IM_COL32(255, 255, 255, 255), s.c_str());
}
}
}
}
}
}
g_LocalController = localController;
g_LocalPlayer = localPlayer;
if (totalEnemies > 0 || totalBots > 0) {
std::string s;
if (totalEnemies > 0) {
s = "Enem";
if (totalEnemies > 1)
s += "ies";
else s += "y";
s += " Around: ";
s += std::to_string(totalEnemies);
if (totalBots > 0)
s += " | ";
}
if (totalBots) {
s += "Bot";
if (totalBots > 1)
s += "s";
s += " Around: ";
s += std::to_string(totalBots);
}
auto textSize = ImGui::CalcTextSize2(s.c_str(), 0, s.size());
draw->AddText(NULL, ((float) density / 16.5f), {((float) glWidth / 2) - (textSize.x / 2), 70}, IM_COL32(255,255,0, 255), s.c_str());
}
if (Config.BulletTracking.Cross) {
if (EAim::Croshhair) {
draw->AddCircle(ImVec2(screenWidth / 3.0f, screenHeight / 3.0f), Config.BulletTracking.Cross*0.5f, ToColor(Config.ColorsESP.Fov), 100, 0.0f);
}
}
}
}
fps.update();
}
std::string getClipboardText() {
if (!g_App)
return "";
auto activity = g_App->activity;
if (!activity)
return "";
auto vm = activity->vm;
if (!vm)
return "";
auto object = activity->clazz;
if (!object)
return "";
std::string result;
JNIEnv *env;
vm->AttachCurrentThread(&env, 0);
{
auto ContextClass = env->FindClass("android/content/Context");
auto getSystemServiceMethod = env->GetMethodID(ContextClass, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
auto str = env->NewStringUTF("clipboard");
auto clipboardManager = env->CallObjectMethod(object, getSystemServiceMethod, str);
env->DeleteLocalRef(str);
auto ClipboardManagerClass = env->FindClass("android/content/ClipboardManager");
auto getText = env->GetMethodID(ClipboardManagerClass, "getText", "()Ljava/lang/CharSequence;");
auto CharSequenceClass = env->FindClass("java/lang/CharSequence");
auto toStringMethod = env->GetMethodID(CharSequenceClass, "toString", "()Ljava/lang/String;");
auto text = env->CallObjectMethod(clipboardManager, getText);
if (text) {
str = (jstring) env->CallObjectMethod(text, toStringMethod);
result = env->GetStringUTFChars(str, 0);
env->DeleteLocalRef(str);
env->DeleteLocalRef(text);
}
env->DeleteLocalRef(CharSequenceClass);
env->DeleteLocalRef(ClipboardManagerClass);
env->DeleteLocalRef(clipboardManager);
env->DeleteLocalRef(ContextClass);
}
vm->DetachCurrentThread();
return result;
}
const char *GetAndroidID(JNIEnv *env, jobject context) {
jclass contextClass = env->FindClass(/*android/content/Context*/ StrEnc("`L+&0^[S+-:J^$,r9q92(as", "\x01\x22\x4F\x54\x5F\x37\x3F\x7C\x48\x42\x54\x3E\x3B\x4A\x58\x5D\x7A\x1E\x57\x46\x4D\x19\x07", 23).c_str());
jmethodID getContentResolverMethod = env->GetMethodID(contextClass, /*getContentResolver*/ StrEnc("E8X\\7r7ys_Q%JS+L+~", "\x22\x5D\x2C\x1F\x58\x1C\x43\x1C\x1D\x2B\x03\x40\x39\x3C\x47\x3A\x4E\x0C", 18).c_str(), /*()Landroid/content/ContentResolver;*/ StrEnc("8^QKmj< }5D:9q7f.BXkef]A*GYLNg}B!/L", "\x10\x77\x1D\x2A\x03\x0E\x4E\x4F\x14\x51\x6B\x59\x56\x1F\x43\x03\x40\x36\x77\x28\x0A\x08\x29\x24\x44\x33\x0B\x29\x3D\x08\x11\x34\x44\x5D\x77", 35).c_str());
jclass settingSecureClass = env->FindClass(/*android/provider/Settings$Secure*/ StrEnc("T1yw^BCF^af&dB_@Raf}\\FS,zT~L(3Z\"", "\x35\x5F\x1D\x05\x31\x2B\x27\x69\x2E\x13\x09\x50\x0D\x26\x3A\x32\x7D\x32\x03\x09\x28\x2F\x3D\x4B\x09\x70\x2D\x29\x4B\x46\x28\x47", 32).c_str());
jmethodID getStringMethod = env->GetStaticMethodID(settingSecureClass, /*getString*/ StrEnc("e<F*J5c0Y", "\x02\x59\x32\x79\x3E\x47\x0A\x5E\x3E", 9).c_str(), /*(Landroid/content/ContentResolver;Ljava/lang/String;)Ljava/lang/String;*/ StrEnc("$6*%R*!XO\"m18o,0S!*`uI$IW)l_/_knSdlRiO1T`2sH|Ouy__^}%Y)JsQ:-\"(2_^-$i{?H", "\x0C\x7A\x4B\x4B\x36\x58\x4E\x31\x2B\x0D\x0E\x5E\x56\x1B\x49\x5E\x27\x0E\x69\x0F\x1B\x3D\x41\x27\x23\x7B\x09\x2C\x40\x33\x1D\x0B\x21\x5F\x20\x38\x08\x39\x50\x7B\x0C\x53\x1D\x2F\x53\x1C\x01\x0B\x36\x31\x39\x46\x0C\x15\x43\x2B\x05\x30\x15\x41\x43\x46\x55\x70\x0D\x59\x56\x00\x15\x58\x73", 71).c_str());
auto obj = env->CallObjectMethod(context, getContentResolverMethod);
auto str = (jstring) env->CallStaticObjectMethod(settingSecureClass, getStringMethod, obj, env->NewStringUTF(/*android_id*/ StrEnc("ujHO)8OfOE", "\x14\x04\x2C\x3D\x46\x51\x2B\x39\x26\x21", 10).c_str()));
return env->GetStringUTFChars(str, 0);
}
const char *GetDeviceModel(JNIEnv *env) {
jclass buildClass = env->FindClass(/*android/os/Build*/ StrEnc("m5I{GKGWBP-VOxkA", "\x0C\x5B\x2D\x09\x28\x22\x23\x78\x2D\x23\x02\x14\x3A\x11\x07\x25", 16).c_str());
jfieldID modelId = env->GetStaticFieldID(buildClass, /*MODEL*/ StrEnc("|}[q:", "\x31\x32\x1F\x34\x76", 5).c_str(), /*Ljava/lang/String;*/ StrEnc(".D:C:ETZ1O-Ib&^h.Y", "\x62\x2E\x5B\x35\x5B\x6A\x38\x3B\x5F\x28\x02\x1A\x16\x54\x37\x06\x49\x62", 18).c_str());
auto str = (jstring) env->GetStaticObjectField(buildClass, modelId);
return env->GetStringUTFChars(str, 0);
}
const char *GetDeviceBrand(JNIEnv *env) {
jclass buildClass = env->FindClass(/*android/os/Build*/ StrEnc("0iW=2^>0zTRB!B90", "\x51\x07\x33\x4F\x5D\x37\x5A\x1F\x15\x27\x7D\x00\x54\x2B\x55\x54", 16).c_str());
jfieldID modelId = env->GetStaticFieldID(buildClass, /*BRAND*/ StrEnc("@{[FP", "\x02\x29\x1A\x08\x14", 5).c_str(), /*Ljava/lang/String;*/ StrEnc(".D:C:ETZ1O-Ib&^h.Y", "\x62\x2E\x5B\x35\x5B\x6A\x38\x3B\x5F\x28\x02\x1A\x16\x54\x37\x06\x49\x62", 18).c_str());
auto str = (jstring) env->GetStaticObjectField(buildClass, modelId);
return env->GetStringUTFChars(str, 0);
}
const char *GetPackageName(JNIEnv *env, jobject context) {
jclass contextClass = env->FindClass(/*android/content/Context*/ StrEnc("`L+&0^[S+-:J^$,r9q92(as", "\x01\x22\x4F\x54\x5F\x37\x3F\x7C\x48\x42\x54\x3E\x3B\x4A\x58\x5D\x7A\x1E\x57\x46\x4D\x19\x07", 23).c_str());
jmethodID getPackageNameId = env->GetMethodID(contextClass, /*getPackageName*/ StrEnc("YN4DaP)!{wRGN}", "\x3E\x2B\x40\x14\x00\x33\x42\x40\x1C\x12\x1C\x26\x23\x18", 14).c_str(), /*()Ljava/lang/String;*/ StrEnc("VnpibEspM(b]<s#[9cQD", "\x7E\x47\x3C\x03\x03\x33\x12\x5F\x21\x49\x0C\x3A\x13\x20\x57\x29\x50\x0D\x36\x7F", 20).c_str());
auto str = (jstring) env->CallObjectMethod(context, getPackageNameId);
return env->GetStringUTFChars(str, 0);
}
const char *GetDeviceUniqueIdentifier(JNIEnv *env, const char *uuid) {
jclass uuidClass = env->FindClass(/*java/util/UUID*/ StrEnc("B/TxJ=3BZ_]SFx", "\x28\x4E\x22\x19\x65\x48\x47\x2B\x36\x70\x08\x06\x0F\x3C", 14).c_str());
auto len = strlen(uuid);
jbyteArray myJByteArray = env->NewByteArray(len);
env->SetByteArrayRegion(myJByteArray, 0, len, (jbyte *) uuid);
jmethodID nameUUIDFromBytesMethod = env->GetStaticMethodID(uuidClass, /*nameUUIDFromBytes*/ StrEnc("P6LV|'0#A+zQmoat,", "\x3E\x57\x21\x33\x29\x72\x79\x67\x07\x59\x15\x3C\x2F\x16\x15\x11\x5F", 17).c_str(), /*([B)Ljava/util/UUID;*/ StrEnc("sW[\"Q[W3,[email protected]) xB", "\x5B\x0C\x19\x0B\x1D\x31\x36\x45\x4D\x18\x35\x3C\x47\x1A\x7B\x65\x7C\x69\x3C\x79", 20).c_str());
jmethodID toStringMethod = env->GetMethodID(uuidClass, /*toString*/ StrEnc("2~5292eW", "\x46\x11\x66\x46\x4B\x5B\x0B\x30", 8).c_str(), /*()Ljava/lang/String;*/ StrEnc("P$BMc' #j?<:myTh_*h0", "\x78\x0D\x0E\x27\x02\x51\x41\x0C\x06\x5E\x52\x5D\x42\x2A\x20\x1A\x36\x44\x0F\x0B", 20).c_str());
auto obj = env->CallStaticObjectMethod(uuidClass, nameUUIDFromBytesMethod, myJByteArray);
auto str = (jstring) env->CallObjectMethod(obj, toStringMethod);
return env->GetStringUTFChars(str, 0);
}
struct MemoryStruct {
char *memory;
size_t size;
};
static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
size_t realsize = size * nmemb;
struct MemoryStruct *mem = (struct MemoryStruct *) userp;
mem->memory = (char *) realloc(mem->memory, mem->size + realsize + 1);
if (mem->memory == NULL) {
return 0;
}
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
return realsize;
}
//=========================MAIN LOGIN =================//
std::string Login(const char *user_key) {
if (!g_App)
return "Internal Error";
auto activity = g_App->activity;
if (!activity)
return "Internal Error";
auto vm = activity->vm;
if (!vm)
return "Internal Error";
auto object = activity->clazz;
if (!object)
return "Internal Error";
JNIEnv *env;
vm->AttachCurrentThread(&env, 0);
std::string hwid = user_key;
hwid += GetAndroidID(env, object);
hwid += GetDeviceModel(env);
hwid += GetDeviceBrand(env);
std::string UUID = GetDeviceUniqueIdentifier(env, hwid.c_str());
vm->DetachCurrentThread();
std::string errMsg;
struct MemoryStruct chunk{};
chunk.memory = (char *) malloc(1);
chunk.size = 0;
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if (curl) {
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, /*POST*/ StrEnc(",IL=", "\x7C\x06\x1F\x69", 4).c_str());
//std::string sRedLink = "YOUR PANNEL LINK MUST HAVE CONNECT PHP AS I HAVE OTHERWISE NO KEY TIME STATUS AND SLOT";
std::string sDoLink = "h";
std::string sJoLink = "t";
std::string sXoLink = "t";
std::string sKoLink = "p";
std::string sEoLink = "s";
std::string sCoLink = ":";
std::string sMao = "/";
std::string sMao2 = "/";
std::string sMao3 = "d";
std::string sMZCV = "c";
std::string sWsl = "x";
std::string sBsl = "t";
std::string sPsl = "e";
std::string sMsl = "a";
std::string sOsl = "m";
std::string sZsl = "x";
std::string sCsl = ".";
std::string sIsl = "x";
std::string sMomy = "y";
std::string sIbbvccl = "z";
std::string sIccll = "/";
std::string sIsswkl = "p";
std::string sIwkwkl = "u";
std::string sIccvsl = "b";
std::string sIssaqsl = "l";
std::string sIsmmbbcl = "i";
std::string sIjdcnsl = "c";
std::string sIscnal = "/";
std::string sIbbbavasl = "c";
std::string sIbbbav = "o";
std::string sIbbbavsl = "n";
std::string sIbbbvasl = "n";
std::string sIbavasl = "e";
std::string sIbbavasl = "c";
std::string sbbavasl = "t";
// std::string sbavas5 = "t";
std::string sRedLink = sDoLink+sJoLink+sXoLink+sKoLink+sEoLink+sCoLink+sMao+sMao2+sMao3+sMZCV+sWsl+sBsl+sPsl+sMsl+sOsl+sZsl+sCsl+sIsl+sMomy+sIbbvccl+sIccll+sIsswkl+sIwkwkl+sIccvsl+sIssaqsl+sIsmmbbcl+sIjdcnsl+sIscnal+sIbbbavasl+sIbbbav+sIbbbavsl+sIbbbvasl+sIbavasl+sIbbavasl+sbbavasl; //sbavas5
curl_easy_setopt(curl, CURLOPT_URL, sRedLink.c_str());
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, /*https*/ StrEnc("!mLBO", "\x49\x19\x38\x32\x3C", 5).c_str());
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, /*Content-Type: application/x-www-form-urlencoded*/ StrEnc("@;Ls\\(KP4Qrop`b#d3094/r1cf<c<=H)AiiBG6i|Ta66s2[", "\x03\x54\x22\x07\x39\x46\x3F\x7D\x60\x28\x02\x0A\x4A\x40\x03\x53\x14\x5F\x59\x5A\x55\x5B\x1B\x5E\x0D\x49\x44\x4E\x4B\x4A\x3F\x04\x27\x06\x1B\x2F\x6A\x43\x1B\x10\x31\x0F\x55\x59\x17\x57\x3F", 47).c_str());
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
char data[4096];
sprintf(data, /*game=PUBG&user_key=%s&serial=%s*/ StrEnc("qu2yXK,[email protected]~Nb'5(:.:chK", "\x16\x14\x5F\x1C\x65\x1B\x79\x1B\x2C\x6C\x0C\x34\x21\x32\x2A\x1F\x55\x57\x48\x5B\x3D\x44\x54\x50\x5A\x53\x4F\x56\x5E\x4D\x38", 31).c_str(), user_key, UUID.c_str());
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) &chunk);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
res = curl_easy_perform(curl);
if (res == CURLE_OK) {
try {
json result = json::parse(chunk.memory);
if (result[/*status*/ StrEnc("(>_LBm", "\x5B\x4A\x3E\x38\x37\x1E", 6).c_str()] == true) {
std::string token = result[/*data*/ StrEnc("fAVA", "\x02\x20\x22\x20", 4).c_str()][/*token*/ StrEnc("{>3Lr", "\x0F\x51\x58\x29\x1C", 5).c_str()].get<std::string>();
time_t rng = result[/*data*/ StrEnc("fAVA", "\x02\x20\x22\x20", 4).c_str()][/*rng*/ StrEnc("+n,", "\x59\x00\x4B", 3).c_str()].get<time_t>();
if (rng + 30 > time(0)) {
std::string auth = /*PUBG*/ StrEnc("Q*) ", "\x01\x7F\x6B\x67", 4).c_str();;
auth += "-";
auth += user_key;
auth += "-";
auth += UUID;
auth += "-";
auth += /*Vm8Lk7Uj2JmsjCPVPVjrLa7zgfx3uz9E*/ StrEnc("-2:uwZdV^%]?{{wHs2V,+(^NJU;kC*_{", "\x7B\x5F\x02\x39\x1C\x6D\x31\x3C\x6C\x6F\x30\x4C\x11\x38\x27\x1E\x23\x64\x3C\x5E\x67\x49\x69\x34\x2D\x33\x43\x58\x36\x50\x66\x3E", 32).c_str();
std::string outputAuth = Tools::CalcMD5(auth);
g_Token = token;
g_Auth = outputAuth;
bValid = g_Token == g_Auth;
}
} else {
errMsg = result[/*reason*/ StrEnc("LW(3(c", "\x3E\x32\x49\x40\x47\x0D", 6).c_str()].get<std::string>();
}
} catch (json::exception &e) {
errMsg = "{";
errMsg += e.what();
errMsg += "}\n{";
errMsg += chunk.memory;
errMsg += "}";
}
} else {
errMsg = curl_easy_strerror(res);
}
}
curl_easy_cleanup(curl);
return bValid ? "OK" : errMsg;
}
// ======================================================================== //
// ======================================================================== //
#define IM_CLAMP(V, MN, MX) ((V) < (MN) ? (MN) : (V) > (MX) ? (MX) : (V))
namespace Settings
{
static int Tab = 1;
}
EGLBoolean (*orig_eglSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
EGLBoolean _eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
eglQuerySurface(dpy, surface, EGL_WIDTH, &glWidth);
eglQuerySurface(dpy, surface, EGL_HEIGHT, &glHeight);
if (glWidth <= 0 || glHeight <= 0)
return eglSwapBuffers(dpy, surface);
if (!g_App)
return eglSwapBuffers(dpy, surface);
screenWidth = ANativeWindow_getWidth(g_App->window);
screenHeight = ANativeWindow_getHeight(g_App->window);
density = AConfiguration_getDensity(g_App->config);
//>==========𝔻𝕖𝕤𝕚𝕘𝕟 𝕊ℝℂ 𝔹𝕪 @𝕩𝕩_𝕚𝕞𝕥𝕖𝕕𝕕𝕪==========<//
//
if (!initImGui) {
ImGui::CreateContext();
ImGuiStyle* Style = &ImGui::GetStyle();
Style->WindowBorderSize = 4;
Style->FrameBorderSize = 4.0f;
Style->WindowBorderSize = 3.0f;
Style->WindowRounding = 10;
Style->TabBorderSize = 4.0f;
Style->ChildRounding = 15;
Style->FrameRounding = 10;
Style->ScrollbarSize = 4;
Style->ScrollbarRounding = 10;
Style->PopupRounding = 10;
Style->GrabRounding = 10;
Style->Colors[ImGuiCol_Text] = ImColor(0, 0, 0, 255);
Style->Colors[ImGuiCol_TextDisabled] = ImColor(0, 0, 0, 255);
Style->Colors[ImGuiCol_WindowBg] = ImColor(230, 199, 188, 150);
Style->Colors[ImGuiCol_ChildBg] = ImVec4(0.15f, 0.18f, 0.22f, 1.00f);
Style->Colors[ImGuiCol_PopupBg] = ImVec4(0.07f, 0.07f, 0.09f, 1.00f);
Style->Colors[ImGuiCol_Border] = ImColor(255, 255, 255, 255);
Style->Colors[ImGuiCol_BorderShadow] = ImColor(0, 0, 0, 255);
Style->Colors[ImGuiCol_FrameBg] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_FrameBgHovered] = ImColor(0, 255, 255, 220);
Style->Colors[ImGuiCol_FrameBgActive] = ImColor(0, 255, 255, 220);
Style->Colors[ImGuiCol_TitleBg] = ImVec4(0.10f, 0.09f, 0.12f, 1.00f);
Style->Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.08f, 0.10f, 0.12f, 1.00f);
Style->Colors[ImGuiCol_TitleBgActive] = ImVec4(0.07f, 0.07f, 0.09f, 1.00f);
Style->Colors[ImGuiCol_MenuBarBg] = ImVec4(0.10f, 0.09f, 0.12f, 1.00f);
Style->Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.10f, 0.09f, 0.12f, 1.00f);
Style->Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.31f, 0.31f, 1.00f, 1.00f);
Style->Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.56f, 0.56f, 0.58f, 1.00f);
Style->Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.06f, 0.05f, 0.07f, 1.00f);
Style->Colors[ImGuiCol_CheckMark] = ImVec4(0.31f, 0.31f, 1.00f, 1.00f);
Style->Colors[ImGuiCol_SliderGrab] = ImVec4(0.31f, 0.31f, 1.00f, 1.00f);
Style->Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.06f, 0.05f, 0.07f, 1.00f);
Style->Colors[ImGuiCol_Button] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_ButtonHovered] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_ButtonActive] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_Header] = ImVec4(0.10f, 0.09f, 0.12f, 1.00f);
Style->Colors[ImGuiCol_HeaderHovered] = ImVec4(0.56f, 0.56f, 0.58f, 1.00f);
Style->Colors[ImGuiCol_HeaderActive] = ImVec4(0.06f, 0.05f, 0.07f, 1.00f);
Style->Colors[ImGuiCol_Separator] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f);
Style->Colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);
Style->Colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);
Style->Colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.56f, 0.56f, 0.58f, 1.00f);
Style->Colors[ImGuiCol_ResizeGripActive] = ImVec4(0.06f, 0.05f, 0.07f, 1.00f);
Style->Colors[ImGuiCol_Tab] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_TabUnfocused] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_TabUnfocusedActive] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
Style->Colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.25f, 1.00f, 0.00f, 1.00f);
Style->Colors[ImGuiCol_PlotHistogram] = ImVec4(0.40f, 0.39f, 0.38f, 0.63f);
Style->Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(0.25f, 1.00f, 0.00f, 1.00f);
Style->Colors[ImGuiCol_TextSelectedBg] = ImColor(0, 0, 0, 255);
Style->Colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
Style->Colors[ImGuiCol_Separator] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f);
Style->Colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);
Style->Colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);
Style->Colors[ImGuiCol_ResizeGrip] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
Style->Colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.56f, 0.56f, 0.58f, 1.00f);
Style->Colors[ImGuiCol_ResizeGripActive] = ImVec4(0.06f, 0.05f, 0.07f, 1.00f);
Style->Colors[ImGuiCol_Tab] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_TabUnfocused] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_TabUnfocusedActive] = ImColor(255, 255, 255, 220);
Style->Colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
Style->Colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.25f, 1.00f, 0.00f, 1.00f);
Style->Colors[ImGuiCol_PlotHistogram] = ImVec4(0.40f, 0.39f, 0.38f, 0.63f);
Style->Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(0.25f, 1.00f, 0.00f, 1.00f);
Style->Colors[ImGuiCol_TextSelectedBg] = ImColor(0, 0, 0, 255);
Style->Colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
Style->ScaleAllSizes(std::max(1.0f, density / 150.0f));
Style->ScrollbarSize *= 2.0f;
Style->Colors[ImGuiCol_ChildBg] = ImColor(29, 34, 38);
ImGui_ImplAndroid_Init();
ImGui_ImplOpenGL3_Init("#version 300 es");
ImGuiIO &io = ImGui::GetIO();
io.ConfigWindowsMoveFromTitleBarOnly = true;
io.IniFilename = NULL;
static const ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 };
ImFontConfig icons_config;
ImFontConfig CustomFont;
CustomFont.FontDataOwnedByAtlas = false;
icons_config.MergeMode = true;
icons_config.PixelSnapH = true;
icons_config.OversampleH = 2.5;
icons_config.OversampleV = 2.5;
io.Fonts->AddFontFromMemoryTTF(const_cast<std::uint8_t*>(Custom), sizeof(Custom), 21.f, &CustomFont);
io.Fonts->AddFontFromMemoryCompressedTTF(font_awesome_data, font_awesome_size, 19.0f, &icons_config, icons_ranges);
ImFontConfig cfg;
cfg.SizePixels = ((float) density / 20.0f);
memset(&Config, 0, sizeof(sConfig));
Config.ColorsESP.Text = CREATE_COLOR(0, 0, 0, 255);
Config.ColorsESP.Menucolour = CREATE_COLOR(255, 255, 255, 255);
Config.ColorsESP.Line = CREATE_COLOR(255, 0, 0, 255);
Config.ColorsESP.Linebot = CREATE_COLOR(255,255,255, 250);
Config.ColorsESP.Skeletonbot = CREATE_COLOR(255, 255, 255, 255);
Config.ColorsESP.Boxbot = CREATE_COLOR(255, 255, 255, 255);
Config.ColorsESP.Box = CREATE_COLOR(255, 0, 255, 255);
Config.ColorsESP.Name = CREATE_COLOR(255, 0, 0, 255);
Config.ColorsESP.Distance = CREATE_COLOR(255, 0, 255, 255);
Config.ColorsESP.Skeleton = CREATE_COLOR(255, 0, 0, 255);
Config.ColorsESP.Vehicle = CREATE_COLOR(255, 0, 0, 255);
Config.ColorsESP.Count = CREATE_COLOR(255, 0, 0, 255);
Config.ColorsESP.Fov = CREATE_COLOR(255,255,255, 250);
Config.BulletTracking.Cross = 00.0f;
initImGui = true;
for (auto &i : items_data) {
for (auto &item : i["Items"]) {
int r, g, b;
sscanf(item["itemTextColor"].get<std::string>().c_str(), "#%02X%02X%02X", &r, &g, &b);
ItemColors[item["itemId"].get<int>()] = CREATE_COLOR(r, g, b, 255);
}
}
initImGui = true;
}
ImGuiIO &io = ImGui::GetIO();
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplAndroid_NewFrame(glWidth, glHeight);
ImGui::NewFrame();
DrawESP(ImGui::GetBackgroundDrawList());
ImGui::SetNextWindowSize(ImVec2((float) glWidth * 0.53f, (float) glHeight * 0.67f),ImGuiCond_Once); // 45% width 70% height
if (ImGui::Begin(OBFUSCATE("DCX CHEATS 2.1 | BY [D C x O W N E R]" ), 0,ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings)) {
static bool isLogin = false, logginIn = false;
static std::string err;
if (!isLogin) {
int pushedColors = 0;
ImGui::Text("DCX CHEATS 2.1 | BY [D C x O W N E R]");
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(ImColor(0,150,255, 255)));
ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(ImColor(39, 172, 57, 255)));
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(ImColor(39, 172, 57, 255)));
pushedColors += 3;
ImGui::PushItemWidth(-1);
static char s[64];
ImGui::InputText("##key", s, sizeof s);
ImGui::PopItemWidth();
if (ImGui::Button(" P A S T E ", ImVec2(ImGui::GetContentRegionAvailWidth(), 0))) {
auto key = getClipboardText();
strncpy(s, key.c_str(), sizeof s);
}
static std::string err;
if (ImGui::Button(" L O G I N ", ImVec2(ImGui::GetContentRegionAvailWidth(), 0))) {
err = Login(s);
if (err == "OK") {
isLogin = bValid && g_Auth == g_Token;
}
}
if (!err.empty() && err != "OK") {
ImGui::Text("STATUS : %s", err.c_str());
}
ImGui::PopStyleColor(pushedColors);
} else {
Config.Bypass = true;
Config.OTHER.FPS = true;
static bool ic;
static bool show;
if (ImGui::Button(("D"),ImVec2(50,50)))
{
show = true;
}
ImGui::SetNextWindowSize(ImVec2(800,650));
if(show){
ImGui::Begin("Hacks",&show,ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize );
{
ImGui::Columns(2);
ImGui::SetColumnOffset(1, 245);
{
ImVec2 pos;
ImDrawList* draw;
pos = ImGui::GetWindowPos();
draw = ImGui::GetWindowDrawList();
draw->AddText(NULL,150.f, ImVec2(pos.x + 50, pos.y + 26), ImColor(255, 255, 255, 255),"DC");
draw->AddText(NULL,35.f, ImVec2(pos.x + 17, pos.y + 180), ImColor(43,43,0, 255), " DCX CHEATS ");
int pushedColors = 0;
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
if (ImGui::Button(ICON_FA_USER_CIRCLE " PLAYER", ImVec2(25 * 8 , 35)))
{
Settings::Tab = 1;
}
/* if (ImGui::Button(ICON_FA_DROPBOX " ITEMS", ImVec2(25 * 8 , 35)))
{
Settings::Tab = 2;
}*/
if (ImGui::Button(ICON_FA_CROSSHAIRS " BULLET", ImVec2(25 * 8 , 35)))
{
Settings::Tab = 2;
}
if (ImGui::Button(ICON_FA_STAR " RISK MENU", ImVec2(25 * 8 , 40)))
{
Settings::Tab = 3;
}
if (ImGui::Button(ICON_FA_KEY " KEY INFO", ImVec2(25 * 8 , 40)))
{
Settings::Tab = 4;
}
/* if (ImGui::Button(ICON_FA_KEY " RISK MENU", ImVec2(25 * 8 , 40)))
{
Settings::Tab = 5;
} */
if (ImGui::Button(ICON_FA_RAINBOW " OTHER INFO", ImVec2(25 * 8 , 40)))
{
Settings::Tab = 5;
}
if(ImGui::Button(ICON_FA_BOMB " HIDE",ImVec2(25 * 8 ,35)))
{
show = false;
}
}
ImGui::NextColumn();
{
if (Settings::Tab == 1) {
ImGui::Spacing();
if (ImGui::BeginTable("split", 2));
{
if (ImGui::BeginTable("split", 2));
{
ImGui::TableNextColumn();
ImGui::TextColored(ImVec4(2.55f, 0.69f, 0.00f, 1.00f), "RADAR PLAYER ");
ImGui::Text("BYPASS ONLINE %c", "|/-\\"[(int)(ImGui::GetTime() / 0.05f) & 3]);
static float values[90] = {};
static int values_offset = 0;
static double refresh_time = 0.0;
while( refresh_time < ImGui::GetTime() ) // Create data at fixed 60 Hz rate for the demo
{
static float phase = 0.0f;
values[values_offset] = cosf( phase );
values_offset = ( values_offset + 1 ) % IM_ARRAYSIZE( values );
phase += 0.10f * values_offset;
refresh_time += 1.0f / 60.0f;
}
char overlay[32] = "";
ImGui::PlotLines("", values, IM_ARRAYSIZE( values ), values_offset, overlay, -1.0f, 1.0f, ImVec2( 0,20.0f ) );
ImGui::SameLine();
ImGuiIO io = ImGui::GetIO();
ImGui::Text( "%.2f ms", 1000 / io.Framerate );
ImGui::RadioButton("Server Connected...", &Config.Bypass);
ImGui::Checkbox("Line ", &Config.ESPMenu.Line);
ImGui::Checkbox("Health", &Config.ESPMenu.Health);
ImGui::Checkbox("Box", &Config.ESPMenu.Box);
ImGui::Checkbox("Name", &Config.ESPMenu.Name);
ImGui::Checkbox("Skeleton", &Config.ESPMenu.Skeleton);
ImGui::Checkbox("Distance", &Config.ESPMenu.Distance);
ImGui::Checkbox("Team-ID", &Config.ESPMenu.TeamID);
ImGui::Checkbox("Hide-Bot", &Config.ESPMenu.NoBot);
/* ImGui::Checkbox("GRENADE ALERT ", &Config.ESPMenu.Grenade);
ImGui::Checkbox("Vehicle ", &Config.ESPMenu.Vehicle);
ImGui::Checkbox("LOOT BOX ", &Config.ESPMenu.LootBox);
ImGui::Checkbox("Ipad View", &Config.Ipad);*/
}
ImGui::EndTable();
}
}
//RADAR ITEMS
/* if (Settings::Tab == 2) {
ImGui::Spacing();
ImGui::Text("ESP Loot Item");
ImGui::Spacing();
for (auto &i : items_data) {
if (ImGui::TreeNode(i["Category"].get<std::string>().c_str())) {
ImGui::Spacing();
for (auto &item : i["Items"]) {
ImGui::Checkbox(item["itemName"].get<std::string>().c_str(),
(bool *) &Items[item["itemId"].get<int>()]);
}
ImGui::TreePop();
}
}
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
}*/
}
}
if (Settings::Tab == 2) {
ImGui::Spacing();
ImGui::TextColored(ImVec4(2.55f, 0.69f, 0.00f, 1.00f), "BULLET TRACK ULTRA");
ImGui::Checkbox("Enable", &Config.BulletTracking.Enable);
ImGui::SliderFloat("", &Config.BulletTracking.Cross, 0.0f, 500.0f);
ImGui::SameLine();
ImGui::SetNextWindowSize(ImVec2((float) glWidth * 0.25f, (float) glHeight * 0.25f), ImGuiCond_Once);
ImGui::ColorEdit3("##FovCol", Config.ColorsESP.Fov, ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoInputs);
ImGui::SameLine();
ImGui::Text("size ") ;
static const char *targets[] = {"Heads", "Chest"};
ImGui::Combo("##Target", (int *) &Config.BulletTracking.Target, targets, 2, -1);
ImGui::Checkbox("Ignore Knocked", &Config.BulletTracking.IgnoreKnocked);
ImGui::Checkbox("Visibility Check", &Config.BulletTracking.VisCheck);
}
if (Settings::Tab == 3) {
ImGui::Spacing();
ImGui::TextColored(ImVec4(2.55f, 0.69f, 0.00f, 1.00f), "RISK MENU DON'T USE MAIN ID ");
ImGui::Checkbox("Flash SDK", &FlashSdk);
ImGui::Checkbox("Wide view", &WideView);
ImGui::Checkbox("No shake ", &Config.memory.Shake);
ImGui::Checkbox("X Hit effect",&Config.memory.HitEffect);
ImGui::Checkbox("Auto Fire ", &Config.ESPMenu.AutoFire);
ImGui::Checkbox("Instant hit ",&Config.memory.Instant);
}
if (Settings::Tab == 4) {
ImGui::Spacing();
ImGui::TextColored(ImVec4(2.55f, 0.69f, 0.00f, 1.00f), "Key info");
ImGui::Text("EXPIRY DATE :- ");
ImGui::SameLine();
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(235, 52, 225, 255));
ImGui::Text(EXP.c_str());
ImGui::PopStyleColor();
ImGui::Spacing();
ImGui::Text("MAX DEVICES :- ");
ImGui::SameLine();
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(52, 222, 235, 255));
ImGui::Text(device.c_str());
ImGui::PopStyleColor();
ImGui::Spacing();
ImGui::Text("CREDIT :- ");
ImGui::SameLine();
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(252, 69, 3, 255));
ImGui::Text(floating.c_str());
ImGui::PopStyleColor();
ImGui::Spacing();
ImGui::Text("CHEATS SAFTY :- ");
ImGui::SameLine();
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(0, 255, 0, 255));
ImGui::Text(status.c_str());
ImGui::PopStyleColor();
ImGui::Spacing();
}
if (Settings::Tab == 5) {
ImGui::Text( ICON_FA_BOMB " RULES TO PLAY SAFE AND CRASH ISSUES.\n\n 1. Take care of reports, they may give ban.\n\n 2. Don't kill more then 8 enimies.\n\n 3. Maintain your KD lower then 5.\n\n 4. Don't ho straight to the enemy in the esp menu, play like a normal player.\n\n 5. Play livik for more safe.\n\n 6. Clear cache and stop force every match.\n\n 7. Bullet Track enable only when necessary need bypass.\n\n 8. Don't use esp Health and esp Skeleton.\n\n 9. Don't use Memory Hacks banned.\n\n Note: If u not follow this Rules & Regulations you definitely Got Ban. ");
}
if (Settings::Tab == 7) {
ImGui::Spacing();
if (ImGui::BeginTable("split", 2));
{
if (ImGui::BeginTable("split", 2));
{
}
ImGui::EndTable();
}
}
}
}
}
ImGui::End();
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
return orig_eglSwapBuffers(dpy, surface);
}
int32_t (*orig_onInputEvent)(struct android_app *app, AInputEvent *inputEvent);
int32_t onInputEvent(struct android_app *app, AInputEvent *inputEvent) {
if (initImGui) {
ImGui_ImplAndroid_HandleInputEvent(inputEvent, {(float) screenWidth / (float) glWidth, (float) screenHeight / (float) glHeight});
}
return orig_onInputEvent(app, inputEvent);
}
[[noreturn]] void *Memory_thread(void *) {
while (true) {
auto t1 = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
if (Config.memory.Recoil || Config.memory.Shake || Config.memory.Instant) {
auto WeaponManagerComponent = g_LocalPlayer->WeaponManagerComponent;
if (WeaponManagerComponent) {
auto CurrentWeaponReplicated = (ASTExtraShootWeapon *) WeaponManagerComponent->CurrentWeaponReplicated;
if (CurrentWeaponReplicated) {
auto ShootWeaponEntityComp = CurrentWeaponReplicated->ShootWeaponEntityComp;
auto ShootWeaponEffectComp = CurrentWeaponReplicated->ShootWeaponEffectComp;
if (ShootWeaponEntityComp && ShootWeaponEffectComp) {
if (Config.memory.Recoil) {
memset(&ShootWeaponEntityComp->RecoilInfo, 0,
sizeof(FSRecoilInfo));
ShootWeaponEntityComp->AccessoriesVRecoilFactor = 0.0f;
ShootWeaponEntityComp->AccessoriesHRecoilFactor = 0.0f;
ShootWeaponEntityComp->AccessoriesRecoveryFactor = 0.0f;
memset(&ShootWeaponEntityComp->DeviationInfo, 0,
sizeof(FSDeviation));
ShootWeaponEntityComp->ShotGunCenterPerc = 0.0f;
ShootWeaponEntityComp->ShotGunVerticalSpread = 0.0f;
ShootWeaponEntityComp->ShotGunHorizontalSpread = 0.0f;
ShootWeaponEntityComp->GameDeviationFactor = 0.0f;
ShootWeaponEntityComp->GameDeviationAccuracy = 0.0f;
ShootWeaponEntityComp->CrossHairInitialSize = 0.0f;
ShootWeaponEntityComp->CrossHairBurstSpeed = 0.0f;
ShootWeaponEntityComp->CrossHairBurstIncreaseSpeed = 0.0f;
ShootWeaponEntityComp->VehicleWeaponDeviationAngle = 0.0f;
ShootWeaponEntityComp->RecoilKickADS = 0.0f;
}
if (Config.memory.Shake) {
ShootWeaponEffectComp->CameraShakeInnerRadius = 0.0f;
ShootWeaponEffectComp->CameraShakeOuterRadius = 0.0f;
ShootWeaponEffectComp->CameraShakFalloff = 0.0f;
}
if (Config.memory.HitEffect) {
ShootWeaponEntityComp->ExtraHitPerformScale = 50.0f;
}
if (Config.memory.Instant) {
ShootWeaponEntityComp->BulletFireSpeed = 100000.0f;
}
}
}
}
}
auto td = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - t1;
std::this_thread::sleep_for(std::chrono::milliseconds(std::max(std::min(0LL, SLEEP_TIME - td), SLEEP_TIME)));
}
return 0;
}
#define SLEEP_TIME 1000LL / 60LL
[[noreturn]] void *putri_thread(void *) {
while (true) {
auto t1 = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
auto objs = UObject::GetGlobalObjects();
for (int i = 0; i < objs.Num(); i++) {
auto Object = objs.GetByIndex(i);
if (isObjectInvalid(Object))
continue;
if (WideView) {
if (Object->IsA(ULocalPlayer::StaticClass())) {
auto playerChar = (ULocalPlayer *) Object;
playerChar->AspectRatioAxisConstraint = EAspectRatioAxisConstraint::AspectRatio_MaintainYFOV;
}}
if (FlashSdk) {
if (Object->IsA(ASTExtraBaseCharacter::StaticClass())) {
auto playerChar = (ASTExtraBaseCharacter *) Object;
playerChar->CharacterOverrideAttrs.GameModeOverride_SpeedScaleModifier = 10;
}}
}
auto td = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - t1;
std::this_thread::sleep_for(std::chrono::milliseconds(std::max(std::min(0LL, SLEEP_TIME - td),SLEEP_TIME)));
}
}
#define SLEEP_TIME 1000LL / 60LL
[[noreturn]] void *maps_thread(void *) {
while (true) {
auto t1 = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
std::vector<sRegion> tmp;
char line[512];
FILE *f = fopen("/proc/self/maps", "r");
if (f) {
while (fgets(line, sizeof line, f)) {
uintptr_t start, end;
char tmpProt[16];
if (sscanf(line, "%" PRIXPTR "-%" PRIXPTR " %16s %*s %*s %*s %*s", &start, &end, tmpProt) > 0) {
if (tmpProt[0] != 'r') {
tmp.push_back({start, end});
}
}
}
fclose(f);
}
auto td = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - t1;
std::this_thread::sleep_for(std::chrono::milliseconds(std::max(std::min(0LL, SLEEP_TIME - td), SLEEP_TIME)));
}
}
void *main_thread(void *) {
g_UE4 = Tools::GetBaseAddress("libUE4.so");
Anogs = Tools::GetBaseAddress("libanogs.so");
while (!Anogs) {
Anogs = Tools::GetBaseAddress("libanogs.so");
sleep(1);
}
while (!g_UE4) {
g_UE4 = Tools::GetBaseAddress("libUE4.so");
sleep(1);
}
while (!g_App) {
g_App = *(android_app **) (g_UE4 + GNativeAndroidApp_Offset);
sleep(1);
}
FName::GNames = GetGNames();
while (!FName::GNames) {
FName::GNames = GetGNames();
sleep(1);
}
UObject::GUObjectArray = (FUObjectArray *) (g_UE4 + GUObject_Offset);
orig_onInputEvent = decltype(orig_onInputEvent)(g_App->onInputEvent);
g_App->onInputEvent = onInputEvent;
plthook_t *plthook;
if (plthook_open(&plthook, "libUE4.so") == 0) {
plthook_replace(plthook, "eglSwapBuffers", (void *) _eglSwapBuffers, (void **) &orig_eglSwapBuffers);
plthook_close(plthook);
}
pthread_t t;
pthread_create(&t, 0, maps_thread, 0);
pthread_create(&t, 0, Memory_thread, 0);
pthread_create(&t, 0, putri_thread, 0);
items_data = json::parse(JSON_ITEMS);
return 0;
}
__attribute__((constructor)) void _init() {
pthread_t t;
pthread_create(&t, 0, main_thread, 0);
//pthread_create(&t, 0, bypassUE4_thread, 0);
}
Write, Run & Share C++ code online using OneCompiler's C++ online compiler for free. It's one of the robust, feature-rich online compilers for C++ language, running on the latest version 17. Getting started with the OneCompiler's C++ compiler is simple and pretty fast. The editor shows sample boilerplate code when you choose language as C++ and start coding!
OneCompiler's C++ online compiler supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample program which takes name as input and print your name with hello.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string name;
cout << "Enter name:";
getline (cin, name);
cout << "Hello " << name;
return 0;
}
C++ is a widely used middle-level programming language.
When ever you want to perform a set of operations based on a condition If-Else is used.
if(conditional-expression) {
//code
}
else {
//code
}
You can also use if-else for nested Ifs and If-Else-If ladder when multiple conditions are to be performed on a single variable.
Switch is an alternative to If-Else-If ladder.
switch(conditional-expression){
case value1:
// code
break; // optional
case value2:
// code
break; // optional
......
default:
code to be executed when all the above cases are not matched;
}
For loop is used to iterate a set of statements based on a condition.
for(Initialization; Condition; Increment/decrement){
//code
}
While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.
while (condition) {
// code
}
Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.
do {
// code
} while (condition);
Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity. Function gets run only when it is called.
return_type function_name(parameters);
function_name (parameters)
return_type function_name(parameters) {
// code
}