Csgox55

csgox55
#include “CSGO.h”
#include “Vector.h”
#include “MD5_CheckSum.h”
#include “CRC32_CheckSum.h”
#include “cDraw.h”
#include “Mathematics.h”
#include “hMenu.h”
#include “SDK.h”

#pragma warning(disable: 4244)
#pragma warning(disable: 4305)
csgox55 informational csgox55
#pragma warning(disable: 4996)
#pragma warning(disable: 4715)
#pragma warning(disable: 4244)
#pragma warning(disable: 4008)
#pragma warning(disable: 4101)
#pragma warning(disable: 4409)
#pragma warning(disable: 4804)

bool showMenu = false;
csgox55 csgox55
//Aiden “why dont you just call it water mark” Truix “Thats some casual shit my nigga”
bool Nigga = false;
bool Nigga2 = false;
int selectedItem = 0;
int maxItems = 9;
char menuItems[9][32] = { “Box ESP”, “Health ESP”, “Name ESP”, “SteamID ESP”, “Rank ESP”, “Display Wins”, “Enemy Only”, “BunnyHop”, “Auto Pistol”,};
bool menuEnabled[9] = { false, false, false, false, false, false, false, false, false};

namespace CSGO
{
csgox55 csgox55
void VectorNormalizeFast(Vector& vec)
{
Assert(s_bMathlibInitialized);

float iradius = 1.f / (sqrtf(vec.x*vec.x + vec.y*vec.y + vec.z*vec.z) + FLT_EPSILON);

vec.x *= iradius;
vec.y *= iradius;
vec.z *= iradius;
}
csgox55 check more csgox55

void VectorAngles(const Vector &forward, QAngle &angles)
{
Assert(s_bMathlibInitialized);

Vector left;

CrossProduct(forward, left);
VectorNormalizeFast(left);

csgox55 informational csgox55
float xyDist = sqrtf(forward[0] * forward[0] + forward[1] * forward[1]);

if (xyDist > 0.001f)
{
angles[1] = RAD2DEG(atan2f(forward[1], forward[0]));
angles[0] = RAD2DEG(atan2f(-forward[2], xyDist));
float up_z = (left[1] * forward[0]) – (left[0] * forward[1]);
angles[2] = RAD2DEG(atan2f(left[2], up_z));
}
else
csgox55 csgox55
{
angles[0] = RAD2DEG(atan2f(-forward[2], xyDist));
angles[2] = 0;
}
}

float AngleNormalize(float angle)
{
angle = fmodf(angle, 360.0f);
if (angle > 180)
csgox55 informational csgox55
{
angle -= 360;
}
if (angle x = cp*cy;
forward->y = cp*sy;
forward->z = -sp;
}

if (right)
{
right->x = (-1 * sr*sp*cy + -1 * cr*-sy);
right->y = (-1 * sr*sp*sy + -1 * cr*cy);
csgox55 check more csgox55
right->z = -1 * sr*cp;
}

if (up)
{
up->x = (cr*sp*cy + -sr*-sy);
up->y = (cr*sp*sy + -sr*cy);
up->z = cr*cp;
}
}
csgox55 csgox55

void VectorAngles(const Vector &forward, const Vector &pseudoup, QAngle &angles)
{
Assert(s_bMathlibInitialized);

Vector left;

CrossProduct(pseudoup, forward, left);
VectorNormalizeFast(left);

csgox55 informational csgox55
float xyDist = sqrtf(forward[0] * forward[0] + forward[1] * forward[1]);

if (xyDist > 0.001f)
{
angles[1] = RAD2DEG(atan2f(forward[1], forward[0]));
angles[0] = RAD2DEG(atan2f(-forward[2], xyDist));
float up_z = (left[1] * forward[0]) – (left[0] * forward[1]);
angles[2] = RAD2DEG(atan2f(left[2], up_z));
}
else
csgox55 check more csgox55
{
angles[1] = RAD2DEG(atan2f(-left[0], left[1]));
angles[0] = RAD2DEG(atan2f(-forward[2], xyDist));
angles[2] = 0;
}
}

void NormalizeAngles(QAngle &angle)
{
for (int axis = 0; axis 180.f)
{
angle[axis] -= 360.f;
}

while (angle[axis] < -180.f)
{
angle[axis] += 360.f;
}
csgox55 informational csgox55
}
}

