𝐁𝐌𝐂 𝐕𝐈𝐏 𝐒𝐑𝐂 𝐅𝐑𝐄𝐄

if (Cheat::Esp::NearbyAr) {
            static FVector2D closestItemPos;
            static float closestDistance = FLT_MAX;
            static bool isVisible = false;

            auto Actors = GetActors();
            for (auto Actor : Actors) {
                if (Actor->IsA(APickUpWrapperActor::StaticClass())) {

                    auto PickUp = (APickUpWrapperActor *)Actor;
                    if (Items[PickUp->DefineID.TypeSpecificID]) {
                        auto RootComponent = PickUp->RootComponent;
                        if (!RootComponent)
                            continue;

                        if (PickUp->bHidden)
                            continue;

                        float Distance = PickUp->GetDistanceTo(Cheat::localPlayer) / 100.f;

                        if (Distance > 100)
                            continue;

                        FVector2D itemPos;

                        if (WorldToScreenBone(PickUp->K2_GetActorLocation(), &itemPos)) {
                            std::string itemName;
                            uint32_t textColor = 0xFF000000;

                            for (const auto &category : items_data) {
                                for (const auto &item : category[("Items")]) {
                                    if (item[("itemId")] == PickUp->DefineID.TypeSpecificID) {
                                        itemName = item[("itemName")].get<std::string>();
                                        textColor = std::stoul(item[("itemTextColor")].get<std::string>(), nullptr, 16);
                                        break;
                                    }
                                }
                            }

                            std::string distanceText = (" - ") + std::to_string(static_cast<int>(Distance)) + ("M");
                            std::string displayText = itemName + distanceText;

                          
                            bool itemVisible = Cheat::localController->LineOfSightTo(PickUp, {0, 0, 0}, true);

                        
                            if (itemVisible && Distance < closestDistance) {
                                closestDistance = Distance;
                                closestItemPos = itemPos;
                                isVisible = true;
                            }
                        }
                    }
                }
            }

            if (isVisible) {
                draw->AddLine({(float)glWidth / 2, 716}, {closestItemPos.X - 2, closestItemPos.Y}, IM_COL32(255, 0, 0, 255), 2.2f);
            }

           
            closestDistance = FLT_MAX;
            isVisible = false;
        }

Join -> @BMC_VIP_SRC Join -> @BMC_VIP_SRC

auto PlayerState = Cheat::localPlayer->STExtraPlayerState;

if (!PlayerState)
{
    return;
}

int Kills = PlayerState->Kills;
if (Kills >= 10)
{
    static bool IsShowed = false;
    if (!IsShowed)
    {
        Cheat::localController->ClientDisplayNormalTips(std::wstring(L"Maintain Your Kill"));
        IsShowed = true;
    }
}

Join -> @BMC_VIP_SRC Join -> @BMC_VIP_SRC

void* Fuck2(void*)
{
    while (true)
    {
        if (localPlayer != 0)
        {
            auto& globalObjects = SDK::UArrayProperty::GetGlobalObjects();
            for (int i = 0; i < globalObjects.Num(); ++i)
            {
                auto object = globalObjects.GetByIndex(i);


                if (object == nullptr || !object->IsA(UBodySetup::StaticClass()))
                {
                    continue;
                }

                uintptr_t BodySetup = (uintptr_t)object;
                if (BodySetup == 0)
                {
                    continue;
                }

#if defined(__aarch64__)
                uintptr_t BoxElemsOffset = 0x38;
                uintptr_t OffsetX = 0x88;
                uintptr_t OffsetY = 0x8c;
                uintptr_t OffsetZ = 0x90;
#else
                uintptr_t BoxElemsOffset = 0x28;
                uintptr_t OffsetX = 0x78;
                uintptr_t OffsetY = 0x7c;
                uintptr_t OffsetZ = 0x80;
#endif


                uintptr_t BoxElems = *(uintptr_t *)(BodySetup + BoxElemsOffset);
                if (BoxElems == 0)
                {
                    continue;
                }


                float& X = *(float *)(BoxElems + OffsetX);
                float& Y = *(float *)(BoxElems + OffsetY);
                float& Z = *(float *)(BoxElems + OffsetZ);

                if (X != 23.0f || Y != 25.0f || Z != 30.5f)
                {
                    continue;
                }


                X = -350.0f;
                Y = 100.0f;
                Z = 99999.0f;
            }
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(300));
    }

    return nullptr;
}

