Oldyt2.de Hile kodu

Adresleri güncellerseniz kendi oyununuzda kullanabilirsiniz, GetPixelPosition gerekmiyor.​

// ================================================================
// ================================================================
// UnifiedHack v10 - Oldyt2 / Rubinum 4.02
// v9 Bot (Range/Target/SwordWait/SkillWait/SafeDamage/Radar)
// + ShiftBoost (geri tepme yok)
//
// ShiftBoost mantigi:
//   1) SendStatePacket(hedef)  -> sunucu konumu kabul eder
//   2) SafeWrite bellek        -> istemci gorseli senkronize olur
//   3) 2x ekstra STATE         -> rubberband kilidi
// ================================================================

#define NOMINMAX
#include <wind[HASH=1]#define[/HASH]#include <[HASH=2388]#include[/HASH]#include <cma[HASH=2388]#include[/HASH]lude <stri[HASH=2388]#include[/HASH]lude <mut[HASH=2388]#include[/HASH]lude <atom[HASH=2388]#include[/HASH]lude <alg[HASH=2388]#include[/HASH]#include <[HASH=2388]#include[/HASH]d_map>
#inclu[HASH=2388]#include[/HASH]io>

#pragma comm[HASH=2388]#include[/HASH] "user32.li[HASH=3375]#pragma[/HASH]agma comment(lib, "gdi32.lib[HASH=3375]#pragma[/HASH]================================================================
// ADRESLER
// ================================================================
static const DWORD ADDR_PLAYER_BASE = 0x6E9D08;
static const DWORD ADDR_PLAYER_OFFSET = 0xC;
static const DWORD ADDR_INST_MGR = 0x6EA904;    //mob base
static const DWORD ADDR_NET = 0x6E9CEC;
static const DWORD ADDR_TARGET_PTR = 0x6E9D1C;
static const DWORD ADDR_TARGET_OFFSET = 0x11B20;

static const DWORD FN_SEND_ATTACK = 0x4849E0;
static const DWORD FN_SEND_STATE = 0x4823D0;
static const DWORD FN_SEND_USE_SKILL = 0x482530;
static const DWORD FN_SEND_ADD_FLY = 0x484DB0;
static const DWORD FN_SEND_SHOOT = 0x484D60;

static const DWORD OFF_X = 0x570;
static const DWORD OFF_Y = 0x574;
static const DWORD OFF_Z = 0x578;
static const DWORD OFF_VID = 0x65C;
static const DWORD OFF_DEAD = 0x54C;
static const DWORD OFF_TYPE = 0x504;