float VectorLengthNew(const float *v)
{
return (float)sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
}

void MakeVector(QAngle angle, QAngle& vector)
{
csgox55 informational csgox55
float pitch;
float yaw;
float tmp;

pitch = (float)(angle[0] * M_PI / 180.f);
yaw = (float)(angle[1] * M_PI / 180.f);
tmp = (float)cos(pitch);

vector[0] = (float)(-tmp * -cos(yaw));
vector[1] = (float)(sin(yaw)*tmp);
csgox55 best of csgox55
vector[2] = (float)-sin(pitch);
}

float GetFOV(Vector src, Vector dst, QAngle angle)
{
QAngle ang, aim;
float fov;

Vector dir = dst – src;
VectorNormalizeFast(dir);
csgox55 best of csgox55
VectorAngles(dir, ang);
NormalizeAngles(ang);

MakeVector(angle, aim);
NormalizeAngles(aim);

MakeVector(ang, ang);
NormalizeAngles(ang);

float mag_s = AngleNormalize(sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2])));
csgox55 informational csgox55
float mag_d = AngleNormalize(sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2])));

float u_dot_v = AngleNormalize(aim[0] * ang[0] + aim[1] * ang[1] + aim[2] * ang[2]);

fov = AngleNormalize(acos(u_dot_v / (mag_s*mag_d)) * (180.f / M_PI));

return fov;
}

csgox55 informational csgox55
#define IA 16807
#define IM 2147483647
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define MAX_RANDOM_RANGE 0x7FFFFFFFUL

#define AM (1.0/IM)
#define EPS 1.2e-7
csgox55 informational csgox55
#define RNMX (1.0-EPS)

int m_idum;
int m_iy;
int m_iv[NTAB];

void SetSeed(int iSeed)
{
m_idum = ((iSeed < 0) ? iSeed : -iSeed);
m_iy = 0;
csgox55 check more csgox55
}

int GenerateRandomNumber()
{
int j;
int k;

if (m_idum <= 0 || !m_iy)
{
if (-(m_idum) = 0; j–)
{
k = (m_idum) / IQ;
m_idum = IA * (m_idum – k * IQ) – IR * k;
if (m_idum < 0) m_idum += IM;
if (j < NTAB) m_iv[j] = m_idum;
}
m_iy = m_iv[0];
csgox55 informational csgox55
}
k = (m_idum) / IQ;
m_idum = IA * (m_idum – k * IQ) – IR * k;
if (m_idum RNMX) fl = RNMX;
return (fl * (flHigh – flLow)) + flLow;
}

float curtime;

csgox55 informational csgox55
CHLCLient* m_pClient;
CEngineClient* m_pEngine;
CMatSystemSurface* m_pSurface;
VPanelWrapper* m_pPanel;
CClientEntityList* m_pEntList;
CTrace* m_pEngineTrace;
CIVDebugOverlay* m_pDebugOverlay;
CModelInfo* m_pModelInfo;
CMaterialSystem* m_pMatSystem;
CModelRender* m_pModelRender;
csgox55 csgox55
CRenderView* m_pRenderView;
IPhysicsSurfaceProps *m_pPhysics;
CInput* m_pInput;

HMODULE m_hClient = NULL;
HMODULE m_hEngine = NULL;
HMODULE m_hVphysics = NULL;
HMODULE m_hVstLib = NULL;
HMODULE m_hMaterialSystem = NULL;
HMODULE m_hVGUI2 = NULL;
csgox55 check more csgox55
HMODULE m_hVGUI = NULL;

