Гайд GAME HACKING - Создаём первый чит

[void pSilent]

CS:GO - Это игра, в которой нельзя просто взять и найти оффсеты, нужно более глубокое познание, поэтому все указатели я советую брать с гитхаба hazedumper:

Пожалуйста, авторизуйтесь для просмотра ссылки.

Окей, давайте приступим)
Сначала очистим наш старый код, не удаляя static Memory mem.

Начинаем писать наш GLOW ESP:

Добавляем Оффсеты:
Код:
public static int bClient;
public static int oLocalPlayer = 0xAAAFEC;
public static int oEntityList = 0x4A87504;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA44E0;
public static int oGlowIndex = 0xA320;

После каждой обновы CS:GO их надо будет обновлять. Если у вас не получается, то можете попросить помощь у меня на форуме или в вк)
https://vk.com/blazer2k

Добавим цвета для вх:
Код:
static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;
Теперь добавим структуру самого вх:
Код:
public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}
Добавляем внедрение в процесс:
Код:
private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

Теперь самое главное, добавляем метод самого вх:
Код:
private static void Draw(int pGlowIn, GlowStructure col)

{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}
Теперь идём в Main, вставляем туда главную логическую часть:
Код:
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
Ещё раз всё проверим, посмотрим на конечный вариант:
Код:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace yougame_biz
{
class Program
{
static Memory mem;

public static int bClient;
public static int oLocalPlayer = 0xAA9F4C;
public static int oEntityList = 0x4A86424;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA33D8;
public static int oGlowIndex = 0xA320;

static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;

public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}

private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

private static void Draw(int pGlowIn, GlowStructure col)
{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}

static void Main(string[] args)
{
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
}
}
}
Теперь самое интересное, грузимся на карту, запускаем наш чит, видим результат:

Базовая часть по созданию читов закончена.

 

[GoGi1337]

переоформи тему. На читабельный вид.

 

[BurundukGEGE]

Найс личка в вк закрыта ы

 

[hoope]

каг жы ахуенна делать Ыкстернал четы с ноля)0))00)

 

[mirniy666sex]

CS:GO - Это игра, в которой нельзя просто взять и найти оффсеты, нужно более глубокое познание, поэтому все указатели я советую брать с гитхаба hazedumper:

Пожалуйста, авторизуйтесь для просмотра ссылки.

Окей, давайте приступим)
Сначала очистим наш старый код, не удаляя static Memory mem.

Начинаем писать наш GLOW ESP:

Добавляем Оффсеты:
Код:
public static int bClient;
public static int oLocalPlayer = 0xAAAFEC;
public static int oEntityList = 0x4A87504;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA44E0;
public static int oGlowIndex = 0xA320;

После каждой обновы CS:GO их надо будет обновлять. Если у вас не получается, то можете попросить помощь у меня на форуме или в вк)
https://vk.com/blazer2k

Добавим цвета для вх:
Код:
static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;
Теперь добавим структуру самого вх:
Код:
public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}
Добавляем внедрение в процесс:
Код:
private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

Теперь самое главное, добавляем метод самого вх:
Код:
private static void Draw(int pGlowIn, GlowStructure col)

{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}
Теперь идём в Main, вставляем туда главную логическую часть:
Код:
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
Ещё раз всё проверим, посмотрим на конечный вариант:
Код:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace prime_coding
{
class Program
{
static Memory mem;

public static int bClient;
public static int oLocalPlayer = 0xAA9F4C;
public static int oEntityList = 0x4A86424;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA33D8;
public static int oGlowIndex = 0xA320;

static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;

public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}

private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

private static void Draw(int pGlowIn, GlowStructure col)
{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}

static void Main(string[] args)
{
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
}
}
}
Теперь самое интересное, грузимся на карту, запускаем наш чит, видим результат:
http://************.pro/data/MetaMirrorCache/puu.sh_weBlm_2eec2b7093.jpg

Базовая часть по созданию читов закончена.

Как сказал @GoGi, переоформи тему, точнее вид самого кода
Можешь вставить в цитату, либо же сторонние сайты, где можно выбрать язык, на котором был написан софт

 

[ikfakof]

Хороший гайд, продалжай!

 

[kodak black]

для кого

 

[henken]

Поправь картинку, не вижу ее

 

[Quadro1337]

Опять уроки от шок байта

 

[GOVARD]

