Oldyt2.de Hile kodu

megatrondev · 1 Mar 2026

Biraz karmaşık ama idare edin, yapay zekayla anca bu kadar oluyor. Bu haliyle çalışıyor kodlar siz düzenleyip daha iyi hale getirebilirsiniz.
Safe damage çok verimli değil moblardan %70 civarı kaçıyor gibi.
Rangeyi arttırırsanız engellere takılır oyundan atar.
Skillhack(ninja zehirli bulut) daha çok perfect skill de verimli oluyor gibi bazen metinleri 1000x atıyor bazen takılı kalıyor anlamadım. Arada sp yokken vuruyor bazen sp varken tek 1 tane vuruyor.
Bu skillhackı bunca zaman neden kimse paylaşmadı

COM2 fixlenmeyen pvplerde hala kullanıma sunuyor.

Adresleri güncellerseniz kendi oyununuzda kullanabilirsiniz, GetPixelPosition gerekmiyor.

Güncelleme: Move speed eklendi. Şimdilik shifte basmak gerekiyor.
[CODE lang="cpp" title="Güncel kod 01.03.2026 18:00"]// ================================================================
// ================================================================
// 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#define#include <#include#include <cma#includelude <stri#includelude <mut#includelude <atom#includelude <alg#include#include <#included_map>
#inclu#includeio>

#pragma comm#include "user32.li#pragmaagma comment(lib, "gdi32.lib#pragma================================================================
// 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;
}
[/CODE]
Bilerek dll vermiyorum siz build alıp kullanın.
Bazı fonksiyonları bulamadım yoksa C4US'daki radarı tam olarak ekleyecektim.

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

C4US'daki tüm fonksiyonları test edip çalışır hale getirirsem belki eğitim amaçlı herkesin rahatça kendisine uygun Guili sourceyi hazırlayabileceği bir proje hayata geçirebilirim.