CreateInterface_t m_pEngineFactory = NULL;
CreateInterface_t m_pClientFactory = NULL;
CreateInterface_t m_pVGUIFactory = NULL;
CreateInterface_t m_pVGUI2Factory = NULL;
CreateInterface_t m_pVPhysics = NULL;
CreateInterface_t m_pMatSystemFactory = NULL;

ScreenSize_t ScreenSize;
csgox55 informational csgox55

unsigned long IFont;
unsigned long IFontMark;
unsigned long IFontL$;
unsigned long IFontMenu;

FORCEINLINE __declspec (naked) DWORD_PTR GetEBP(void)
{
__asm
{
csgox55 informational csgox55
mov eax, ebp
retn
}
}

CBaseCombatWeapon* GetBaseCombatWeapon(CBaseEntity* pEntity)
{
EHANDLE hHandle = (EHANDLE)*(PDWORD)((DWORD)pEntity + 0x12C0);
CBaseCombatWeapon* pWeapon = (CBaseCombatWeapon*)m_pEntList->GetClientEntityFromHandle(hHandle);
return pWeapon;
csgox55 informational csgox55
}

int GetWeaponId(CBaseCombatWeapon* pWeapon)
{
typedef int(__thiscall* GetWeapodIdFn)(PVOID);
GetWeapodIdFn WeapodId = (GetWeapodIdFn)((*(PDWORD*)pWeapon)[432]);
return WeapodId(pWeapon);
}

const char *GetWeaponAlias(int ID)
csgox55 best of csgox55
{
typedef const char* (*WeaponIDToAlias_t)(int ID);
WeaponIDToAlias_t WeaponIDToAlias = ((WeaponIDToAlias_t)0x0);
return WeaponIDToAlias(ID);
}

/*void NoRecoil(CUserCmd *pCmd, CBaseEntity *pLocalPlayer)
{
QAngle PunchAngle = pLocalPlayer->GetPunchAngle();
pCmd->viewangles -= PunchAngle * 2.f; // should work
csgox55 csgox55

}*/