Join -> @BMC_VIP_SRC Join -> @BMC_VIP_SRC

int EngineClose() {
    JavaVM* java_vm = g_App->activity->vm;
    JNIEnv* java_env = NULL;
    jint jni_return = java_vm->GetEnv((void**)&java_env, JNI_VERSION_1_6);
    if (jni_return == JNI_ERR)
        return -1;
    jni_return = java_vm->AttachCurrentThread(&java_env, NULL);
    if (jni_return != JNI_OK)
        return -2;
    jclass native_activity_clazz = java_env->GetObjectClass(g_App->activity->clazz);
    if (native_activity_clazz == NULL)
        return -3;
    jmethodID method_id = java_env->GetMethodID(native_activity_clazz, OBFUSCATE("AndroidThunkJava_RestartGame"),/*Engine New Restart*/OBFUSCATE("()V"));
    if (method_id == NULL)
        return -4;
    java_env->CallVoidMethod(g_App->activity->clazz, method_id);
    jni_return = java_vm->DetachCurrentThread();
    if (jni_return != JNI_OK)
        return -5;
    return 0;
}
bool isEngineFolderHere(const std::string& folderPath) {
    return (access(folderPath.c_str(), F_OK) == 0);
}

// Canary Locaiton
void EngineCrack1() {
std::string folderPath = OBFUSCATE("/storage/emulated/0/Android/data/com.guoshi.httpcanary");
if (isEngineFolderHere(folderPath)) {
    EngineClose(); } else {}
}
void EngineCrack2() {
std::string folderPath = OBFUSCATE("/storage/emulated/0/Android/data/com.guoshi.httpcanary.premium");
if (isEngineFolderHere(folderPath)) {
    EngineClose(); } else {}
}
void EngineCrack3() {
std::string folderPath = OBFUSCATE("/storage/emulated/0/Android/data/com.sniffer");
if (isEngineFolderHere(folderPath)) {
    EngineClose(); } else {}
}
void EngineCrack4() {
std::string folderPath = OBFUSCATE("/storage/emulated/0/Android/data/com.sant.canary");
if (isEngineFolderHere(folderPath)) {
    EngineClose(); } else {}
}

void EngineCrack7() {
std::string folderPath = OBFUSCATE("/storage/emulated/0/Android/data/com.sanmeet");
if (isEngineFolderHere(folderPath)) {
    EngineClose(); } else {}
}

Join -> @BMC_VIP_SRC Join -> @BMC_VIP_SRC

#include <curl/curl.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// Define the font progress callback function
void font_progress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) {
    // Update the progress bar or other UI elements here
    printf("Download progress: %f%%\n", (dlnow / dltotal) * 100);
}

// Define the download callback function
size_t download_callback(void *ptr, size_t size, size_t nmemb, void *data) {
    // Write the downloaded data to the file
    FILE *fp = (FILE *)data;
    size_t written = fwrite(ptr, size, nmemb, fp);
    return written;
}

// Define the getExternalFilesDir function
char *getExternalFilesDir() {
    // Get the external files directory from the Android SDK
    // This function is typically provided by the Android SDK
    // For this example, we will use a hardcoded path
    return "/sdcard/Android/data/com.example.app/files";
}

int download_file(const char *url, const char *path) {
    CURL *curl;
    CURLcode res = static_cast<CURLcode>(-1);
    FILE *fp;
    curl = curl_easy_init();
    if (curl) {
        fp = fopen(path, "wb");
        if (fp) {
            curl_easy_setopt(curl, CURLOPT_URL, url);
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
            curl_easy_setopt(curl, CURLOPT_NOPROGRESS, false);
            curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, font_progress);
            curl_easy_setopt(curl, CURLOPT_XFERINFODATA, NULL);
            res = curl_easy_perform(curl);
            fclose(fp);
        }
        curl_easy_cleanup(curl);
    }
    return res;
}

