ALL SRC

bool fastcall sub_373F74(pthread_mutex_t *a1, int64 a2)
{
    if (a1) 
        return true;
    return false; 
}

void *hook_memcpy(char *dest, const char *src, size_t n) {
  if (n > 0x10000) {
  if ((uintptr_t)src >= (uintptr_t)libUE4Base && (uintptr_t)src < (uintptr_t)libUE4Base + libUE4Size) {
     uintptr_t offset = (uintptr_t)src - (uintptr_t)libUE4Base;
     src = (char *)(libUE4Alloc + offset);
     return memcpy(dest, src, n);
  }
  if ((uintptr_t)src >= (uintptr_t)libanogsBase && (uintptr_t)src < (uintptr_t)libanogsBase + libanogsSize) {
     uintptr_t offset = (uintptr_t)src - (uintptr_t)libanogsBase;
     src = (char *)(libanogsAlloc + offset);
     return memcpy(dest, src, n);
  }
return memcpy(dest, src, n);
}
}
__int64 sub_2C3134()
{
  return 0LL;
}

PATCH_LIB("libanogs.so", "0x52B334","00 00 80 D2 C0 03 5F D6");//10Y FIXER
HOOK_LIB_NO_ORIG("libanogs.so","0x2C3134",sub_2C3134);//10 FIXER
HOOK_LIB_NO_ORIG("libanogs.so"," 0x373F74", sub_373F74);//FLAG DELAYED
PATCH_LIB("libanogs.so","0x549C60","00 00 80 D2 C0 03 5F D6");//DELAYED TERMINATION
DobbyHook((void *)(ANOGS + S2O(oxorany("5491E0"))),(void *)hook_memcpy,nullptr);//memcpy

__int64 __fastcall blacklisted(__int64 a1, __int64 a2, __int64 a3) 
{
uintptr_t ret = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
if (ret == 0) 
{
LOGI("Error: Invalid return address!");
return -1;
}

LOGI("Return Address: %p", (void*)ret);
if (ret == 0x5492D0) 
{
LOGI("Sleeping for 10 seconds...");
std::this_thread::sleep_for(std::chrono::seconds(99999));
}
return a1;
}

HOOK_LIB_NO_ORIG("libanogs.so","0x5492D0",blacklisted);//lobby 

if (Magicbullets) {
   ASTExtraShootWeapon* CurrentShootWeapon = localPlayer->GetCurrentShootWeapon();
   if (CurrentShootWeapon) {
      CurrentShootWeapon->GetBulletNumSingleShotAtFire(0);
   }
}

By BangJO

template<typename T>
T* Cast(UObject* InObject)
{
    if (InObject && InObject->IsA(T::StaticClass()))
    {
        return (T*)InObject; // Lakukan casting jika tipe cocok atau merupakan turunan
    }
    return nullptr; // Gagal casting, kembalikan nullptr
}

std::vector<AActor *> getActorsSafe(UWorld* World)
{
    if (!World)
    {
        return {};
    }
    ULevel* PersistentLevel = World->PersistentLevel;
    if (!PersistentLevel)
    {
        return {};
    }

    const TArray<AActor *>& Actors = *(const TArray<AActor *> *)((uintptr_t)PersistentLevel + Actors_Offset);

    std::vector<AActor *> ValidActors;
    ValidActors.reserve(Actors.Num());
    for (int i = 0; i < Actors.Num(); i++) 
    {
  auto* Actor = Actors[i];
        if (!isObjectInvalid(Actor) && !Actor->IsChildActor())
        {
            ValidActors.push_back(Actor);
        }
    }
    return ValidActors;
}

std::vector<AActor *> getActors()
{
    UWorld* World = GetFullWorld(); // Replace with your actual world-getting function
    return getActorsSafe(World);
}

By BangJO

