HERAKLES Otomatik Avlı kalıcı sunucu. 19 Haziran'da açılıyor. Atius & Wizard güvencesiyle hemen kayıt ol, ön kayıt ödülleri aktif. HEMEN TIKLA!
drayn4145 dcden ulaşır mısın
[CODE lang="cpp" title="memory"]#include <windows.h>
uintptr_t client = (uintptr_t)GetModuleHandleA(NULL);
struct MoveToDest
{
float x, y, z;
};
struct D3DVECTOR3
{
float x, y, z;
};
class Vector2
{
public:
Vector2() : x(0.f), y(0.f) {}
Vector2(float _x, float _y) : x(_x), y(_y) {}
~Vector2() {}
float x;
float y;
inline float Dot(Vector2 v)
{
return x * v.x + y * v.y;
}
inline float Distance(Vector2 v)
{
return sqrtf(powf(v.x - x, 2.0f) + powf(v.y - y, 2.0f));
}
Vector2 operator+(Vector2 v)
{
return Vector2(x + v.x, y + v.y);
}
Vector2 operator-(Vector2 v)
{
return Vector2(x - v.x, y - v.y);
}
Vector2 operator+(const Vector2& v) const
{
return Vector2(x + v.x, y + v.y);
}
Vector2 Cnv(float offsetX, float offsetY) const {
return *this + Vector2(offsetX, offsetY);
}
};
class Vector3
{
public:
Vector3() : x(0.f), y(0.f), z(0.f) {}
Vector3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {}
~Vector3() {}
float x;
float y;
float z;
inline float Dot(Vector3 v)
{
return x * v.x + y * v.y + z * v.z;
}
inline float Distance(Vector3 v)
{
return sqrtf(powf(v.x - x, 2.0f) + powf(v.y - y, 2.0f) + powf(v.z - z, 2.0f));
}
Vector3 operator+(Vector3 v)
{
return Vector3(x + v.x, y + v.y, z + v.z);
}
Vector3 operator-(Vector3 v)
{
return Vector3(x - v.x, y - v.y, z - v.z);
}
Vector3 operator+(const Vector3& v) const
{
return Vector3(x + v.x, y + v.y, z + v.z);
}
Vector3 Cnv(float offsetX, float offsetY, float offsetZ) const {
return *this + Vector3(offsetX, offsetY, offsetZ);
}
};
std::string WideToUtf8(const wchar_t* wideStr)
{
if (!wideStr) return "";
int size_needed = WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, nullptr, 0, nullptr, nullptr);
std::string strTo(size_needed, 0);
WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, &strTo[0], size_needed, nullptr, nullptr);
return strTo;
}
struct c_entity
{
int Type;
float x;
float y;
float z;
float GetPixelPositionX;
float GetPixelPositionY;
float GetPixelPositionZ;
int levels;
float Rotation;
int IsDead;
int IsChar;
int NoKnockBack;
char Name[100];
DWORD VID;
} c_entity[355];
struct c_players
{
float x;
float y;
float z;
float GetPixelPositionX;
float GetPixelPositionY;
float GetPixelPositionZ;
float Rotation;
int IsDead;
char Name[100];
int IsChar;
int levels;
int NoKnockBack;
DWORD VID;
DWORD SkillHacks;
} c_players;
enum NPC
{
OBJECT_NPC = 1,
OBJECT_PLAYER = 6,
OBJECT_ENTİTY = 0,
OBJECT_STONE = 2,
};
namespace data
{
inline bool IsType(int ID, NPC type) {
return c_entity[ID].Type == type;
}
}
enum
{
POINT_NONE = 0,
POINT_LEVEL = 1,
POINT_VOICE = 2,
POINT_EXP = 3,
POINT_NEXT_EXP = 4,
POINT_HP = 5,
POINT_MAX_HP = 6,
POINT_SP = 7,
POINT_MAX_SP = 8,
POINT_STAMINA = 9,
POINT_MAX_STAMINA = 10,
};
enum class LycanArmor : int
{
Gokruzgari = 21009,
BoraPlaka = 21019,
MalahitPlaka = 21029,
KasirgaPlaka = 21039,
BronzPlaka = 21049,
KoboldPlaka = 21059,
ZodyakPlaka = 21069,
Gecegolgesi = 21079,
Ormanci = 21089,
Baskomutan = 21099,
Zodyak = 21209,
GolgeSavasi = 20809,
AkikPlaka = 20859,
AyTasiPlaka = 20909,
OniksPlaka = 20959,
Kyanit = 12099
};
enum class WarriorArmor : int
{
Kesisk = 11209,
Demir = 11219,
Kaplan = 11229,
Aslan = 11239,
Olumcul = 11249,
Ejderha = 11259,
MaviTas = 11269,
AltinTas = 11279,
EjderhaTanrisi = 11289,
SiyahCelik = 11299,
MaviCelik = 12019,
SeytanBoynuzu = 20009,
Zodyak = 19299,
KutupIsigi = 20769,
MagmaKoru = 20819,
BalinaKemigi = 20869,
KulYagmuru = 20919,
Kyanit = 12059
};
enum class NinjaArmor : int
{
GokMavisi = 11409,
Fildisi = 11419,
KoyuKirmizi = 11429,
KirmiziKarinca = 11439,
KarincaAslan = 11449,
Ninja = 11459,
GencEjderha = 11469,
OldurucuRuzgar = 11479,
Kupecicegi = 11489,
SiyahRuzgar = 11499,
MaviEjderha = 12029,
EjderSsuvari = 20259,
Zodyak = 19499,
Suikast = 20779,
KanliAy = 20829,
Donusum = 20879,
OlumGecesi = 20929,
Kyanit = 12069
};
enum class SuraArmor : int
{
Agit = 11609,
Buyucu = 11619,
KotuSans = 11629,
Hayalet = 11639,
YinYang = 11649,
Mistik = 11659,
Belirsiz = 11669,
HayaletSurat = 11679,
Ruh = 11689,
KaraBuyu = 11699,
AuraTas = 12039,
KemikPlaka = 20509,
Zodyak = 19699,
SeytanPencesi = 20789,
CehennemKosucu = 20839,
YaniticiIsik = 20889,
KaraAtes = 20939,
Kyanit = 12079
};
enum class ShamanArmor : int
{
GokMavisi = 11809,
Turkuaz = 11819,
Pembe = 11829,
Sevgi = 11839,
Sema = 11849,
Gunes = 11859,
Manevi = 11869,
TuruncuKedi = 11879,
SoyluKadin = 11889,
Siyah = 11899,
Ejderha = 12049,
Altin = 20759,
Zodyak = 19899,
Inanc = 20799,
Ates = 20849,
Ahenk = 20899,
Ay = 20949,
Kyanit = 12089
};
namespace Effects
{
int EFFECT_FIRE[] = { 1, 26, -1 };
int EFFECT_GM[] = { 1, 0, -1 };
int EFFECT_AIR_SOWRD[] = { -1,15,1 };
int EFFECT_MEGIC_SWORD[] = { -1,19,1 };
int EFFECT_HORROR[] = { -1,20,1 };
int EFFECT_MEGİCAL_ARMOR[] = { -1,21,1 };
int EFFECT_BLLASSING[] = { -1,22,1 };
int EFFECT_DRAGON_HELP[] = { -1,29,1 };
int EFFECT_PROJECTION[] = { -1,23,1 };
int EFFECT_HIGH_ATTACK[] = { -1,30,1 };
int EFFECT_STRONG_BODY[] = { -1,16,1 };
}
#p#p#pragmanceHANDLE MEMORY = OpenProcess(PROCESS_ALL_ACCESS, 0, GetCurrentProcessId());
DWORD GetModules;
BOOL PointModule = FALSE;
uintptr_t Ez_game_base = (uintptr_t)GetModuleHandleA(NULL);
namespace Ez_memory
{
uintptr_t Adres(uintptr_t pointer, std::vector<unsigned int> adres)
{
uintptr_t adres_c = pointer;
for (unsigned int i = 0; i < adres.size(); ++i)
{
if (adres_c == 0 || IsBadReadPtr((void*)adres_c, sizeof(uintptr_t))) {
return 0;
}
adres_c = *(uintptr_t*)adres_c;
if (adres_c == 0 || IsBadReadPtr((void*)adres_c, sizeof(uintptr_t))) {
return 0;
}
adres_c += adres;
}
return adres_c;
}
}
template <typename T>
T ReadMemory(DWORD_PTR address, T* value = nullptr, bool isWrite = false) {
if (isWrite) {
if (!IsBadWritePtr(reinterpret_cast<void*>(address), sizeof(T))) {
*(T*)address = *value;
return *value;
}
}
else {
if (!IsBadReadPtr(reinterpret_cast<void*>(address), sizeof(T))) {
return *(T*)address;
}
}
T def{};
return def;
}
uintptr_t GetModuleBaseAddress(const char* moduleName) {
HMODULE hModule = GetModuleHandle(moduleName);
if (!hModule) {
MessageBox(NULL, "Modül bulunamadı!", "Hata", MB_OK);
return 0;
}
return (uintptr_t)hModule;
}
namespace driver
{
template <typename T>
bool ReadMemory(DWORD moduleHandle, DWORD baseClient, DWORD addr, DWORD offsets, T& value)
{
DWORD off1, off2;
if (!ReadProcessMemory(MEMORY, (LPCVOID)(moduleHandle + baseClient), &off1, sizeof(DWORD), NULL))
return false;
if (!ReadProcessMemory(MEMORY, (LPCVOID)(off1 + addr), &off2, sizeof(DWORD), NULL))
return false;
if (!ReadProcessMemory(MEMORY, (LPCVOID)(off2 + offsets), &value, sizeof(T), NULL))
return false;
return true;
}
void WriteAssembly(uintptr_t address, int newValue) {
DWORD oldProtect;
if (VirtualProtect((LPVOID)address, sizeof(int), PAGE_EXECUTE_READWRITE, &oldProtect)) {
memcpy((void*)address, &newValue, sizeof(int));
VirtualProtect((LPVOID)address, sizeof(int), oldProtect, &oldProtect);
}
else {
MessageBox(NULL, "Bellek koruma ayarı değiştirilemedi!", "Hata", MB_OK);
}
}
}
#pragma#pragmainclud#include"
bool local = true;
bool entity = true;
bool Writes = true;
DWORD WINAPI MemoryManager(LPVOID param) {
if (!PointModule)
{
GetModules = (DWORD)GetModuleHandleA(NULL);
PointModule = TRUE;
}
while (true)
{
try
{
for (int i = 0; i < 331; i += 4) {
// ======================================== LocalPlayer ========================================//
if (local)
{
driver::ReadMemory<float>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_CoordX, c_players.x);
driver::ReadMemory<float>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_CoordY, c_players.y);
driver::ReadMemory<float>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_CoordZ, c_players.z);
}
if (local)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_IsDead, c_players.IsDead);
}
if (local)
{
driver::ReadMemory<float>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_IsRotation, c_players.Rotation);
}
if (local)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_IsCharacterType, c_players.IsChar);
}
if (local)
{
driver::ReadMemory<DWORD>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_IsVID, c_players.VID);
}
if (local)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_Lvl, c_players.levels);
}
if (local)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_NoKnockBack, c_players.NoKnockBack);
}
if (local)
{
char local_names[100] = { 0 };
driver::ReadMemory<char[100]>(GetModules, metin2client::CPythonCharacterManager, metin2client::Instance, metin2client::C_Name, local_names);
strcpy_s(c_players.Name, sizeof(c_players.Name), local_names);
}
// ======================================== Entitylist ========================================//
if (entity)
{
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_CoordX, c_entity.x);
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_CoordY, c_entity.y);
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_CoordZ, c_entity.z);
}
if (entity)
{
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_GetPixelPositionX, c_entity.GetPixelPositionX);
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_GetPixelPositionY, c_entity.GetPixelPositionY);
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_GetPixelPositionZ, c_entity.GetPixelPositionZ);
}
if (entity)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_IsDead, c_entity.IsDead);
}
if (entity)
{
driver::ReadMemory<DWORD>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_IsVID, c_entity.VID);
}
if (entity)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_IsRadarType, c_entity.Type);
}
if (entity)
{
driver::ReadMemory<float>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_IsRotation, c_entity.Rotation);
}
if (entity)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_IsCharacterType, c_entity.IsChar);
}
if (entity)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_Lvl, c_entity.levels);
}
if (entity)
{
driver::ReadMemory<int>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_NoKnockBack, c_entity.NoKnockBack);
}
if (entity)
{
char entites_name[100] = { 0 };
driver::ReadMemory<char[100]>(GetModules, metin2client::CPythonInstanceManager, i, metin2client::C_Name, entites_name);
strcpy_s(c_entity.Name, sizeof(c_entity.Name), entites_name);
}
}
Sleep(1);
}
catch (...)
{
}
}
}[/CODE]
[CODE lang="cpp" title="range wait source tam source"]namespace metin2client
{
// Localplayer
DWORD CPythonCharacterManager = 0x2F9180; // Yapıldı!!
DWORD CPythonInstanceManager = 0x2F93AC; // Yapıldı!!
DWORD CPythonChatManager = 0x2F9220;
DWORD SetAccountConnector = 0x2F56B0;
DWORD GetName = 0x84;
DWORD GetPassword = 0x9D;
DWORD CPythonPlayer = 0x2F9198; // Yapıldı!!
DWORD CPythonNetworkStream = 0x2F56AC; // Yapıldı!!
// local addr xd
DWORD Instance = 0x14; // Yapıldı
DWORD Mng = 0x4; // Yapıldı!!
// Pointers
DWORD C_NoClip = 0x828;
DWORD C_IsVID = 0x820;
// Character
DWORD C_AttackSpeed = 0x760;
DWORD C_MovementSpeed = 0x75C;
DWORD C_SwordRange = 0x758;
DWORD C_NoKnockBack = 0x6F4;
DWORD C_CoordX = 0x72C;
DWORD C_CoordY = 0x730;
DWORD C_CoordZ = 0x734;
DWORD C_GetPixelPositionX = 0x4EC;
DWORD C_GetPixelPositionY = 0x4F0;
DWORD C_GetPixelPositionZ = 0x4F4;
DWORD C_ModelX = 0x1F0;
DWORD C_ModelY = 0x1F4;
DWORD C_ModelZ = 0x1F8;
DWORD C_OneHit = 0x6BC;
DWORD C_Fixing = 0x81C; // Byte
DWORD C_DamageFix = 0x714; // byte 0
DWORD C_Name = 0x10;
DWORD C_Lvl = 0x44;
DWORD C_IsDead = 0x708;
DWORD C_IsRotation = 0x77C;
DWORD C_IsRadarType = 0x6C0;
DWORD C_IsCharacterType = 0x6C4;
// Game Packed
DWORD MoveToDestPosition = 0x4BA50;// Yapıldı!
DWORD GetStatus = 0x95890; // Yapıldı!!
DWORD SetStatus = 0x95730; // Yapıldı!!
DWORD SetAffect = 0x5FB60; // Yapıldı
DWORD Refresh = 0x5D0D0; // yapıldı!!
DWORD PickCloseItem = 0x99840; // Yapıldı!!
DWORD GetMainCharacterPosition = 0x95000; // Yapıldı!!
DWORD SetAttackKeyState = 0x9A910; // Yapıldı!!
DWORD SendChatPacket = 0x880D0; // Yapıldı!!
DWORD SendItemUsePacket = 0x90D30;// Yapıldı!!
DWORD GetTargetVID = 0x998D0; // Yapıldı!!
DWORD SendBattlePacked = 0x8A830; // Yapıldı!!
DWORD SendEmoticon = 0x80FB0; // Yapıldı!!
DWORD SendShootPacket = 0x8ABB0; // Yapıldı!!
DWORD GetPixelPosition = 0x4BDD0;// Yapıldı!!
DWORD SetArmor = 0x43CA0;// Yapıldı!!
DWORD SendCharacterStatePacket = 0x87EF0; // Yapıldı!!
DWORD SendAddFlyTargeting = 0x8AC00; // Yapıldı!!
DWORD ClickSkillSlot = 0xA0530; // Yapıldı!!
DWORD SendItemPickUpPacket = 0x91250;
}
class Addresses
{
public:
static DWORD* GetMainActorPtr()
{
DWORD* CPythonCharacterManager = *(DWORD**)(client + metin2client::CPythonCharacterManager);
if (!CPythonCharacterManager)return nullptr;
DWORD* Instance = *(DWORD**)((DWORD)CPythonCharacterManager + metin2client::Instance);
if (!Instance)return nullptr;
return Instance;
}
template<typename T>
static void Write(DWORD offset, T value)
{
DWORD* pActor = GetMainActorPtr();
if (!pActor)
return;
*(T*)((DWORD)pActor + offset) = value;
}
template<typename T>
static T Read(DWORD offset)
{
DWORD* pActor = GetMainActorPtr();
if (!pActor)
return T();
return *(T*)((DWORD)pActor + offset);
}
static DWORD* iGetConnector()
{
DWORD* CPythonCharacterManager = *(DWORD**)(client + metin2client::SetAccountConnector);
if (!CPythonCharacterManager) return nullptr;
return CPythonCharacterManager;
}
template<typename T>
static T* Server(DWORD offset)
{
DWORD* pActor = iGetConnector();
if (!pActor)
return nullptr;
return reinterpret_cast<T*>((DWORD)pActor + offset);
}
static DWORD* CharacterManager()
{
DWORD* CPythonCharacterManager = *(DWORD**)(client + metin2client::CPythonCharacterManager);
if (!CPythonCharacterManager)return nullptr;
return CPythonCharacterManager;
}
static void* İCPythonCharacterManager()
{
DWORD mgr = *(DWORD*)(client + metin2client::CPythonCharacterManager);
if (!mgr) return nullptr;
return (void*)mgr;
}
static void* iNetworkStreamInstance()
{
DWORD inst = *(DWORD*)(client + metin2client::CPythonNetworkStream);
if (!inst) return nullptr;
return (void*)inst;
}
static void* iPythonInstance()
{
DWORD CPythonPlayer = *(DWORD*)(client + metin2client::CPythonPlayer);
if (!CPythonPlayer) return nullptr;
return (void*)CPythonPlayer;
}
static void* iCPythonPlayerInstance()
{
DWORD CPythonPlayerMgr = *(DWORD*)(client + metin2client::CPythonPlayer);
if (!CPythonPlayerMgr)return nullptr;
void* pInstance = (void*)(CPythonPlayerMgr + metin2client::Mng);
if (!pInstance)return nullptr;
return pInstance;
}
};
static Vector3 InstanceBaseNEW_GetPixelPosition(Vector3* pOut)
{
try
{
typedef void(__thiscall* tCInstanceBaseNEW_GetPixelPosition)(void* thisPtr, Vector3* pOut);
tCInstanceBaseNEW_GetPixelPosition GetPixel = (tCInstanceBaseNEW_GetPixelPosition)(client + metin2client::GetPixelPosition);
void* Instance = Addresses::GetMainActorPtr();
if (!Instance || !GetPixel)
{
if (pOut)
*pOut = Vector3{ 0.f, 0.f, 0.f };
return { 0.f, 0.f, 0.f };
}
Vector3 vector{};
GetPixel(Instance, &vector);
if (pOut)
*pOut = vector;
return vector;
}
catch (...) {
if (pOut)
*pOut = Vector3{ 0.f, 0.f, 0.f };
return Vector3{ 0.f, 0.f, 0.f };
}
}
static bool NetworkStreamSendAttackPacket(UINT dwAttack, DWORD dwVID)
{
try
{
typedef void(__thiscall* tSendBattleAttackPacket)(void* This, UINT dwAttack, DWORD dwVID);
tSendBattleAttackPacket SendPacket = (tSendBattleAttackPacket)(client + metin2client::SendBattlePacked);
void* pNetStream = Addresses::iNetworkStreamInstance();
if (!pNetStream || !SendPacket)
return false;
SendPacket(pNetStream, dwAttack, dwVID);
return true;
}
catch (...)
{
return false;
}
}
static Vector3 NEW_GetPixelPosition(Vector3* pOut, int count)
{
try
{
if (count < 0 || count >= 331)
{
if (pOut)
*pOut = Vector3{ 0.f, 0.f, 0.f };
return { 0.f, 0.f, 0.f };
}
Vector3 vector = {
c_entity[count].x,
-c_entity[count].y,
c_entity[count].z
};
if (pOut)
*pOut = vector;
return vector;
}
catch (...)
{
if (pOut)
*pOut = Vector3{ 0.f, 0.f, 0.f };
return Vector3{ 0.f, 0.f, 0.f };
}
}
bool NetworkStreamSendCharacterStatePacket(const Vector3& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{
try
{
typedef void(__thiscall* SendCharacterState)(void* pInstance, const Vector3& kPos, float z, UINT eFunc, UINT uArg);
static SendCharacterState Send = (SendCharacterState)(client + 0x87EF0);
void* NetworkStream = *(void**)(client + 0x2F56AC);
Send(NetworkStream, c_rkPPosDst, fDstRot, eFunc, uArg);
return true;
}
catch (...)
{
return false;
}
}
float CalculateRotation(const Vector3& from, const Vector3& to)
{
float dx = to.x - from.x;
float dy = to.y - from.y;
float angle = atan2f(dy, dx);
return angle;
}
std::vector<Vector3> DivideTwoPointsByDistance(float distance, const Vector3& start, const Vector3& end)
{
std::vector<Vector3> path;
float dx = end.x - start.x;
float dy = end.y - start.y;
float dz = end.z - start.z;
float totalDist = sqrtf(dx * dx + dy * dy + dz * dz);
if (totalDist < distance)
{
path.push_back(end);
return path;
}
int steps = static_cast<int>(totalDist / distance);
for (int i = 1; i <= steps; ++i)
{
float t = static_cast<float>(i) / steps;
Vector3 p = {
start.x + dx * t,
start.y + dy * t,
start.z + dz * t
};
path.push_back(p);
}
return path;
}
bool Range = true;
int Yürüme = 1;
DWORD WINAPI swordwait(HMODULE hModule)
{
while (true)
{
for (int i = 0; i < 331; i += 4) {
if (c_entity.Type == 0)
{
DWORD C_VID = c_entity.VID;
if (C_VID != 0)
{
Vector3 oldPosition;
Gamepacked::InstanceBaseNEW_GetPixelPosition(&oldPosition);
Vector3 newPosition;
Gamepacked::InstanceBaseNEW_GetPixelPosition(&oldPosition);
Gamepacked::NEW_GetPixelPosition(&newPosition,i);
if (Range)
{
std::vector< Vector3> distancePoints = DivideTwoPointsByDistance(Yürüme, oldPosition, newPosition);
int i = 0;
for (std::vector<Vector3>::iterator it = distancePoints.begin(); it != distancePoints.end(); ++it)
{
NetworkStreamSendCharacterStatePacket(Vector3{ it->x, it->y, it->z }, 0, 0, 0);
i++;
}
}
Gamepacked::NetworkStreamSendAttackPacket(0, C_VID);
if (Range)
{
std::vector< Vector3> distancePoints = DivideTwoPointsByDistance(Yürüme, oldPosition, newPosition);
int i = 0;
for (std::vector<Vector3>::iterator it = distancePoints.begin(); it != distancePoints.end(); ++it)
{
NetworkStreamSendCharacterStatePacket(Vector3{ it->x, it->y, it->z }, 0, 0, 0);
i++;
}
}
}
Sleep(1);
}
}
}
return 0;
}
extern "C" BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
if (ul_reason_for_call == DLL_PROCESS_ATTACH)
{
DisableThreadLibraryCalls(hModule);
if (Beep(200, 200))
{
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)swordwait, 0, 0, 0);
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ConsoleMain, 0, 0, 0);
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)MemoryManager, 0, 0, 0);
}
}
return TRUE;
}
extern "C" __declspec(dllexport) int Nethan2(int code, WPARAM wParam, LPARAM lParam) {
return CallNextHookEx(NULL, code, wParam, lParam);
}
[/CODE]
Metin2 de efsanelesmis ve forumlarda yada baska kaynaklarda bulunmayan wait range source sizlerle simdiden kullanıcak arkadaşlara teşşekürlerimi iletirim
unutmayın kimse söylemedigi icin yada kimse birsey ögretmek istemedigi icin paylasımlarımı gerceklestiriyorumisterseniz bunun ninja sı da gelir
konularımdan menülerimide indire bilirsiniz
https://forum.turkmmo.com/konu/3918762-c-metin2-internal-imgui-source/https://forum.turkmmo.com/konu/3917903-c-imgui-bot-ui-source/https://forum.turkmmo.com/konu/3916811-hammermt2-eski-basit-ws-lik-hile/https://forum.turkmmo.com/konu/3916809-areaui-eski-basit-farm-bot-source/https://forum.turkmmo.com/konu/3879250-metin2-basit-waithack/
arada dağlar duvarlar olduğu zaman oyundan atıyor. veyahut nehrin karşısındaki moblar vs. bunlar için nasıl çözüm üretebiliriz?