Если я увижу ещё одну тему от тебя с того блядского форума - улетишь в бан.

 

[II4eJla]

CS:GO - Это игра, в которой нельзя просто взять и найти оффсеты, нужно более глубокое познание, поэтому все указатели я советую брать с гитхаба hazedumper:

Пожалуйста, авторизуйтесь для просмотра ссылки.

Окей, давайте приступим)
Сначала очистим наш старый код, не удаляя static Memory mem.

Начинаем писать наш GLOW ESP:

Добавляем Оффсеты:
Код:
public static int bClient;
public static int oLocalPlayer = 0xAAAFEC;
public static int oEntityList = 0x4A87504;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA44E0;
public static int oGlowIndex = 0xA320;

После каждой обновы CS:GO их надо будет обновлять. Если у вас не получается, то можете попросить помощь у меня на форуме или в вк)
https://vk.com/blazer2k

Добавим цвета для вх:
Код:
static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;
Теперь добавим структуру самого вх:
Код:
public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}
Добавляем внедрение в процесс:
Код:
private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

Теперь самое главное, добавляем метод самого вх:
Код:
private static void Draw(int pGlowIn, GlowStructure col)

{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}
Теперь идём в Main, вставляем туда главную логическую часть:
Код:
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
Ещё раз всё проверим, посмотрим на конечный вариант:
Код:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace yougame_biz
{
class Program
{
static Memory mem;

public static int bClient;
public static int oLocalPlayer = 0xAA9F4C;
public static int oEntityList = 0x4A86424;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA33D8;
public static int oGlowIndex = 0xA320;

static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;

public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}

private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

private static void Draw(int pGlowIn, GlowStructure col)
{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}

static void Main(string[] args)
{
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
}
}
}
Теперь самое интересное, грузимся на карту, запускаем наш чит, видим результат:

Базовая часть по созданию читов закончена.

а не проще скачать сурсы андефа? а

 

[Billy]

Подскажите пожалуйста , как обновления оффсеты подобного типа? Или я хз что ито ваще. Или это вообще не надо обновлять?

 

[justzloy]

Подскажите пожалуйста , как обновления оффсеты подобного типа? Или я хз что ито ваще. Или это вообще не надо обновлять?

В тгф'е авто-обновление оффсетов по паттерну.

 

[Billy]

В тгф'е авто-обновление оффсетов по паттерну.

Но это не ТГФ , я просто понять не могу что это такое , надо ли там менять что-то и т.д

 

[Крайслер]

CS:GO это как раз та игра, где не нужно напрягатся с обновлением\поиском и кодом...

 

[un_h]

CS:GO - Это игра, в которой нельзя просто взять и найти оффсеты, нужно более глубокое познание, поэтому все указатели я советую брать с гитхаба hazedumper:

Пожалуйста, авторизуйтесь для просмотра ссылки.

Окей, давайте приступим)
Сначала очистим наш старый код, не удаляя static Memory mem.

Начинаем писать наш GLOW ESP:

Добавляем Оффсеты:
Код:
public static int bClient;
public static int oLocalPlayer = 0xAAAFEC;
public static int oEntityList = 0x4A87504;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA44E0;
public static int oGlowIndex = 0xA320;

После каждой обновы CS:GO их надо будет обновлять. Если у вас не получается, то можете попросить помощь у меня на форуме или в вк)
https://vk.com/blazer2k

Добавим цвета для вх:
Код:
static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;
Теперь добавим структуру самого вх:
Код:
public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}
Добавляем внедрение в процесс:
Код:
private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

Теперь самое главное, добавляем метод самого вх:
Код:
private static void Draw(int pGlowIn, GlowStructure col)

{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}
Теперь идём в Main, вставляем туда главную логическую часть:
Код:
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
Ещё раз всё проверим, посмотрим на конечный вариант:
Код:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace yougame_biz
{
class Program
{
static Memory mem;

public static int bClient;
public static int oLocalPlayer = 0xAA9F4C;
public static int oEntityList = 0x4A86424;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA33D8;
public static int oGlowIndex = 0xA320;

static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;

public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}

private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

private static void Draw(int pGlowIn, GlowStructure col)
{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}

static void Main(string[] args)
{
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
}
}
}
Теперь самое интересное, грузимся на карту, запускаем наш чит, видим результат:

Базовая часть по созданию читов закончена.