void VectorAnglesNew(const float *forward, float *angles)
{
float tmp, yaw, pitch;

if (forward[1] == 0 && forward[0] == 0)
{
yaw = 0;
csgox55 informational csgox55
if (forward[2] > 0)
pitch = 270;
else
pitch = 90;
}
else
{
yaw = (atan2(forward[1], forward[0]) * 180 / M_PI);
if (yaw < 0)
yaw += 360;
csgox55 csgox55

tmp = sqrt(forward[0] * forward[0] + forward[1] * forward[1]);
pitch = (atan2(-forward[2], tmp) * 180 / M_PI);
if (pitch = 0; –axis)
{
while (angle[axis] > 180.f)
{
angle[axis] -= 360.f;
}
csgox55 check more csgox55

while (angle[axis] GetClientEntity(m_pEngine->GetLocalPlayer());
csgox55 check more csgox55

ray.Init(vecAbsStart, vecAbsEnd);
m_pEngineTrace->TraceRay(ray, 0x4600400B, &filter, &tr);

return (tr.m_pEnt == pBaseEnt || tr.fraction > 0.99f);
}

void NormalizeQGayAngle(QAngle& angle) //plss no untrusted
{
for (int axis = 0; axis 180.f)
{
angle[axis] -= 360.f;
}

while (angle[axis] 89.0f)
qaAng.x = 89.0f;

if (qaAng.x 180)
qaAng.y = 180;

if (qaAng.y GetMethodAddress(21);

_asm
csgox55 check more csgox55
{
PUSH active
PUSH input_sample_frametime
PUSH sequence_number
CALL dwOriginalCreateMoveVMT
}

if (!m_pEngine->IsConnected() && !m_pEngine->IsInGame()) return;

CInput::CVerifiedUserCmd* pVerified = *(CInput::CVerifiedUserCmd**)((DWORD)m_pInput + 0xF0);
csgox55 check more csgox55
if (!pVerified) return;

pVerified = &pVerified[sequence_number % 150];
CUserCmd* pCmd = m_pInput->GetUserCmd(0, sequence_number);
if (!pCmd || !pVerified) return;

CBaseEntity *pLocal = m_pEntList->GetClientEntity(m_pEngine->GetLocalPlayer());

if (!pLocal)
return;
csgox55 informational csgox55

bSendPackets = true;

//get my gun
CBaseCombatWeapon* Weapon = GetBaseCombatWeapon(pLocal);

//NoRecoil(pCmd, pLocal);

#pragma region Bunnyhop
csgox55 informational csgox55
if (menuEnabled[7])
{

if ((pLocal->GetWaterLevel() >= 2) || (pLocal->GetMoveType() == MOVETYPE_LADDER))
{
if (pCmd->buttons & IN_JUMP)
{
pCmd->buttons |= IN_JUMP;
}
else
csgox55 informational csgox55
{
pCmd->buttons &= ~IN_JUMP;
}
}

if (pCmd->buttons & IN_JUMP)
{
if (pLocal->GetFlags() & FL_ONGROUND)
{
pCmd->buttons |= IN_JUMP;
csgox55 informational csgox55
}
else
{
pCmd->buttons &= ~IN_JUMP;
}
}

}
#pragma endregion

csgox55 csgox55
#pragma region AutoPistol
if (menuEnabled[8])
{
if (pCmd->buttons & IN_ATTACK)
{
static bool bAttack = false;
if (bAttack) pCmd->buttons |= IN_ATTACK;
else
pCmd->buttons &= ~IN_ATTACK;
bAttack = !bAttack;
csgox55 best of csgox55
}
}
#pragma endregion

#pragma region Triggerbot
if (GetAsyncKeyState(0x06)){

//if im not connected to server or ingame
if (!m_pEngine->IsConnected() && !m_pEngine->IsInGame()) return;
csgox55 best of csgox55

//get local player id
CBaseEntity *LocalPlayer = (CBaseEntity*)m_pEntList->GetClientEntity(m_pEngine->GetLocalPlayer());

//define some variables
Vector vEnd, direction, right, up;
QAngle qAngle = pCmd->viewangles;
CTrace::trace_t tr;
CTrace::Ray_t ray;
CTrace::CTraceFilter filter;
csgox55 check more csgox55

//set filter to skip myself (not really needed for triggerbot but ima thug…) / Retard
filter.pSkip = m_pEntList->GetClientEntity(m_pEngine->GetLocalPlayer());

//convert viewangles to vector
AngleVectors(qAngle, &vEnd, &right, &up);

//calculate endpoint
vEnd = vEnd* 8192.0f + LocalPlayer->GetEyePosition();

csgox55 check more csgox55
//initialize raytrace
ray.Init(LocalPlayer->GetEyePosition(), vEnd);

//shoot the ray
m_pEngineTrace->TraceRay(ray, CONTENTS_SOLID | CONTENTS_GRATE | CONTENTS_HITBOX, &filter, &tr);

//check of the person were aiming at is on our team
if (tr.m_pEnt->GetTeamNum() != LocalPlayer->GetTeamNum()){
//hit any hitbox
if (tr.hitgroup 0){
csgox55 informational csgox55
pCmd->buttons |= IN_ATTACK;
}
//headONLY
//if (tr.hitgroup == 1){
// pCmd->buttons |= IN_ATTACK;
//}
}
}
#pragma endregion

csgox55 best of csgox55

NormalizeQGayAngle(pCmd->viewangles);
ClampAngle(pCmd->viewangles);
pVerified->m_cmd = *pCmd;
pVerified->m_crc = pCmd->GetChecksum();
//pVerified->m_cmd = *pCmd;
//pVerified->m_crc = CRC32_ProcessSingleBuffer(&pVerified->m_cmd, sizeof(CUserCmd));
}
#pragma endregion

csgox55 informational csgox55
#pragma region PaintTaverse
//paint traverse hook for visuals
VOID WINAPI hkPaintTraverse(int vguiPanel, bool forceRepaint, bool allowForce)
{
static DWORD dwOriginalPaintTraverseVMT = g_pPaintTraverseVMTHook->GetMethodAddress(41);

_asm
{
PUSH allowForce
PUSH forceRepaint
csgox55 informational csgox55
PUSH vguiPanel
MOV ECX, m_pPanel
CALL dwOriginalPaintTraverseVMT
}

DO_ONCE(IFont = m_pSurface->CreateFont(); m_pSurface->SetFontGlyphSet(IFont, “VISTOR TT2 (BRK)”, 12, 450, 0, 0, 0x200);
IFontMark = m_pSurface->CreateFont(); m_pSurface->SetFontGlyphSet(IFontMark, “Tahoma”, 17, 450, 0, 0, 0x200);
IFontL$ = m_pSurface->CreateFont(); m_pSurface->SetFontGlyphSet(IFontL$, “VISTOR TT2 (BRK)”, 70, 450, 0, 0, 0x200);
IFontMenu = m_pSurface->CreateFont(); m_pSurface->SetFontGlyphSet(IFontMenu, “VISTOR TT2 (BRK)”, 17, 450, 0, 0, 0x200););

csgox55 csgox55
//get game resolution
m_pEngine->GetScreenSize(ScreenSize.m_iWidth, ScreenSize.m_iHeight);

if (!strcmp(m_pPanel->GetName(vguiPanel), “MatSystemTopPanel”))
{
int ScreenX, ScreenY;
m_pEngine->GetScreenSize(ScreenX, ScreenY);

if (!m_pEngine->IsConnected() && !m_pEngine->IsInGame()) return;
csgox55 best of csgox55

CBaseEntity *LocalPlayer = (CBaseEntity*)m_pEntList->GetClientEntity(m_pEngine->GetLocalPlayer());

//loop for active player entites
for (int i_Player = 0; i_Player GetLocalPlayer()) continue;

CBaseEntity *targetEntity = m_pEntList->GetClientEntity(i_Player);

csgox55 best of csgox55
if (targetEntity == 0) continue;

//if team is equal to mine exit the loop
if (menuEnabled[6])
{
if (targetEntity->GetTeamNum() == LocalPlayer->GetTeamNum()) continue;
}

//===================================================================================================
csgox55 informational csgox55
static int iRankOffset = 0x1a38;

static DWORD dwForPlayerResource = NULL;

if (dwForPlayerResource == NULL)
dwForPlayerResource = Memory::FindPatternAlt(“client.dll”, (PBYTE)”x55x8BxECx83xE4xF8x81xECx00x00x00x00x83x3Dx00x00x00x00x00x53x56x8BxD9xC7″, “xxxxxxxx????xx?????xxxxx”, NULL, NULL) + 0xE;

DWORD dwPlayerRes = **(PDWORD*)dwForPlayerResource;

int iRank = *(PINT)(dwPlayerRes + iRankOffset + i_Player * 4);
csgox55 informational csgox55

char m_szPrintName[100];
switch (iRank)
{
case 0:{strcpy(m_szPrintName, “Unranked”); break; }
case 1:{strcpy(m_szPrintName, “Silver I”); break; }
case 2:{strcpy(m_szPrintName, “Silver II”); break; }
case 3:{strcpy(m_szPrintName, “Silver III”); break; }
case 4:{strcpy(m_szPrintName, “Silver IV”); break; }
case 5:{strcpy(m_szPrintName, “Silver Elite”); break; }
csgox55 check more csgox55
case 6:{strcpy(m_szPrintName, “Silver Elite Master”); break; }
case 7:{strcpy(m_szPrintName, “Gold Nova I”); break; }
case 8:{strcpy(m_szPrintName, “Gold Nova II”); break; }
case 9:{strcpy(m_szPrintName, “Gold Nova III”); break; }
case 10:{strcpy(m_szPrintName, “Gold Nova Master”); break; }
case 11:{strcpy(m_szPrintName, “Master Guardian I”); break; }
case 12:{strcpy(m_szPrintName, “Master Guardian II”); break; }
case 13:{strcpy(m_szPrintName, “Master Guardian Elite”); break; }
case 14:{strcpy(m_szPrintName, “Distinguished Master Guardian”); break; }
case 15:{strcpy(m_szPrintName, “Legendary Eagle”); break; }
csgox55 best of csgox55
case 16:{strcpy(m_szPrintName, “Legendary Eagle Master”); break; }
case 17:{strcpy(m_szPrintName, “Supreme Master First Class”); break; }
case 18:{strcpy(m_szPrintName, “The Global Elite”); break; }
}
//==========================================================================================

//===================================================================================================
static int iWinOffset = 0x1b3c;

csgox55 informational csgox55
static DWORD dwPlayerResource = NULL;

if (dwPlayerResource == NULL)
dwPlayerResource = Memory::FindPatternAlt(“client.dll”, (PBYTE)”x55x8BxECx83xE4xF8x81xECx00x00x00x00x83x3Dx00x00x00x00x00x53x56x8BxD9xC7″, “xxxxxxxx????xx?????xxxxx”, NULL, NULL) + 0xE;

DWORD PlayerRes = **(PDWORD*)dwPlayerResource;

int iWins = *(PINT)(dwPlayerRes + iWinOffset + i_Player * 4);

//==========================================================================================
csgox55 best of csgox55

//if target is alive
if (targetEntity->GetLifeState() == LIFE_ALIVE && !targetEntity->IsDormant())
{
COLORREF GetTeamColor = RGB(255, 255, 255);

Vector TargetPosition = targetEntity->GetAbsOrigin();
Vector TargetEyePosition = targetEntity->GetEyePosition();

Vector VecOrigin, AbsOrigin;
csgox55 check more csgox55

//get player info for each entity
player_info_t PlayerInfo;
if (!m_pEngine->GetPlayerInfo(i_Player, &PlayerInfo)) continue;

//set t esp red
if (targetEntity->GetTeamNum() == 2) GetTeamColor = RGB(255, 125, 0);
//set ct esp blue
if (targetEntity->GetTeamNum() == 3) GetTeamColor = RGB(0, 125, 255);
csgox55 csgox55

if (IsVisible(LocalPlayer->GetEyePosition(), targetEntity->GetEyePosition(), targetEntity))
{
GetTeamColor = RGB(0, 255, 0);
}

if (Draw.WorldToScreen(TargetEyePosition, VecOrigin))
{
if (Draw.WorldToScreen(TargetPosition, AbsOrigin))
{
csgox55 check more csgox55
float Width = 4;
float Height = 8;

int xOffset = (AbsOrigin.y – VecOrigin.y) / Width;
int yOffset = (AbsOrigin.y – VecOrigin.y) / Height;

int leftX = VecOrigin.x – xOffset;
int rightX = VecOrigin.x + xOffset;
int topY = VecOrigin.y – yOffset;
int botY = AbsOrigin.y – VecOrigin.y + (yOffset * 1.9);
csgox55 informational csgox55
int width = rightX – leftX;

if (menuEnabled[0])
{
//esp box outline
Draw.DrawOutlineRect(leftX + 1, topY + 1, width – 2, botY – 2, 0, 0, 0, 255);
Draw.DrawOutlineRect(leftX – 1, topY – 1, width + 2, botY + 2, 0, 0, 0, 255);
//esp box
Draw.DrawOutlineRect(leftX, topY, width, botY, GetRValue(GetTeamColor), GetGValue(GetTeamColor), GetBValue(GetTeamColor), 255);
}
csgox55 informational csgox55

//set esp rgb values by player health
COLORREF GetHealthColor = RGB(15, 161, 0);
if (targetEntity->GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() > 100) GetHealthColor = RGB(255, 255, 255);

//set esp rgb values to rainbow instead of normal – Mark GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() GetHealth() > 100) GetHealthColor2 = RGB(rand() % 255, rand() % 255, rand() % 255);

//set health esp height by player health
float hpsize;

csgox55 best of csgox55
if (targetEntity->GetHealth() > 100)
{
hpsize = 1;
}
else hpsize = (targetEntity->GetHealth() / 100.f);

//healthESP
if (menuEnabled[1])
{
//draw health esp on left side of esp box
csgox55 check more csgox55
Draw.FillRGBA(leftX – 6, topY – 1, 6, botY + 2, 0, 0, 0, 200);
Draw.DrawOutlineRect(leftX – 6, topY – 1, 6, botY + 2, 0, 0, 0, 255);
Draw.FillRGBA(leftX – 5, topY, 4, botY * hpsize, GetRValue(GetHealthColor), GetGValue(GetHealthColor), GetBValue(GetHealthColor), 255);

//draw health esp on Bottom of esp box
//Draw.DrawOutlineRect(leftX, topY + botY + 2, width, 6, 0, 0, 0, 255);
//Draw.FillRGBA(leftX + 1, topY + botY + 3, width * hpwidth – 2, 4, GetRValue(GetHealthColor), GetGValue(GetHealthColor), GetBValue(GetHealthColor), 255);
}

if (menuEnabled[2])
csgox55 informational csgox55
{
//draw player name esp
Draw.PrintText(IFont, false, rightX + 8, topY + 4, 255, 255, 255, 255, PlayerInfo.name);
}

if (menuEnabled[3])
{
//draw player guid(steamid) esp
Draw.PrintText(IFont, false, rightX + 8, topY + 20, 255, 255, 255, 255, PlayerInfo.guid);
}
csgox55 best of csgox55

if (menuEnabled[4])
{
//draw rank esp – Mark 0)
{
selectedItem–;
}
}
else if (GetAsyncKeyState(VK_DOWN) & 1)
csgox55 csgox55
{
if (selectedItem < (maxItems – 1))
{
selectedItem++;
}
}
else if (GetAsyncKeyState(VK_RIGHT) & 1 || GetAsyncKeyState(VK_LEFT) & 1)
{
menuEnabled[selectedItem] = !menuEnabled[selectedItem];
}
csgox55 csgox55
if (showMenu)
{
Draw.FillRGBA(5, 5, 140, 20, 0, 0, 0, 200);
Draw.DrawOutlineRect(5, 5, 140, 20, 0, 0, 0, 255);//outline
Draw.PrintText(IFontMenu, true, 60, 16, 240, rand() % 255, rand() % 255, rand() % 255, "Derpy$m0k3");// LOL
Draw.FillRGBA(5, 25, 140, 228, 1, 0, 0, 200);
Draw.DrawOutlineRect(5, 25, 140, 228, 1, 0, 0, 255);//outline
Draw.PrintText(IFont, false, 5, 252, 240, 240, 250, 255, "HOME Key – Watermark");
Draw.PrintText(IFont, false, 5, 262, 240, 240, 250, 255, "END Key – Credits");
Draw.PrintText(IFont, false, 5, 272, 240, 240, 250, 255, "Mouse Button 5 – Triggerbot");
csgox55 best of csgox55
for (size_t i = 0; i GetHookMethod((DWORD)hkPaintTraverse, 41);
csgox55 best of csgox55

g_pCreateMoveVMTHook = new VTable::Hooking::CVMTHookManager((DWORD**)m_pClient);
g_pCreateMoveVMTHook->GetHookMethod((DWORD)CreateMoveNaked, 21);
}
}
csgox55

Mobile Legends Hack No Survey

Qynoa