int main() {
    // Download the library file
    char *url = "https://website.com/libName.so";
    char *path = getExternalFilesDir();
    strcat(path, "/lib/libName.so");
    int res = download_file(url, path);
    if (res != CURLE_OK) {
        printf("Download failed: %s\n", curl_easy_strerror(res));
        return 1;
    }

    // Load the library
    void *handle = dlopen(path, RTLD_LAZY);
    if (!handle) {
        printf("Failed to load library: %s\n", dlerror());
        return 1;
    }

    // Use the library
    // ...

    // Clean up
    dlclose(handle);
    return 0;
}

Join -> @BMC_VIP_SRC Join -> @BMC_VIP_SRC

if (auto WeaponManagerComponent = Cheat::localPlayer->WeaponManagerComponent)
{

    if (auto CurrentWeaponReplicated = static_cast<ASTExtraShootWeapon *>(WeaponManagerComponent->CurrentWeaponReplicated))
    {
        auto WeaponSlot = CurrentWeaponReplicated->GetWeaponSlot();
        if (WeaponSlot == ESurviveWeaponPropSlot::SWPS_MainShootWeapon1 ||
            WeaponSlot == ESurviveWeaponPropSlot::SWPS_MainShootWeapon2 ||
            WeaponSlot == ESurviveWeaponPropSlot::SWPS_SubShootWeapon)
        {
            if (auto ShootWeaponComponent = CurrentWeaponReplicated->ShootWeaponComponent)
            {
                static bool IsHooked = false;
                if (IsHooked == false && ShootWeaponComponent != nullptr)
                {
                    uintptr_t ShotBulletInnerAddr = *(uintptr_t *)(*(uintptr_t *)((uintptr_t)ShootWeaponComponent) + 0x2A0);
                    DobbyHook((void *)ShotBulletInnerAddr, (void *)xShootBulletInner, (void **)&ShootBulletInner);
                    IsHooked = true;
                }
            }
        }
    }
}

void (*ShootBulletInner)(uintptr_t Weapon, FVector StartLoc, FRotator StartRot, int ShootID);
void xShootBulletInner(uintptr_t Weapon, FVector StartLoc, FRotator StartRot, int ShootID)
{
  // Add your Own Bulletrack Logic 
   return ShootBulletInner(Weapon, StartLoc, StartRot, ShootID);
}

__int64 (*Orig_CreateWeaponAndSkin)(__int64 result, int WeaponSkinID, bool bUse, bool bSync);
__int64 Hook_CreateWeaponAndSkin(__int64 result, int WeaponSkinID, bool bUse, bool bSync)
{ 
   if (WeaponSkinID == 101004)
   {
      WeaponSkinID = 1101004046;
   }          
   return Orig_CreateWeaponAndSkin(result, WeaponSkinID, bUse, bSync);
}

    DobbyHook((void *)(Cheat::libUE4Base + Tools::string2Offset("0x4fadf3c")), (void *)Hook_CreateWeaponAndSkin, (void **)&Orig_CreateWeaponAndSkin); // CreateWeaponAndSkin

__int64 __fastcall (*oBulletHitInfo)(__int64 result, float a2);
__int64 __fastcall hBulletHitInfo(__int64 result, float a2)
{
     auto Upload = (UBulletHitInfoUploadComponent*)result;
  Upload->UploadInterval = 0.1f; // 2.0f for delay hit
     Upload->bEnableTssSdkAntiData = false;
     Upload->bEnableTssSdkAntiDataFilter = false;
     Upload->bEnableTssSdkAntiDataFilterNew = false;
  Upload->bDisableDsTick = false;
     Upload->bDisableDsAntiDataReport = false;
  Upload->bEnableAddSPCShootData = false;
  Upload->NeedSendSimpleCharacterHitData = false;
   
   return oBulletHitInfo(result, a2);
}

Tools::Hook((void *) (UE4 + 90873760), (void *) hBulletHitInfo, (void **) &oBulletHitInfo);

unsigned int libanogsSize = 0x30EDF0; unsigned int libUE4Size = 0x793BD24;

unsigned int libanogsSize = 0x43DB54; unsigned int libUE4Size = 0xA7CBD94;