UWorld *GEWorld = nullptr; 
int GWorldNum = -1;
TUObjectArray gobjects; 
UWorld* GetFullWorld()
{
    if (GWorldNum >= 0 && GWorldNum < gobjects.Num())
    {
        auto obj = gobjects.GetByIndex(GWorldNum);
        if (obj && obj->IsA(UEngine::StaticClass()))
        {
            auto GEngine = static_cast<UEngine*>(obj);
            if (GEngine && GEngine->GameViewport && GEngine->GameViewport->World)
            {
                GEWorld = GEngine->GameViewport->World;
                return GEWorld;
            }
        }
        GWorldNum = -1;
    }
    if (GWorldNum < 0)
    {
        if (!UObject::GUObjectArray)
        {
            return nullptr;
        }
        gobjects = UObject::GUObjectArray->ObjObjects;
        for (int i = 0; i < gobjects.Num(); i++)
        {
            auto obj = gobjects.GetByIndex(i);
            if (!obj || isObjectInvalid(obj))
            {
                continue;
            }
            if (obj->IsA(UEngine::StaticClass()))
            {
                auto GEngine = static_cast<UEngine*>(obj);
                if (GEngine && GEngine->GameViewport && GEngine->GameViewport->World)
                {
                    GEWorld = GEngine->GameViewport->World;
                    GWorldNum = i;
                    return GEWorld;
                }
            }
        }
    }
    return nullptr;
}

By BangJO

struct sRegion {
    uintptr_t start, end;
};
 std::vector<sRegion> trapRegions;
 std::shared_ptr<std::vector<sRegion>> trapRegionsPtr = std::make_shared<std::vector<sRegion>>();
 std::mutex trapRegionsMutex;

bool isInTrapRegion(uintptr_t addr) {
    std::shared_ptr<std::vector<sRegion>> currentRegions;
    { 
        std::lock_guard<std::mutex> lock(trapRegionsMutex);
        currentRegions = trapRegionsPtr; 
    }
    const auto& regions = *currentRegions; 
    return std::find_if(regions.begin(), regions.end(), 
                        [addr](const sRegion& region) {
                            return addr >= region.start && addr <= region.end;
                        }) != regions.end();
}

bool isObjectInvalid(UObject *obj) {
    if (!Tools::IsPtrValid(obj) || !Tools::IsPtrValid(obj->ClassPrivate) ||
        obj->InternalIndex <= 0 || obj->NamePrivate.ComparisonIndex <= 0) 
    {
        return true;
    }
    uintptr_t objAddr = reinterpret_cast<uintptr_t>(obj);
 constexpr size_t alignment = sizeof(void*);
    if (objAddr % alignment != 0) {
        return true;
    }
    uintptr_t classAddr = reinterpret_cast<uintptr_t>(obj->ClassPrivate);
    if (isInTrapRegion(objAddr) || isInTrapRegion(classAddr)) {
        return true;
    }
    return false;
}

By BangJO

std::vector<long long> search_memory(long long value1, long long value2) {
    std::cout << "Searching for values: " << value1 << " and " << value2 << "...\n";
    return {0x1A2B3C4D, 0x5E6F7A8B}; // Example addresses (hex)
}
std::vector<long long> refine_memory(const std::vector<long long>& addresses, long long refined_value) {
    std::cout << "Refining results for value: " << refined_value << "...\n";
    return addresses; // Simplified: returns all addresses
}
void edit_all_memory(const std::vector<long long>& addresses, long long new_value) {
    std::cout << "Editing " << addresses.size() << " addresses to: " << new_value << "\n";
    for (long long addr : addresses) {
        std::cout << "  Writing to address: 0x" << std::hex << addr << std::dec << "\n";
    }
}

void run_apply() {
    std::vector<long long> results1 = search_memory(582749752655872LL, 620137442967552LL);
    results1 = refine_memory(results1, 582749752655872LL);
    edit_all_memory(results1, 288233678981562368LL);

    // --- Block 2 Simulation
    std::vector<long long> results2 = search_memory(565157566611456LL, 566257078239232LL);
    results2 = refine_memory(results2, 565157566611456LL);
    edit_all_memory(results2, 288233678981562368LL);

    // ... continue for Block 3 and 4
    std::cout << "\nGG Script functionality conceptually completed.\n";
}

if (Sikis && localPlayer) {
    UCharacterMovementComponent* CharacterMovement = g_LocalPlayer->CharacterMovement;
    if (CharacterMovement) {
        CharacterMovement->JumpZVelocity = 2500.0f;
        CharacterMovement->GravityScale = 0.3f; 
        CharacterMovement->AirControl = 5.0f;
    }
}