WTF??? Просто скопировал Shok Byte'а и переименовал функции
 

CS:GO - Это игра, в которой нельзя просто взять и найти оффсеты, нужно более глубокое познание, поэтому все указатели я советую брать с гитхаба hazedumper:

Пожалуйста, авторизуйтесь для просмотра ссылки.

Окей, давайте приступим)
Сначала очистим наш старый код, не удаляя static Memory mem.

Начинаем писать наш GLOW ESP:

Добавляем Оффсеты:
Код:
public static int bClient;
public static int oLocalPlayer = 0xAAAFEC;
public static int oEntityList = 0x4A87504;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA44E0;
public static int oGlowIndex = 0xA320;

После каждой обновы CS:GO их надо будет обновлять. Если у вас не получается, то можете попросить помощь у меня на форуме или в вк)
https://vk.com/blazer2k

Добавим цвета для вх:
Код:
static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;
Теперь добавим структуру самого вх:
Код:
public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}
Добавляем внедрение в процесс:
Код:
private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

Теперь самое главное, добавляем метод самого вх:
Код:
private static void Draw(int pGlowIn, GlowStructure col)

{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}
Теперь идём в Main, вставляем туда главную логическую часть:
Код:
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
Ещё раз всё проверим, посмотрим на конечный вариант:
Код:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace yougame_biz
{
class Program
{
static Memory mem;

public static int bClient;
public static int oLocalPlayer = 0xAA9F4C;
public static int oEntityList = 0x4A86424;
public static int oTeamNumber = 0xF0;
public static int oHealth = 0xFC;
public static int oDormant = 0xE9;
public static int oGlowObject = 0x4FA33D8;
public static int oGlowIndex = 0xA320;

static int R = 255;
static int G = 0;
static int B = 255;
static int A = 55;

public struct GlowStructure
{
public float r;
public float g;
public float b;
public float a;
public bool rwo;
public bool rwuo;
}

private static bool GetProcessState(string processName)
{
try
{
Process csgo = Process.GetProcessesByName(processName)[0];

mem = new Memory("csgo");
foreach (ProcessModule module in csgo.Modules)
{
if (module.ModuleName == "client.dll")
bClient = (int)module.BaseAddress;
}
return true;
}
catch
{
return false;
}
}

private static void Draw(int pGlowIn, GlowStructure col)
{
int adress = bClient + oGlowObject;
int GlowObject = mem.Read<int>(adress);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 4), col.r);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 8), col.g);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 12), col.b);
mem.Write<float>((GlowObject + (pGlowIn * 0x38) + 0x10), col.a);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x24), true);
mem.Write<bool>((GlowObject + (pGlowIn * 0x38) + 0x25), false);
}

static void Main(string[] args)
{
while (!GetProcessState("csgo")) { }

while (true)
{
GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

for (int i = 1; i <= 64; i++)
{
int adress = bClient + oLocalPlayer;
int LocalPlayer = mem.Read<int>(adress);

adress = LocalPlayer + oTeamNumber;
int PlayerTeam = mem.Read<int>(adress);

adress = bClient + oEntityList + (i - 1) * 0x10;
int EntityList = mem.Read<int>(adress);

adress = EntityList + oTeamNumber;
int HisTeam = mem.Read<int>(adress);

adress = EntityList + oDormant;
int isDormant = mem.Read<int>(adress);

if (HisTeam != 0 && isDormant != 1)
{
adress = EntityList + oGlowIndex;
int GlowIndex = mem.Read<int>(adress);
adress = EntityList + oHealth;
float HP = mem.Read<int>(adress) / 100f;
if (HisTeam != PlayerTeam && PlayerTeam != 1)
{
Draw(GlowIndex, Enemy);
}
else
{

}
}
}

Thread.Sleep(1);
}
}
}
}
Теперь самое интересное, грузимся на карту, запускаем наш чит, видим результат:

Базовая часть по созданию читов закончена.

И да зачем ты в while(true) добавил это:?

GlowStructure Enemy = new GlowStructure()
{
r = R / 100f,
g = G / 100f,
b = B / 100f,
a = A / 100f,

rwo = false,
rwuo = false
};

 

[555x7]

Оформи, а так найс

 

[P45H3]

Не лучшая идея делать экстернал глов на шарпе

 

[anmly]

Много лишнего, можно проще сделать.