// ================================================================
// GUVENLI BELLEK
// ================================================================
template<typename T>
static T SafeRead(uintptr_t addr)
{
    T val = T();
    __try
    {
        val = *(T*)addr;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {}
    return val;
}

template<typename T>
static void SafeWrite(uintptr_t addr, T val)
{
    __try
    {
        *(T*)addr = val;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {}
}

// ================================================================
// YAPILAR
// ================================================================
struct D3DVEC { float x, y, z; };

struct Entity
{
    DWORD vid;
    float x, y, z, dist;
    int   type;
    bool  isTarget;
    bool  isThreat;
};

struct PrevPos { float x, y; DWORD tick; };

// ================================================================
// GLOBAL AYARLAR - BOT
// ================================================================
std::atomic<int>   g_attackMode(0);
std::atomic<int>   g_targetMode(0);
std::atomic<bool>  g_botEnabled(false);

std::atomic<bool>  g_wantMobs(false);
std::atomic<bool>  g_wantStones(false);
std::atomic<bool>  g_wantPlayers(false);

std::atomic<float> g_range(1500.0f);
std::atomic<int>   g_packetCount(1);
std::atomic<int>   g_packetDelay(20);
std::atomic<int>   g_mobLimit(7);
std::atomic<int>   g_loopDelay(75);

std::atomic<float> g_teleportStep(1000.0f);
std::atomic<float> g_attackRange(900.0f);
std::atomic<int>   g_skillIndex(35);

std::atomic<bool>  g_safeDamage(false);
std::atomic<float> g_threatRadius(450.0f);
std::atomic<float> g_escapeDist(1050.0f);

// ================================================================
// GLOBAL AYARLAR - SHIFT BOOST
// ================================================================
std::atomic<bool>  g_boostEnabled(true);
std::atomic<float> g_boostSpeed(50.0f);
std::atomic<int>   g_boostDelay(20);

// ================================================================
// ENTITY / STATE
// ================================================================
static std::vector<Entity>               g_entities;
static std::mutex                         g_entMutex;
static std::unordered_map<DWORD, PrevPos> g_prevPos;
static std::mutex                         g_prevMutex;
static HANDLE                             g_hStop = NULL;

static std::atomic<float> g_escX(0.f), g_escY(0.f), g_escZ(0.f);
static std::atomic<bool>  g_escActive(false);
static std::atomic<DWORD> g_selectedTargetVid(0);

// ================================================================
// GUI HANDLE'LARI
// ================================================================
HWND g_hwndMain = NULL;
HWND g_hwndRadar = NULL;
HWND g_btnBot = NULL;
HWND g_listLog = NULL;
HWND g_lblStatus = NULL;
HWND g_radSword = NULL;
HWND g_radSkill = NULL;
HWND g_radRange = NULL;
HWND g_radTarget = NULL;
HWND g_chkMob = NULL;
HWND g_chkStone = NULL;
HWND g_chkPlayer = NULL;
HWND g_chkSafe = NULL;
HWND g_editRange = NULL;
HWND g_editPkt = NULL;
HWND g_editDelay = NULL;
HWND g_editLimit = NULL;
HWND g_editLoop = NULL;
HWND g_editAtkRange = NULL;
HWND g_editTeleStep = NULL;
HWND g_editSkill = NULL;
HWND g_editThreat = NULL;
HWND g_editEscDist = NULL;
HWND g_lblTargetVid = NULL;
HWND g_btnBoost = NULL;
HWND g_editBoostAmt = NULL;
HWND g_editBoostDly = NULL;
HWND g_lblBoostState = NULL;

// ================================================================
// LOG
// ================================================================
static void LogAdd(const char* txt)
{
    if (!g_listLog) return;
    int cnt = (int)SendMessageA(g_listLog, LB_GETCOUNT, 0, 0);
    if (cnt > 200) SendMessageA(g_listLog, LB_DELETESTRING, 0, 0);
    SendMessageA(g_listLog, LB_ADDSTRING, 0, (LPARAM)txt);
    int last = (int)SendMessageA(g_listLog, LB_GETCOUNT, 0, 0) - 1;
    if (last >= 0) SendMessageA(g_listLog, LB_SETTOPINDEX, last, 0);
}

// ================================================================
// OYUNCU / NET
// ================================================================
static uintptr_t GetNetPtr()
{
    return SafeRead<uintptr_t>(ADDR_NET);
}

static uintptr_t GetPlayerPtr()
{
    uintptr_t base = SafeRead<uintptr_t>(ADDR_PLAYER_BASE);
    if (!base) return 0;
    return SafeRead<uintptr_t>(base + ADDR_PLAYER_OFFSET);
}

static bool GetPlayerPos(float& x, float& y, float& z)
{
    uintptr_t pl = GetPlayerPtr();
    if (!pl) return false;
    x = SafeRead<float>(pl + OFF_X);
    y = fabsf(SafeRead<float>(pl + OFF_Y));
    z = SafeRead<float>(pl + OFF_Z);
    return (x != 0.f || y != 0.f);
}

static DWORD GetTargetVid()
{
    DWORD* ptr = (DWORD*)ADDR_TARGET_PTR;
    if (!ptr || !(*ptr)) return 0;
    DWORD* tgt = (DWORD*)(*ptr + ADDR_TARGET_OFFSET);
    if (!tgt) return 0;
    return SafeRead<DWORD>((uintptr_t)tgt);
}

// ================================================================
// PAKET FONKSIYONLARI
// ================================================================
static bool SendStatePacket(float px, float py, float pz)
{
    uintptr_t net = GetNetPtr();
    if (!net) return false;
    D3DVEC pos = { px, fabsf(py), pz };
    DWORD fn = FN_SEND_STATE;
    __try
    {
        __asm
        {
            pushad
            push 0
            push 0
            push 0
            lea eax, pos
            push eax
            mov ecx, net
            mov eax, fn
            call eax
            popad
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return false;
    }
    return true;
}

static bool SendAttackPacket(DWORD vid)
{
    uintptr_t net = GetNetPtr();
    if (!net) return false;
    DWORD fn = FN_SEND_ATTACK;
    __try
    {
        __asm
        {
            pushad
            push vid
            push 0
            mov ecx, net
            mov eax, fn
            call eax
            add esp, 8
            popad
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return false;
    }
    return true;
}

static void SendUseSkill(DWORD vid, DWORD idx)
{
    uintptr_t net = GetNetPtr();
    if (!net) return;
    DWORD fn = FN_SEND_USE_SKILL;
    __try
    {
        __asm
        {
            pushad
            push vid
            push idx
            mov ecx, net
            mov eax, fn
            call eax
            popad
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {}
}

static void SendAddFly(DWORD vid, float tx, float ty, float tz)
{
    uintptr_t net = GetNetPtr();
    if (!net) return;
    D3DVEC pos = { tx, fabsf(ty), tz };
    DWORD fn = FN_SEND_ADD_FLY;
    __try
    {
        __asm
        {
            pushad
            lea eax, pos
            push eax
            push vid
            mov ecx, net
            mov eax, fn
            call eax
            popad
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {}
}

static void SendShoot(DWORD idx)
{
    uintptr_t net = GetNetPtr();
    if (!net) return;
    DWORD fn = FN_SEND_SHOOT;
    __try
    {
        __asm
        {
            pushad
            push idx
            mov ecx, net
            mov eax, fn
            call eax
            popad
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {}
}

// ================================================================
// WALKPATH
// ================================================================
static void WalkPath(float fx, float fy, float fz,
    float tx, float ty, float tz,
    float step, int maxSteps = 10)
{
    float dx = tx - fx;
    float dy = ty - fy;
    float dz = tz - fz;
    float dist = sqrtf(dx * dx + dy * dy + dz * dz);
    if (dist < 0.5f)
    {
        SendStatePacket(tx, ty, tz);
        return;
    }
    if (dist <= step || step <= 0.f)
    {
        SendStatePacket(tx, ty, tz);
        return;
    }
    int n = (int)(dist / step);
    if (n < 1) n = 1;
    if (n > maxSteps) n = maxSteps;
    for (int i = 1; i <= n; i++)
    {
        float t = (float)i / (float)n;
        SendStatePacket(fx + dx * t, fy + dy * t, fz + dz * t);
    }
}

// ================================================================
// ESCAPE
// ================================================================
static void CalcEscape(float ox, float oy, float oz,
    const std::vector<Entity*>& threats,
    float escDist,
    float& outX, float& outY, float& outZ)
{
    float cx = 0.f, cy = 0.f;
    for (auto* t : threats) { cx += t->x; cy += t->y; }
    cx /= (float)threats.size();
    cy /= (float)threats.size();
    float dx = ox - cx;
    float dy = oy - cy;
    float len = sqrtf(dx * dx + dy * dy);
    if (len < 0.01f) { dx = 1.f; dy = 0.f; len = 1.f; }
    dx /= len; dy /= len;
    outX = ox + dx * escDist;
    outY = oy + dy * escDist;
    outZ = oz;
}

// ================================================================
// SALDIRI
// ================================================================
static void AttackSword(const Entity& e, float safeX, float safeY, float safeZ)
{
    float step = g_teleportStep.load();
    int   n = std::max(1, g_packetCount.load());
    int   del = std::max(0, g_packetDelay.load());

    if (step > 0.f)
        WalkPath(safeX, safeY, safeZ, e.x, e.y, e.z, step);

    SendStatePacket(e.x, e.y, e.z);

    for (int i = 0; i < n; i++)
    {
        SendAttackPacket(e.vid);
        if (i < n - 1 && del > 0) Sleep(del);
    }

    SendStatePacket(safeX, safeY, safeZ);
    SendStatePacket(safeX, safeY, safeZ);
    SendStatePacket(safeX, safeY, safeZ);
}

static void AttackSkill(const Entity& e, float safeX, float safeY, float safeZ)
{
    float step = g_teleportStep.load();
    int   idx = g_skillIndex.load();
    int   n = std::max(1, g_packetCount.load());
    int   del = std::max(0, g_packetDelay.load());

    if (step > 0.f)
        WalkPath(safeX, safeY, safeZ, e.x, e.y, e.z, step);

    SendStatePacket(e.x, e.y, e.z);

    for (int i = 0; i < n; i++)
    {
        SendUseSkill(e.vid, (DWORD)idx);
        SendAddFly(e.vid, e.x, e.y, e.z);
        SendShoot((DWORD)idx);
        if (i < n - 1 && del > 0) Sleep(del);
    }

    SendStatePacket(safeX, safeY, safeZ);
    SendStatePacket(safeX, safeY, safeZ);
    SendStatePacket(safeX, safeY, safeZ);
}

static void AttackEntity(const Entity& e, float sx, float sy, float sz, int mode)
{
    if (mode == 0) AttackSword(e, sx, sy, sz);
    else           AttackSkill(e, sx, sy, sz);
}

// ================================================================
// THREAT TESPITI
// ================================================================
static bool IsThreat(DWORD vid, float d, float threatR,
    const std::unordered_map<DWORD, PrevPos>& prev,
    float px, float py, DWORD nowTick)
{
    if (d < threatR * 0.4f) return true;
    auto it = prev.find(vid);
    if (it == prev.end()) return false;
    DWORD dt = nowTick - it->second.tick;
    if (dt < 30 || dt > 3000) return false;
    float pdx = it->second.x - px;
    float pdy = it->second.y - py;
    float prevD = sqrtf(pdx * pdx + pdy * pdy);
    float threshold = std::max(2.0f, 3.0f * (float)dt / 100.0f);
    return (prevD > d + threshold);
}

// ================================================================
// ENTITY TARAMA - Range Modu
// ================================================================
static void ScanEntitiesRange(float px, float py)
{
    uintptr_t instMap = SafeRead<uintptr_t>(ADDR_INST_MGR);
    if (!instMap) return;

    const bool  wMob = g_wantMobs.load();
    const bool  wStone = g_wantStones.load();
    const bool  wPlayer = g_wantPlayers.load();
    const float range = g_range.load();
    const bool  doSafe = g_safeDamage.load();
    const float threatR = g_threatRadius.load();
    const DWORD nowTick = GetTickCount();

    std::vector<Entity> tmp;
    tmp.reserve(256);

    std::unordered_map<DWORD, PrevPos> prevCopy;
    {
        std::lock_guard<std::mutex> lg(g_prevMutex);
        prevCopy = g_prevPos;
    }

    std::unordered_map<DWORD, PrevPos> newPrev;
    newPrev.reserve(256);

    for (int i = 0; i < 2048; i++)
    {
        uintptr_t ent = SafeRead<uintptr_t>(instMap + i * 4);
        if (!ent) continue;
        DWORD vid = SafeRead<DWORD>(ent + OFF_VID);
        if (!vid) continue;
        if (SafeRead<int>(ent + OFF_DEAD) != 0) continue;
        int type = SafeRead<int>(ent + OFF_TYPE);
        if (type != 0 && type != 2 && type != 6) continue;

        float ex = SafeRead<float>(ent + OFF_X);
        float ey = fabsf(SafeRead<float>(ent + OFF_Y));
        float ez = SafeRead<float>(ent + OFF_Z);
        float dx = ex - px;
        float dy = ey - py;
        float d = sqrtf(dx * dx + dy * dy);

        float scanLimit = (range > 0.f) ? range * 1.5f : threatR * 2.0f;
        if (d > scanLimit && (!doSafe || d > threatR * 1.5f)) continue;

        bool isTarget = false;
        if (range > 0.f && d <= range)
        {
            if (type == 0 && wMob)    isTarget = true;
            if (type == 2 && wStone)  isTarget = true;
            if (type == 6 && wPlayer) isTarget = true;
        }

        bool isThreat = false;
        if (doSafe && type == 0 && d < threatR)
            isThreat = IsThreat(vid, d, threatR, prevCopy, px, py, nowTick);

        newPrev[vid] = { ex, ey, nowTick };

        Entity e2;
        e2.vid = vid;
        e2.x = ex;
        e2.y = ey;
        e2.z = ez;
        e2.dist = d;
        e2.type = type;
        e2.isTarget = isTarget;
        e2.isThreat = isThreat;
        tmp.push_back(e2);
    }

    {
        std::lock_guard<std::mutex> lg(g_prevMutex);
        g_prevPos = std::move(newPrev);
    }

    std::sort(tmp.begin(), tmp.end(), [](const Entity& a, const Entity& b)
        {
            int pa = (a.isThreat ? 2 : 0) + (a.isTarget ? 1 : 0);
            int pb = (b.isThreat ? 2 : 0) + (b.isTarget ? 1 : 0);
            if (pa != pb) return pa > pb;
            return a.dist < b.dist;
        });

    {
        std::lock_guard<std::mutex> lg(g_entMutex);
        g_entities = std::move(tmp);
    }
}

// ================================================================
// ENTITY TARAMA - Target Modu
// ================================================================
static void ScanEntitiesTarget(float px, float py)
{
    uintptr_t instMap = SafeRead<uintptr_t>(ADDR_INST_MGR);
    if (!instMap) return;

    DWORD targetVid = GetTargetVid();
    g_selectedTargetVid = targetVid;

    const bool  doSafe = g_safeDamage.load();
    const float threatR = g_threatRadius.load();
    const DWORD nowTick = GetTickCount();

    std::vector<Entity> tmp;
    tmp.reserve(64);

    std::unordered_map<DWORD, PrevPos> prevCopy;
    {
        std::lock_guard<std::mutex> lg(g_prevMutex);
        prevCopy = g_prevPos;
    }

    std::unordered_map<DWORD, PrevPos> newPrev;
    newPrev.reserve(64);

    for (int i = 0; i < 2048; i++)
    {
        uintptr_t ent = SafeRead<uintptr_t>(instMap + i * 4);
        if (!ent) continue;
        DWORD vid = SafeRead<DWORD>(ent + OFF_VID);
        if (!vid) continue;
        if (SafeRead<int>(ent + OFF_DEAD) != 0) continue;

        int   type = SafeRead<int>(ent + OFF_TYPE);
        float ex = SafeRead<float>(ent + OFF_X);
        float ey = fabsf(SafeRead<float>(ent + OFF_Y));
        float ez = SafeRead<float>(ent + OFF_Z);
        float dx = ex - px;
        float dy = ey - py;
        float d = sqrtf(dx * dx + dy * dy);

        bool isTarget = (vid == targetVid);
        bool isThreat = false;
        if (doSafe && type == 0 && d < threatR)
            isThreat = IsThreat(vid, d, threatR, prevCopy, px, py, nowTick);

        if (!isTarget && !isThreat)
        {
            newPrev[vid] = { ex, ey, nowTick };
            continue;
        }
        if (d > threatR * 2.0f && !isTarget) continue;

        newPrev[vid] = { ex, ey, nowTick };

        Entity e2;
        e2.vid = vid;
        e2.x = ex;
        e2.y = ey;
        e2.z = ez;
        e2.dist = d;
        e2.type = type;
        e2.isTarget = isTarget;
        e2.isThreat = isThreat;
        tmp.push_back(e2);
    }

    {
        std::lock_guard<std::mutex> lg(g_prevMutex);
        g_prevPos = std::move(newPrev);
    }

    std::sort(tmp.begin(), tmp.end(), [](const Entity& a, const Entity& b)
        {
            if (a.isTarget != b.isTarget) return (int)a.isTarget > (int)b.isTarget;
            if (a.isThreat != b.isThreat) return (int)a.isThreat > (int)b.isThreat;
            return a.dist < b.dist;
        });

    {
        std::lock_guard<std::mutex> lg(g_entMutex);
        g_entities = std::move(tmp);
    }
}

// ================================================================
// BOT THREAD
// ================================================================
static DWORD WINAPI BotThread(LPVOID)
{
    float localEscX = 0.f, localEscY = 0.f, localEscZ = 0.f;
    DWORD lastTargetVid = 0;

    while (WaitForSingleObject(g_hStop, 0) != WAIT_OBJECT_0)
    {
        float px, py, pz;
        if (!GetPlayerPos(px, py, pz)) { Sleep(500); continue; }

        if (g_targetMode.load() == 0) ScanEntitiesRange(px, py);
        else                           ScanEntitiesTarget(px, py);

        if (!g_botEnabled.load())
        {
            g_escActive = false;
            Sleep(200);
            continue;
        }

        std::vector<Entity> snap;
        {
            std::lock_guard<std::mutex> lg(g_entMutex);
            snap = g_entities;
        }

        const bool  doSafe = g_safeDamage.load();
        const float escDist = g_escapeDist.load();
        const int   limit = g_mobLimit.load();
        const int   mode = g_attackMode.load();

        if (g_targetMode.load() == 1)
        {
            DWORD cur = g_selectedTargetVid.load();
            if (cur != lastTargetVid)
            {
                char buf[64];
                if (cur) sprintf_s(buf, "[Target] Yeni: %X", cur);
                else     sprintf_s(buf, "[Target] Hedef yok");
                LogAdd(buf);
                lastTargetVid = cur;
            }
        }

        std::vector<Entity*> threats;
        for (auto& e : snap)
            if (e.isThreat) threats.push_back(&e);

        float safeX = px, safeY = py, safeZ = pz;

        if (doSafe && !threats.empty())
        {
            CalcEscape(px, py, pz, threats, escDist, localEscX, localEscY, localEscZ);
            g_escX = localEscX;
            g_escY = localEscY;
            g_escZ = localEscZ;
            g_escActive = true;
            SendStatePacket(localEscX, localEscY, localEscZ);
            SendStatePacket(localEscX, localEscY, localEscZ);
            safeX = localEscX; safeY = localEscY; safeZ = localEscZ;

            int tHit = 0;
            for (auto* t : threats)
            {
                if (!t->isTarget) continue;
                if (limit > 0 && tHit >= limit) break;
                AttackEntity(*t, safeX, safeY, safeZ, mode);
                SendStatePacket(safeX, safeY, safeZ);
                tHit++;
            }
            if (tHit > 0)
            {
                char buf[80];
                sprintf_s(buf, "[SafeDMG] Kacildi+%d vuruldu", tHit);
                LogAdd(buf);
            }
        }
        else
        {
            if (g_escActive.load())
            {
                SendStatePacket(px, py, pz);
                g_escActive = false;
            }
        }

        int hit = 0;
        for (const auto& e : snap)
        {
            if (!e.isTarget) continue;
            if (limit > 0 && hit >= limit) break;
            AttackEntity(e, safeX, safeY, safeZ, mode);
            if (doSafe && g_escActive.load()) SendStatePacket(safeX, safeY, safeZ);
            hit++;
        }
        if (hit > 0)
        {
            char buf[64];
            sprintf_s(buf, "[%s] %d hedefe saldirildi", mode == 0 ? "Sword" : "Skill", hit);
            LogAdd(buf);
        }

        SendStatePacket(safeX, safeY, safeZ);
        Sleep(g_loopDelay.load());
    }
    return 0;
}

// ================================================================
// SHIFT BOOST THREAD
//
// Neden onceki surum geri tepiyordu:
//   SetPixelPosition -> sadece istemci bellegini degistiriyordu.
//   Sunucu eski konumu bildiginden kisa sure sonra geri cekiyordu.
//
// Dogru siralama (rubberband yok):
//   1) SendStatePacket(hedef) -> sunucu "tamam" der, artik geri cekmez
//   2) SafeWrite(OFF_X/Y/Z)   -> istemci motoru bellegini okur, gorsel ilerler
//   3) 2x SendStatePacket     -> rubberband kilidi (lag/kayip paket korumasi)
// ================================================================
static DWORD WINAPI BoostThread(LPVOID)
{
    float lastX = 0.f, lastY = 0.f, lastZ = 0.f;
    bool  isFirst = true;

    while (WaitForSingleObject(g_hStop, 0) != WAIT_OBJECT_0)
    {
        if (!g_boostEnabled.load())
        {
            isFirst = true;
            Sleep(500);
            continue;
        }

        float curX, curY, curZ;
        if (!GetPlayerPos(curX, curY, curZ))
        {
            isFirst = true;
            Sleep(250);
            continue;
        }

        if (isFirst)
        {
            lastX = curX; lastY = curY; lastZ = curZ;
            isFirst = false;
            Sleep(10);
            continue;
        }

        float dx = curX - lastX;
        float dy = curY - lastY;
        float distSq = dx * dx + dy * dy;

        if (distSq > 1.0f && (GetAsyncKeyState(VK_SHIFT) & 0x8000))
        {
            float dist = sqrtf(distSq);
            float boost = g_boostSpeed.load();

            float nx = curX + (dx / dist) * boost;
            float ny = curY + (dy / dist) * boost;

            // 1) Sunucu bilgilendir
            SendStatePacket(nx, ny, curZ);

            // 2) Istemci bellegi guncelle
            uintptr_t pl = GetPlayerPtr();
            if (pl)
            {
                float rawY = SafeRead<float>(pl + OFF_Y);
                float signY = (rawY < 0.f) ? -1.f : 1.f;
                SafeWrite<float>(pl + OFF_X, nx);
                SafeWrite<float>(pl + OFF_Y, signY * ny);
                SafeWrite<float>(pl + OFF_Z, curZ);
            }

            // 3) Rubberband kilidi
            SendStatePacket(nx, ny, curZ);
            SendStatePacket(nx, ny, curZ);

            lastX = nx; lastY = ny; lastZ = curZ;
        }
        else
        {
            lastX = curX; lastY = curY; lastZ = curZ;
        }

        Sleep(g_boostDelay.load());
    }
    return 0;
}

// ================================================================
// RADAR
// ================================================================
static void DrawRadar(HDC hdc, int w, int h)
{
    RECT rc = { 0, 0, w, h };
    FillRect(hdc, &rc, (HBRUSH)GetStockObject(BLACK_BRUSH));

    float px, py, pz;
    bool  hasPlayer = GetPlayerPos(px, py, pz);
    int   cx = w / 2, cy = h / 2;

    float range = g_range.load();
    float radarRange = (range > 100.f) ? range : g_threatRadius.load() * 2.0f;
    if (radarRange < 1.f) radarRange = 1000.f;
    float scale = (float)cx / radarRange;

    SelectObject(hdc, GetStockObject(NULL_BRUSH));

    {
        HPEN pg = CreatePen(PS_SOLID, 1, RGB(22, 22, 22));
        HPEN old = (HPEN)SelectObject(hdc, pg);
        for (int i = 1; i <= 4; i++)
        {
            int r = (int)(radarRange * i / 4 * scale);
            Ellipse(hdc, cx - r, cy - r, cx + r, cy + r);
        }
        SelectObject(hdc, old); DeleteObject(pg);

        HPEN pa = CreatePen(PS_SOLID, 1, RGB(35, 35, 35));
        old = (HPEN)SelectObject(hdc, pa);
        MoveToEx(hdc, cx, 0, NULL); LineTo(hdc, cx, h);
        MoveToEx(hdc, 0, cy, NULL); LineTo(hdc, w, cy);
        SelectObject(hdc, old); DeleteObject(pa);
    }

    if (!hasPlayer)
    {
        SetBkMode(hdc, TRANSPARENT);
        SetTextColor(hdc, RGB(110, 110, 110));
        DrawTextA(hdc, "Oyuncu bekleniyor...", -1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        return;
    }

    if (g_range.load() > 0.f)
    {
        HPEN p = CreatePen(PS_DOT, 1, RGB(60, 60, 60));
        HPEN old = (HPEN)SelectObject(hdc, p);
        int  r = (int)(g_range.load() * scale);
        Ellipse(hdc, cx - r, cy - r, cx + r, cy + r);
        SelectObject(hdc, old); DeleteObject(p);
    }

    if (g_safeDamage.load())
    {
        HPEN p = CreatePen(PS_DOT, 1, RGB(255, 120, 0));
        HPEN old = (HPEN)SelectObject(hdc, p);
        int  r = (int)(g_threatRadius.load() * scale);
        Ellipse(hdc, cx - r, cy - r, cx + r, cy + r);
        SelectObject(hdc, old); DeleteObject(p);
    }

    if (g_escActive.load())
    {
        float ex2 = g_escX.load(), ey2 = g_escY.load();
        int   rx = (int)(cx + (ex2 - px) * scale);
        int   ry = (int)(cy + (ey2 - py) * scale);
        HPEN  p = CreatePen(PS_SOLID, 2, RGB(0, 180, 255));
        HPEN  old = (HPEN)SelectObject(hdc, p);
        MoveToEx(hdc, rx - 8, ry - 8, NULL); LineTo(hdc, rx + 8, ry - 8);
        LineTo(hdc, rx + 8, ry + 8); LineTo(hdc, rx - 8, ry + 8);
        LineTo(hdc, rx - 8, ry - 8);
        SelectObject(hdc, old); DeleteObject(p);
        HBRUSH br = CreateSolidBrush(RGB(0, 60, 100));
        RECT   rr = { rx - 7, ry - 7, rx + 7, ry + 7 };
        FillRect(hdc, &rr, br); DeleteObject(br);
    }

    {
        std::lock_guard<std::mutex> lg(g_entMutex);
        for (const auto& e : g_entities)
        {
            int mx = cx + (int)((e.x - px) * scale);
            int my = cy + (int)((e.y - py) * scale);
            if (mx < 2 || mx >= w - 2 || my < 2 || my >= h - 2) continue;

            COLORREF col;
            int      sz;
            if (e.isThreat && e.isTarget) { col = RGB(255, 120, 0); sz = 6; }
            else if (e.isThreat) { col = RGB(200, 80, 0);  sz = 5; }
            else if (e.isTarget)
            {
                sz = 4;
                col = (e.type == 0) ? RGB(255, 50, 50) :
                    (e.type == 2) ? RGB(255, 230, 0) : RGB(180, 0, 255);
            }
            else
            {
                sz = 2;
                col = (e.type == 0) ? RGB(70, 20, 20) :
                    (e.type == 2) ? RGB(65, 60, 0) : RGB(40, 0, 65);
            }
            HBRUSH br = CreateSolidBrush(col);
            HBRUSH ob = (HBRUSH)SelectObject(hdc, br);
            Ellipse(hdc, mx - sz, my - sz, mx + sz, my + sz);
            SelectObject(hdc, ob); DeleteObject(br);
        }

        if (g_targetMode.load() == 1 && g_selectedTargetVid.load() != 0)
        {
            DWORD tv = g_selectedTargetVid.load();
            for (const auto& e : g_entities)
            {
                if (e.vid != tv) continue;
                int  mx = cx + (int)((e.x - px) * scale);
                int  my = cy + (int)((e.y - py) * scale);
                HPEN p = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
                HPEN old = (HPEN)SelectObject(hdc, p);
                SelectObject(hdc, GetStockObject(NULL_BRUSH));
                Ellipse(hdc, mx - 10, my - 10, mx + 10, my + 10);
                SelectObject(hdc, old); DeleteObject(p);
                break;
            }
        }
    }

    HBRUSH br = CreateSolidBrush(RGB(0, 130, 255));
    HBRUSH ob = (HBRUSH)SelectObject(hdc, br);
    Ellipse(hdc, cx - 5, cy - 5, cx + 5, cy + 5);
    SelectObject(hdc, ob); DeleteObject(br);
}

static LRESULT CALLBACK RadarProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
    if (msg == WM_PAINT)
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
        RECT r;
        GetClientRect(hwnd, &r);
        DrawRadar(hdc, r.right, r.bottom);
        EndPaint(hwnd, &ps);
    }
    else if (msg == WM_TIMER) InvalidateRect(hwnd, NULL, FALSE);
    else if (msg == WM_CLOSE) ShowWindow(hwnd, SW_HIDE);
    else return DefWindowProcW(hwnd, msg, wp, lp);
    return 0;
}

// ================================================================
// AYAR OKUMA
// ================================================================
static void ReadSettings()
{
    auto getF = [](HWND h) -> float
        {
            if (!h) return -1.f;
            wchar_t b[32];
            GetWindowTextW(h, b, 32);
            return (float)_wtof(b);
        };
    auto getI = [](HWND h) -> int
        {
            if (!h) return -1;
            wchar_t b[32];
            GetWindowTextW(h, b, 32);
            return _wtoi(b);
        };

    float r = getF(g_editRange);    if (r >= 0.f) g_range = r;
    int   pk = getI(g_editPkt);      if (pk >= 0)   g_packetCount = std::max(1, pk);
    int   pd = getI(g_editDelay);    if (pd >= 0)   g_packetDelay = pd;
    int   ml = getI(g_editLimit);    if (ml >= 0)   g_mobLimit = ml;
    int   ld = getI(g_editLoop);     if (ld >= 0)   g_loopDelay = std::max(10, ld);
    float ar = getF(g_editAtkRange); if (ar >= 0.f) g_attackRange = ar;
    float ts = getF(g_editTeleStep); if (ts >= 0.f) g_teleportStep = ts;
    int   si = getI(g_editSkill);    if (si >= 0)   g_skillIndex = si;
    float tr = getF(g_editThreat);   if (tr > 0.f) g_threatRadius = tr;
    float ed = getF(g_editEscDist);  if (ed > 0.f) g_escapeDist = ed;
    float bs = getF(g_editBoostAmt); if (bs >= 1.f) g_boostSpeed = bs;
    int   bd = getI(g_editBoostDly); if (bd >= 5 && bd <= 500) g_boostDelay = bd;

    if (g_radRange && g_radTarget)
        g_targetMode = (SendMessageW(g_radRange, BM_GETCHECK, 0, 0) == BST_CHECKED) ? 0 : 1;

    if (g_chkMob)    g_wantMobs = (SendMessageW(g_chkMob, BM_GETCHECK, 0, 0) == BST_CHECKED);
    if (g_chkStone)  g_wantStones = (SendMessageW(g_chkStone, BM_GETCHECK, 0, 0) == BST_CHECKED);
    if (g_chkPlayer) g_wantPlayers = (SendMessageW(g_chkPlayer, BM_GETCHECK, 0, 0) == BST_CHECKED);
    if (g_chkSafe)   g_safeDamage = (SendMessageW(g_chkSafe, BM_GETCHECK, 0, 0) == BST_CHECKED);
}

// ================================================================
// ANA PENCERE
// ================================================================
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_CREATE:
    {
        int x = 10, y = 8;
        const int LW = 162, EW = 66, EX = x + LW + 3;

        auto MakeRow = [&](const wchar_t* lbl, const wchar_t* def, HWND& out)
            {
                CreateWindowW(L"STATIC", lbl, WS_CHILD | WS_VISIBLE, x, y + 2, LW, 18, hwnd, NULL, NULL, NULL);
                out = CreateWindowW(L"EDIT", def, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_NUMBER,
                    EX, y, EW, 22, hwnd, NULL, NULL, NULL);
                y += 26;
            };

        auto Sep = [&](const wchar_t* lbl)
            {
                CreateWindowW(L"STATIC", lbl, WS_CHILD | WS_VISIBLE, x, y, 385, 18, hwnd, NULL, NULL, NULL);
                y += 22;
            };

        // Saldiri tipi
        CreateWindowW(L"STATIC", L"Saldiri Tipi:", WS_CHILD | WS_VISIBLE, x, y + 2, LW, 18, hwnd, NULL, NULL, NULL);
        g_radSword = CreateWindowW(L"BUTTON", L"SwordWait", WS_CHILD | WS_VISIBLE | BS_AUTORADIOBUTTON | WS_GROUP,
            EX, y, 95, 20, hwnd, (HMENU)20, NULL, NULL);
        g_radSkill = CreateWindowW(L"BUTTON", L"SkillWait", WS_CHILD | WS_VISIBLE | BS_AUTORADIOBUTTON,
            EX + 100, y, 95, 20, hwnd, (HMENU)21, NULL, NULL);
        SendMessageW(g_radSword, BM_SETCHECK, BST_CHECKED, 0);
        y += 28;

        // Hedef modu
        CreateWindowW(L"STATIC", L"Hedef Modu:", WS_CHILD | WS_VISIBLE, x, y + 2, LW, 18, hwnd, NULL, NULL, NULL);
        g_radRange = CreateWindowW(L"BUTTON", L"Range Modu", WS_CHILD | WS_VISIBLE | BS_AUTORADIOBUTTON | WS_GROUP,
            EX, y, 95, 20, hwnd, (HMENU)30, NULL, NULL);
        g_radTarget = CreateWindowW(L"BUTTON", L"Target Modu", WS_CHILD | WS_VISIBLE | BS_AUTORADIOBUTTON,
            EX + 100, y, 95, 20, hwnd, (HMENU)31, NULL, NULL);
        SendMessageW(g_radRange, BM_SETCHECK, BST_CHECKED, 0);
        y += 28;

        // Hedef tipi
        CreateWindowW(L"STATIC", L"Hedef Tipi (Range):", WS_CHILD | WS_VISIBLE, x, y + 2, LW, 18, hwnd, NULL, NULL, NULL);
        g_chkMob = CreateWindowW(L"BUTTON", L"Mob", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, EX, y, 52, 20, hwnd, (HMENU)10, NULL, NULL);
        g_chkStone = CreateWindowW(L"BUTTON", L"Metin", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, EX + 57, y, 57, 20, hwnd, (HMENU)11, NULL, NULL);
        g_chkPlayer = CreateWindowW(L"BUTTON", L"Oyuncu", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, EX + 119, y, 68, 20, hwnd, (HMENU)12, NULL, NULL);
        y += 28;

        g_lblTargetVid = CreateWindowW(L"STATIC", L"Hedef VID: ---", WS_CHILD | WS_VISIBLE, x, y, 385, 20, hwnd, NULL, NULL, NULL);
        y += 26;

        Sep(L"─── Bot Ayarlari ────────────────────");
        MakeRow(L"Tarama Menzili:", L"1500", g_editRange);
        MakeRow(L"Paket Sayisi:", L"1", g_editPkt);
        MakeRow(L"Paket Gecikmesi (ms):", L"20", g_editDelay);
        MakeRow(L"Mob Limiti (0=snrsz):", L"7", g_editLimit);
        MakeRow(L"Dongu Gecikmesi (ms):", L"75", g_editLoop);

        Sep(L"─── SwordWait ───────────────────────");
        MakeRow(L"Saldiri Menzili:", L"900", g_editAtkRange);
        MakeRow(L"Teleport Adimi:", L"1000", g_editTeleStep);

        Sep(L"─── SkillWait ───────────────────────");
        MakeRow(L"Skill No:", L"35", g_editSkill);

        Sep(L"─── Safe Damage ─────────────────────");
        g_chkSafe = CreateWindowW(L"BUTTON", L"Safe Damage (moblardan kac)",
            WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
            x, y, 240, 20, hwnd, (HMENU)40, NULL, NULL);
        y += 24;
        CreateWindowW(L"STATIC", L"* Tehdit menzilindeki moblardan otomatik kacilir",
            WS_CHILD | WS_VISIBLE, x, y, 385, 18, hwnd, NULL, NULL, NULL);
        y += 18;
        CreateWindowW(L"STATIC", L"* Mob+SafeDMG: kacip o moblari da vurur",
            WS_CHILD | WS_VISIBLE, x, y, 385, 18, hwnd, NULL, NULL, NULL);
        y += 22;
        MakeRow(L"Tehdit Menzili:", L"450", g_editThreat);
        MakeRow(L"Kacis Mesafesi:", L"1050", g_editEscDist);

        Sep(L"─── Shift Boost ─────────────────────");
        CreateWindowW(L"STATIC", L"Kosarken SHIFT tut = anlik boost (rubberband yok)",
            WS_CHILD | WS_VISIBLE, x, y, 385, 18, hwnd, NULL, NULL, NULL);
        y += 20;
        MakeRow(L"Boost Miktari (px):", L"50", g_editBoostAmt);
        MakeRow(L"Boost Dongu (ms):", L"20", g_editBoostDly);
        g_btnBoost = CreateWindowW(L"BUTTON", L"BOOST: ACIK",
            WS_CHILD | WS_VISIBLE, x, y, 120, 26, hwnd, (HMENU)50, NULL, NULL);
        g_lblBoostState = CreateWindowW(L"STATIC", L"[SHIFT basili tut]",
            WS_CHILD | WS_VISIBLE, x + 130, y + 5, 220, 18, hwnd, NULL, NULL, NULL);
        y += 34;

        Sep(L"─────────────────────────────────────");
        CreateWindowW(L"BUTTON", L"Radar", WS_CHILD | WS_VISIBLE, x, y, 70, 28, hwnd, (HMENU)2, NULL, NULL);
        g_btnBot = CreateWindowW(L"BUTTON", L"BOT: BASLAT", WS_CHILD | WS_VISIBLE,
            x + 80, y, 130, 28, hwnd, (HMENU)1, NULL, NULL);
        y += 36;

        g_listLog = CreateWindowW(L"LISTBOX", NULL,
            WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER | LBS_NOINTEGRALHEIGHT,
            x, y, 385, 80, hwnd, NULL, NULL, NULL);
        y += 88;

        g_lblStatus = CreateWindowW(L"STATIC", L"Hazir", WS_CHILD | WS_VISIBLE,
            x, y, 385, 20, hwnd, NULL, NULL, NULL);

        SetTimer(hwnd, 1, 250, NULL);
        break;
    }

    case WM_COMMAND:
    {
        int id = LOWORD(wp);
        if (id == 1)
        {
            g_botEnabled = !g_botEnabled;
            SetWindowTextW(g_btnBot, g_botEnabled ? L"BOT: DURDUR" : L"BOT: BASLAT");
            LogAdd(g_botEnabled ? "[Bot] Baslatildi" : "[Bot] Durduruldu");
        }
        else if (id == 2)
        {
            if (g_hwndRadar)
                ShowWindow(g_hwndRadar, IsWindowVisible(g_hwndRadar) ? SW_HIDE : SW_SHOW);
        }
        else if (id == 20) { g_attackMode = 0; LogAdd("[Mod] SwordWait"); }
        else if (id == 21) { g_attackMode = 1; LogAdd("[Mod] SkillWait"); }
        else if (id == 30) { g_targetMode = 0; LogAdd("[Mod] Range Modu"); }
        else if (id == 31) { g_targetMode = 1; LogAdd("[Mod] Target Modu"); }
        else if (id == 50)
        {
            g_boostEnabled = !g_boostEnabled;
            SetWindowTextW(g_btnBoost, g_boostEnabled ? L"BOOST: ACIK" : L"BOOST: KAPALI");
            LogAdd(g_boostEnabled ? "[Boost] Acildi" : "[Boost] Kapatildi");
        }
        break;
    }

    case WM_TIMER:
    {
        ReadSettings();

        if (g_lblTargetVid)
        {
            DWORD    tv = GetTargetVid();
            wchar_t  buf[64];
            if (tv)  swprintf_s(buf, L"Hedef VID: %X", tv);
            else     wcscpy_s(buf, L"Hedef VID: ---");
            SetWindowTextW(g_lblTargetVid, buf);
        }

        int tgt = 0, thr = 0;
        {
            std::lock_guard<std::mutex> lg(g_entMutex);
            for (const auto& e : g_entities)
            {
                if (e.isTarget) tgt++;
                if (e.isThreat) thr++;
            }
        }

        bool    shifting = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
        wchar_t st[256];
        swprintf_s(st, L"Bot:%s | Hedef:%d Tehdit:%d | %s | %s%s%s | Boost:%s%s",
            g_botEnabled.load() ? L"ACIK" : L"KAPALI",
            tgt, thr,
            g_attackMode.load() == 0 ? L"Sword" : L"Skill",
            g_targetMode.load() == 0 ? L"Range" : L"Target",
            g_safeDamage.load() ? L" SafeDMG" : L"",
            g_escActive.load() ? L" [KACILIYOR]" : L"",
            g_boostEnabled.load() ? L"ACIK" : L"KAPALI",
            (g_boostEnabled.load() && shifting) ? L" [AKTIF]" : L"");

        if (g_lblStatus) SetWindowTextW(g_lblStatus, st);
        break;
    }

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProcW(hwnd, msg, wp, lp);
    }
    return 0;
}

// ================================================================
// GUI THREAD
// ================================================================
static DWORD WINAPI GuiThread(LPVOID)
{
    WNDCLASSW wc = {};
    wc.lpfnWndProc = WndProc;
    wc.lpszClassName = L"UH10_MAIN";
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClassW(&wc);

    g_hwndMain = CreateWindowExW(0, L"UH10_MAIN",
        L"UnifiedHack v10  |  Bot + ShiftBoost",
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        80, 80, 430, 970, NULL, NULL, NULL, NULL);
    ShowWindow(g_hwndMain, SW_SHOW);

    WNDCLASSW rw = {};
    rw.lpfnWndProc = RadarProc;
    rw.lpszClassName = L"UH10_RADAR";
    rw.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    rw.hCursor = LoadCursor(NULL, IDC_CROSS);
    RegisterClassW(&rw);

    g_hwndRadar = CreateWindowExW(WS_EX_TOPMOST, L"UH10_RADAR", L"Radar",
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        520, 80, 400, 400, NULL, NULL, NULL, NULL);
    ShowWindow(g_hwndRadar, SW_SHOW);
    SetTimer(g_hwndRadar, 1, 80, NULL);

    MSG m;
    while (GetMessageW(&m, NULL, 0, 0))
    {
        TranslateMessage(&m);
        DispatchMessageW(&m);
    }
    return 0;
}

// ================================================================
// DLL ENTRY
// ================================================================
BOOL APIENTRY DllMain(HMODULE hMod, DWORD reason, LPVOID)
{
    if (reason == DLL_PROCESS_ATTACH)
    {
        DisableThreadLibraryCalls(hMod);
        g_hStop = CreateEventW(NULL, TRUE, FALSE, NULL);
        CreateThread(NULL, 0, GuiThread, NULL, 0, NULL);
        Sleep(300);
        CreateThread(NULL, 0, BotThread, NULL, 0, NULL);
        CreateThread(NULL, 0, BoostThread, NULL, 0, NULL);
    }
    else if (reason == DLL_PROCESS_DETACH && g_hStop)
    {
        SetEvent(g_hStop);
        Sleep(400);
        CloseHandle(g_hStop);
        g_hStop = NULL;
    }
    return TRUE;
}

Bazı fonksiyonları bulamadım yoksa C4US'daki radarı tam olarak ekleyecektim.