private void changeOtherPlayerGlow(int baseClientAddress, GlowStruct team, int entityListAddr)
{
int address = entityListAddr + Utils.glowIndexOffset;
int otherPlayerGlowIndex = vam.ReadInt32((IntPtr)address);
address = baseClientAddress + Utils.glowObjectOffset;
int glowObject = vam.ReadInt32((IntPtr)address);
int calculation = otherPlayerGlowIndex * 0x38 + 0x4;
int current = glowObject + calculation;
vam.WriteFloat((IntPtr)current, team.r);
calculation = otherPlayerGlowIndex * 0x38 + 0x8;
current = glowObject + calculation;
vam.WriteFloat((IntPtr)current, team.g);
calculation = otherPlayerGlowIndex * 0x38 + 0xC;
current = glowObject + calculation;
vam.WriteFloat((IntPtr)current, team.b);
calculation = otherPlayerGlowIndex * 0x38 + 0x10;
current = glowObject + calculation;
vam.WriteFloat((IntPtr)current, team.a);
calculation = otherPlayerGlowIndex * 0x38 + 0x24;
current = glowObject + calculation;
vam.WriteBoolean((IntPtr)current, team.rwo);
calculation = otherPlayerGlowIndex * 0x38 + 0x25;
current = glowObject + calculation;
vam.WriteBoolean((IntPtr)current, team.rwuo);
}
private static void MainThread()
{
GlowStruct GlowRed = new GlowStruct()
{
r = 255,
g = 0f,
b = 0f,
a = 255
};
GlowStruct GlowBlue = new GlowStruct()
{
r = 0f,
g = 0f,
b = 255,
a = 255
};
if (Modules.IsModuleRunning(Modules.ClientDLLName))
{
while (true)
{
if (CLocalPlayer.IsPlaying)
{
GlowESP.RunGlowESPOWALL(GlowRed, GlowBlue, CheatActive);
Thread.Sleep((int)CheatPerf);
}
}
}
}
static void Main(string[] args)
{
foreach (ProcessModule mod in csgo.Modules)
{
if (mod.ModuleName == "client.dll")
{
module = (int)mod.BaseAddress;
}
}
int cur;
int curTeam;
int curGlowIndex;
GlowStruct Team = new GlowStruct()
{
r = 0,
g = 0,
b = 1,
a = 1,
rwo = true,
rwuo = false
};
GlowStruct Enemy = new GlowStruct()
{
r = 1,
g = 0,
b = 0,
a = 1,
rwo = true,
rwuo = false
};
Thread trigger = new Thread(Trigger);
trigger.Start();
Thread bhop = new Thread(Bhop);
bhop.Start();
while (true)
{
LocalPlayer = memory.ReadInt32((IntPtr)(module + Offsets.dwLocalPlayer));
PlayerTeam = memory.ReadInt32((IntPtr)(LocalPlayer + Offsets.m_iTeamNum));
for (int i = 0; i < 64; i++)
{
cur = memory.ReadInt32((IntPtr)(module + Offsets.dwEntityList + i * 0x10));
curTeam = memory.ReadInt32((IntPtr)(cur + Offsets.m_iTeamNum));
curGlowIndex = memory.ReadInt32((IntPtr)(cur + Offsets.m_iGlowIndex));
if (!memory.ReadBoolean((IntPtr)cur + Offsets.m_bDormant))
{
if (curTeam == PlayerTeam)
{
DrawGlow(curGlowIndex, Team);
}
else
{
DrawGlow(curGlowIndex, Enemy);
}
}
}
}
}
/// <summary>
/// Drawing border on player. Wallhack
/// </summary>
/// <param name="rgba">Color</param>
public void SetGlow(RGBA rgba)
{
var glowStruct = new GlowStruct(true, true, false);
//todo: create one struct and use just 1 wpm instead of 2. (add 16bytes junk code)
ManageMemory.WriteMemory <GlowStruct>(BaseMemory.GlowHandle + GlowIndex * 0x38 + 0x24, glowStruct);
ManageMemory.WriteMemory <RGBA>(BaseMemory.GlowHandle + GlowIndex * 0x38 + 0x4, rgba);
}
public static GlowStruct ParseEnemyGlowHealth(int Health)
{
GlowStruct output = new GlowStruct();
output.r = 1.0f - (Health / 100.0f);
output.g = Health / 100.0f;
output.b = 0;
output.a = 1.0f;
return(output);
}
private static void DrawGlow(int glowAddress, GlowStruct colours, ProcessMemory Mem)
{
object objectValue = RuntimeHelpers.GetObjectValue(Mem.ReadInt(dwClient + dwGlowObjectManager));
Mem.WriteFloat(Conversions.ToInteger(Operators.AddObject(objectValue, (glowAddress * 0x38) + 4)), colours.r);
Mem.WriteFloat(Conversions.ToInteger(Operators.AddObject(objectValue, (glowAddress * 0x38) + 8)), colours.g);
Mem.WriteFloat(Conversions.ToInteger(Operators.AddObject(objectValue, (glowAddress * 0x38) + 12)), colours.b);
Mem.WriteFloat(Conversions.ToInteger(Operators.AddObject(objectValue, (glowAddress * 0x38) + 0x10)), colours.a);
Mem.WriteBool(Conversions.ToInteger(Operators.AddObject(objectValue, (glowAddress * 0x38) + 0x24)), colours.rwo);
Mem.WriteBool(Conversions.ToInteger(Operators.AddObject(objectValue, (glowAddress * 0x38) + 0x25)), colours.rwuo);
}
static void DrawGlow(int index, GlowStruct glow)
{
int obj = memory.ReadInt32((IntPtr)(module + Offsets.dwGlowObjectManager));
memory.WriteFloat((IntPtr)(obj + (index * 0x38) + 4), glow.r);
memory.WriteFloat((IntPtr)(obj + (index * 0x38) + 8), glow.g);
memory.WriteFloat((IntPtr)(obj + (index * 0x38) + 12), glow.b);
memory.WriteFloat((IntPtr)(obj + (index * 0x38) + 0x10), 255 / 100f);
memory.WriteBoolean((IntPtr)(obj + (index * 0x38) + 0x24), glow.rwo);
memory.WriteBoolean((IntPtr)(obj + (index * 0x38) + 0x25), glow.rwuo);
}
public static void startGlow()
{
while (true)
{
for (var i = 0; i < 32; i++)
{
int curEnt = Program.Mem.ReadInt(Offsets.baseClient + Offsets.dwEntityList + i * 0x10);
int curTeam = Program.Mem.ReadInt(curEnt + Offsets.m_iTeamNum);
int curDormant = Program.Mem.ReadInt(curEnt + 0xED);
int curGlowIndex = Program.Mem.ReadInt(curEnt + Offsets.m_iGlowIndex);
if (curEnt == LocalPlayer.localBase)
{
continue;
}
if (LocalPlayer.localTeam == curTeam)
{
continue;
}
if (curDormant == 1 || curTeam == 0)
{
continue;
}
GlowStruct Enemy = new GlowStruct()
{
r = 0,
g = 0.5F,
b = 1,
};
Program.Mem.WriteFloat(LocalPlayer.glowBase + (curGlowIndex * 0x38 + 0x4), Enemy.r);
Program.Mem.WriteFloat(LocalPlayer.glowBase + (curGlowIndex * 0x38 + 0x8), Enemy.g);
Program.Mem.WriteFloat(LocalPlayer.glowBase + (curGlowIndex * 0x38 + 0xC), Enemy.b);
Program.Mem.WriteFloat(LocalPlayer.glowBase + (curGlowIndex * 0x38 + 0x10), 0.8f);
Program.Mem.WriteByte(LocalPlayer.glowBase + (curGlowIndex * 0x38 + 0x24), 1);
//RADAR
Program.Mem.WriteMemory <bool>(curEnt + Offsets.m_bSpotted, true);
}
Thread.Sleep(1);
}
}
public static void RunGlowESPLegit(int EntBase, bool Active, GlowStruct TColor, GlowStruct ATColor)
{
int GlowIndex = CylMem.ReadInt(EntBase + m_iGlowIndex);
if (Active)
{
if (CLocalPlayer.isDead)
{
if (CLocalPlayer.Team != CEntityPlayer.Team(EntBase))
{
if (CEntityPlayer.Team(EntBase) == Teams.TERRORIST && CEntityPlayer.isAlive(EntBase)) //T
{
CEntityPlayer.Glow(GlowIndex, TColor, GlowStyle.NORMAL, GlowType.NORMAL);
}
if (CEntityPlayer.Team(EntBase) == Teams.ANTI_TERRORIST && CEntityPlayer.isAlive(EntBase)) //AT
{
CEntityPlayer.Glow(GlowIndex, ATColor, GlowStyle.NORMAL, GlowType.NORMAL);
}
}
}
}
}
public static void RunGlowESPOWALL(GlowStruct red, GlowStruct blue, bool Active)
{
for (int i = 0; i <= EngineClient.MaxPlayer; i++)
{
int EntBase = CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + i * 0x10);
if (EntBase == 0)
{
continue;
}
if (CEntityPlayer.isDormant(EntBase))
{
continue;
}
if (CEntityPlayer.isDead(EntBase))
{
continue;
}
if (CEntityPlayer.Team(EntBase) == Teams.NONE || CEntityPlayer.Team(EntBase) == Teams.SPECTATOR)
{
continue;
}
if (CEntityPlayer.WeaponName(EntBase) == "NONE")
{
continue;
}
int GlowIndex = CylMem.ReadInt(EntBase + m_iGlowIndex);
if (CEntityPlayer.Team(EntBase) == Teams.TERRORIST && Active && CEntityPlayer.isAlive(EntBase)) //T
{
CEntityPlayer.Glow(GlowIndex, red, GlowStyle.NORMAL, GlowType.NORMAL);
}
if (CEntityPlayer.Team(EntBase) == Teams.ANTI_TERRORIST && Active && CEntityPlayer.isAlive(EntBase)) //AT
{
CEntityPlayer.Glow(GlowIndex, blue, GlowStyle.NORMAL, GlowType.NORMAL);
}
}
}
static void Main(string[] args)
{
var handle = GetConsoleWindow();
// Hide
ShowWindow(handle, SW_HIDE);
// Show
//ShowWindow(handle, SW_SHOW);
GlowStruct Enemy = new GlowStruct()
{
r = 1,
g = 0,
b = 0,
a = 0.8f,
rwo = true,
rwuo = false
};
GlowStruct Team = new GlowStruct()
{
r = 0,
g = 0,
b = 1,
a = 0.6f,
rwo = true,
rwuo = false
};
Player MyPlayer = new Player();
Player player = new Player();
Thread mythread = new Thread(TriggrerbotThread);
Thread BHopThread = new Thread(BHop);
Thread menuThread = new Thread(MenuThread);
menuThread.Start();
if (GetModuleAddy())
{
int address;
address = client + oLocalPlayer;
int lPlayer = vam.ReadInt32((IntPtr)address);
// address = client + hazedumper.signatures.force_update_spectator_glow; //0xEB
// vam.WriteByte((IntPtr)address, 0xEB);
BHopThread.Start();
mythread.Start();
while (true)
{
//address = client + hazedumper.signatures.force_update_spectator_glow; //0xEB
// vam.WriteByte((IntPtr)address, 0xEB);
address = client + oGlowObject;
int GlowObject = vam.ReadInt32((IntPtr)address);
address += 0xC;
int objectCount = vam.ReadInt32((IntPtr)address);
int i = 1;
do
{
address = client + oEntityList + (i - 1) * 0x10;
int EntityList = vam.ReadInt32((IntPtr)address);
//Console.WriteLine(EntityList);
if (EntityList != 0 && checkBoxGlow)
{
player = GetMyPlayerInfo(EntityList);
MyPlayer = GetMyPlayerInfo(lPlayer);
if (MyPlayer.Team != player.Team && checkBoxSpotted)
{
vam.WriteBoolean((IntPtr)(EntityList + hazedumper.netvars.m_bSpotted), true);
}
address = EntityList + oDormant;
if (!vam.ReadBoolean((IntPtr)address))
{
address = EntityList + oGlowIndex;
int GlowIndex = vam.ReadInt32((IntPtr)address);
if (MyPlayer.Team == player.Team)
{
if (!checkBoxOnlyEnemy)
{
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, ally.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Team.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Team.rwuo);
}
}
else
{
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, enemy.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Enemy.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Enemy.rwuo);
}
}
}
i++;
//address = client + hazedumper.signatures.force_update_spectator_glow; //0xEB
//vam.WriteByte((IntPtr)address, 0xEB);
}while (i < objectCount);
Thread.Sleep(1);
// address = client + netvars.
// int localbase = vam.ReadInt32((IntPtr)address);
}
}
Console.WriteLine("Press enter to close...");
Console.ReadLine();
}
static void Main()
{
Console.Title = "EAZ Glow - Unknowncheats.me";
MemoryManager.Initialize("csgo");
ClientPointer = MemoryManager.GetModuleAdress("client");
EnginePointer = MemoryManager.GetModuleAdress("engine");
Offsets.ScanPatterns();
var AddressReaderThread = new Thread(AddressReader);
var KeyProcThread = new Thread(KeyProc);
AddressReaderThread.Start();
KeyProcThread.Start();
while (true)
{
for (var i = 0; i < 64; i++)
{
if (Arrays.Entity[i].m_iBase == 0)
{
continue;
}
if (Arrays.Entity[i].m_iBase == LocalPlayer.m_iBase)
{
continue;
}
if (Arrays.Entity[i].m_iHealth < 1)
{
continue;
}
if (Arrays.Entity[i].m_iDormant == 1)
{
continue;
}
GlowStruct GlowObject = new GlowStruct();
if (GlowEnabled != false)
{
if (Arrays.Entity[i].m_iTeam != LocalPlayer.m_iTeam)
{
GlowObject = MemoryManager.ReadMemory <GlowStruct>(LocalPlayer.m_iGlowBase + Arrays.Entity[i].m_iGlowIndex * 0x38);
GlowObject.r = 255 / 255;
GlowObject.g = 0 / 255;
GlowObject.b = 0 / 255;
GlowObject.a = 255 / 255;
GlowObject.m_bRenderWhenOccluded = true;
GlowObject.m_bRenderWhenUnoccluded = false;
GlowObject.m_bFullBloom = false;
MemoryManager.WriteMemory <GlowStruct>(LocalPlayer.m_iGlowBase + Arrays.Entity[i].m_iGlowIndex * 0x38, GlowObject);
}
else
{
GlowObject = MemoryManager.ReadMemory <GlowStruct>(LocalPlayer.m_iGlowBase + Arrays.Entity[i].m_iGlowIndex * 0x38);
GlowObject.r = 0 / 255;
GlowObject.g = 0 / 255;
GlowObject.b = 255 / 255;
GlowObject.a = 255 / 255;
GlowObject.m_bRenderWhenOccluded = true;
GlowObject.m_bRenderWhenUnoccluded = false;
GlowObject.m_bFullBloom = false;
MemoryManager.WriteMemory <GlowStruct>(LocalPlayer.m_iGlowBase + Arrays.Entity[i].m_iGlowIndex * 0x38, GlowObject);
}
}
}
Thread.Sleep(1);
}
}
private static void MainThread()
{
Process[] p = Process.GetProcessesByName("csgo");
foreach (var proc in p)
{
CylMem.OpenProcess(proc.Id);
}
int LocalBase = CylMem.ReadInt(clientModule.moduleAddress + dwLocalPlayer);
int ClientAdress = CylMem.ReadInt(engineModule.moduleAddress + dwClientState);
if (GetModuleAddress())
{
while (true)
{
if (WallActive == true)
{
GlowStruct Terrorist = new GlowStruct()
{
r = 0.254f,
g = 0.236f,
b = 0.124f,
a = 2,
rwo = true,
rwuo = false
};
GlowStruct CTerrorist = new GlowStruct()
{
r = 0.113f,
g = 0.145f,
b = 0.204f,
a = 2,
rwo = true,
rwuo = false
};
int address;
int i = 1;
do
{
address = Client + dwEntityList + (i - 1) * 0x10;
int EntityList = CylMem.ReadInt((int)address);
address = EntityList + m_iTeamNum;
int HisTeam = CylMem.ReadInt((int)address);
address = EntityList + m_bDormant;
if (!CylMem.ReadBool((int)address))
{
address = EntityList + m_iGlowIndex;
int GlowIndex = CylMem.ReadInt((int)address);
if (HisTeam == 2)
{
address = Client + dwGlowObjectManager;
int GlowObject = CylMem.ReadInt((int)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, Terrorist.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, Terrorist.rwuo);
}
else
{
if (WallActive == true)
{
address = Client + dwGlowObjectManager;
int GlowObject = CylMem.ReadInt((int)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, CTerrorist.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, CTerrorist.rwuo);
}
}
}
i++;
} while (i < CylMem.ReadInt(ClientAdress + dwClientState_MaxPlayer));
}
if (aFlashActive)
{
CylMem.WriteFloat(LocalBase + m_flFlashDuration, 0f);
CylMem.WriteFloat(LocalBase + m_flFlashMaxAlpha, 0f);
}
else
{
CylMem.WriteFloat(LocalBase + m_flFlashDuration, 255.0f);
CylMem.WriteFloat(LocalBase + m_flFlashMaxAlpha, 255.0f);
}
if (radarActive)
{
int i = 1;
do
{
int address = Client + dwEntityList + (i - 1) * 0x10;
int EntityList = CylMem.ReadInt((int)address);
CylMem.WriteBoolean(EntityList + m_bSpottedByMask, true);
i++;
} while (i < 20);
}
if (bunnyActive)
{
int LocalFlag = CylMem.ReadInt(LocalBase + m_fFlags);
if (HoldingKey(Keys.Space))
{
if ((LocalFlag == 257 || LocalFlag == 263) /*&& G.Engine.LocalPlayer.Velocity > 10*/)
{
CylMem.WriteInt(clientModule.moduleAddress + dwForceJump, 6);
}
}
}
if (triggerActive)
{
int address = Client + dwLocalPlayer;
int LocalPlayer = CylMem.ReadInt(address);
address = LocalPlayer + m_iTeamNum;
int MyTeam = CylMem.ReadInt(address);
address = LocalPlayer + m_iCrosshairId;
int PlayerInCross = CylMem.ReadInt(address);
if (PlayerInCross > 0 && PlayerInCross < 65)
{
address = Client + dwEntityList + (PlayerInCross - 1) * 0x0000010;
int PtrToPIC = CylMem.ReadInt(address);
address = PtrToPIC + m_iHealth;
int PICHealth = CylMem.ReadInt(address);
address = PtrToPIC + m_iTeamNum;
int PICTeam = CylMem.ReadInt(address);
if ((PICTeam != MyTeam) && (PICTeam > 1) && (PICHealth > 0))
{
for (int i = 0; i < 2; i++)
{
CylMem.WriteInt(dwForceAttack, 1);
Thread.Sleep(10);
CylMem.WriteInt(dwForceAttack, 4);
}
}
}
Thread.Sleep(10);
}
}
}
}
private static void wall()
{
Process[] p = Process.GetProcessesByName("csgo");
foreach (var proc in p)
{
CylMem.OpenProcess(proc.Id);
}
if (GetModuleAddress())
{
while (true)
{
int EngineBase = CylMem.ReadInt(engineModule.moduleAddress + Offsets.bClient);
int GameState = 1;//CylMem.ReadInt(EngineBase + Offsets.aGameChck);
if (GameState != 999)
{
//for (var i = 1; i < 16; ++i)
//{
// int LocalBase = CylMem.ReadInt(clientModule.moduleAddress + Offsets.oLocalPlayer);
// int WeaponHandle = CylMem.ReadInt(LocalBase + 0x2EE8 + (i - 1) * 0x4) & 0xFFF;
// WeaponHandle &= 0xFFF;
// int WeaponEntity = CylMem.ReadInt(clientModule.moduleAddress + 0x4A8574C + (WeaponHandle - 1) * 0x10);
// int WeaponDefIndex = CylMem.ReadInt(WeaponEntity + 0x2F88);
// if (WeaponDefIndex == 40)
// {
// CylMem.WriteInt(WeaponEntity + 0x2F88, 38);
// }
//}
if (WallActive == true)
{
GlowStruct Terrorist = new GlowStruct()
{
r = 0.254f,
g = 0.236f,
b = 0.124f,
a = 2,
rwo = true,
rwuo = false
};
GlowStruct CTerrorist = new GlowStruct()
{
r = 0.113f,
g = 0.145f,
b = 0.204f,
a = 2,
rwo = true,
rwuo = false
};
int address;
int i = 1;
do
{
address = Client + Offsets.oLocalPlayer;
int Player = CylMem.ReadInt((int)address);
address = Player + Offsets.oTeam;
int MyTeam = CylMem.ReadInt((int)address);
address = Client + Offsets.oEntityList + (i - 1) * 0x10;
int EntityList = CylMem.ReadInt((int)address);
address = EntityList + Offsets.oTeam;
int HisTeam = CylMem.ReadInt((int)address);
address = EntityList + Offsets.oDormat;
if (!CylMem.ReadBool((int)address))
{
address = EntityList + Offsets.oGlowIndex;
int GlowIndex = CylMem.ReadInt((int)address);
if (HisTeam == 2)
{
address = Client + Offsets.oGlowObject;
int GlowObject = CylMem.ReadInt((int)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Terrorist.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, Terrorist.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, Terrorist.rwuo);
}
else
{
if (WallActive == true)
{
address = Client + Offsets.oGlowObject;
int GlowObject = CylMem.ReadInt((int)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, CTerrorist.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, CTerrorist.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, CTerrorist.rwuo);
}
}
}
i++;
} while (i < 65);
}
}
}
}
}
public static void DoGlow(ProcessMemory Mem, Entity cEntity, LocalEntity cLocalEntity, float rainbowProgress)
{
Color friTemp = GlowTeamARGB;
Color oppTemp = GlowEnemyARGB;
if (RainbowGlowEnabledOpposition)
{
oppTemp = Rainbow(rainbowProgress);
}
else if (HPToColourEnabledOpposition)
{
oppTemp = HPtoColour(cEntity.Entity_Health);
}
else
{
oppTemp = GlowEnemyARGB;
}
GlowStruct opposition = new GlowStruct
{
r = (float)((oppTemp.R) / 255.0),
g = (float)((oppTemp.G) / 255.0),
b = (float)((oppTemp.B) / 255.0),
a = (float)((GlowAlpha) / 255.0),
rwo = true,
rwuo = false
};
if (RainbowGlowEnabledFriendly)
{
friTemp = Rainbow(rainbowProgress);
}
else if (HPToColourEnabledFriendly)
{
friTemp = HPtoColour(cEntity.Entity_Health);
}
else
{
friTemp = GlowTeamARGB;
}
GlowStruct team = new GlowStruct
{
r = (float)((friTemp.R) / 255.0),
g = (float)((friTemp.G) / 255.0),
b = (float)((friTemp.B) / 255.0),
a = (float)((GlowAlpha) / 255.0),
rwo = true,
rwuo = false
};
if (GlowEnabledOpposition | GlowEnabledFriendly)
{
if (cEntity.Entity_isAlive() && cEntity.Entity_IsDormant)
{
object right = Mem.ReadInt(cEntity.Entity_Base + m_iTeamNum);
if (cEntity.Entity_Team == cLocalEntity.LocalEntity_Team)
{
if (GlowEnabledFriendly)
{
DrawGlow(Conversions.ToInteger(cEntity.Entity_GlowIndex), team, Mem);
}
}
else
{
if (GlowEnabledOpposition)
{
DrawGlow(Conversions.ToInteger(cEntity.Entity_GlowIndex), opposition, Mem);
}
}
}
}
}
//Cheats
public static void wallHack()
{
Process[] p = Process.GetProcessesByName("csgo");
foreach (var proc in p)
{
CylMem.OpenProcess(proc.Id);
}
if (GetModuleAddress())
{
while (true)
{
int EngineBase = CylMem.ReadInt(engineModule.moduleAddress + Offsets.bClient);
int GameState = CylMem.ReadInt(EngineBase + Offsets.aGameChck);
if (GameState == 6)
{
Thread.Sleep(performance);
if (HackStats.wallhack_use)
{
GlowStruct Enemy = new GlowStruct()
{
r = 1f,
g = 0,
b = 0,
a = 0.8f,
rwo = true,
rwuo = false
};
GlowStruct Team = new GlowStruct()
{
r = 0,
g = 0.5f,
b = 255,
a = 0.5f,
rwo = true,
rwuo = false
};
int address;
int i = 1;
do
{
address = Client + Offsets.oLocalPlayer;
int Player = CylMem.ReadInt((int)address);
address = Player + Offsets.oTeam;
int MyTeam = CylMem.ReadInt((int)address);
address = Client + Offsets.oEntityList + (i - 1) * 0x10;
int EntityList = CylMem.ReadInt((int)address);
address = EntityList + Offsets.oTeam;
int HisTeam = CylMem.ReadInt((int)address);
address = EntityList + Offsets.oDormat;
if (!CylMem.ReadBool((int)address))
{
address = EntityList + Offsets.oGlowIndex;
int GlowIndex = CylMem.ReadInt((int)address);
if (MyTeam != HisTeam)
{
address = Client + Offsets.oGlowObject;
int GlowObject = CylMem.ReadInt((int)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Enemy.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Enemy.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Enemy.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
CylMem.WriteFloat((int)current, Enemy.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, Enemy.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
CylMem.WriteBoolean((int)current, Enemy.rwuo);
}
}
i++;
} while (i < 65);
}
}
}
}
}
public void GlowIt()
{
GlowStruct colorsE = new GlowStruct()
{
r = 255.0f,
g = 0f,
b = 0f,
a = 122.5f,
rwo = true,
rwuo = false
};
GlowStruct colorsT = new GlowStruct()
{
r = 0f,
g = 103.0f,
b = 221.0f,
a = 122.5f,
rwo = true,
rwuo = false
};
while (true)
{
if (wallCHCK.Checked)
{
GameState = mem.ReadInt32((IntPtr)EngineBase + Offsets.OffsetList.GameState);
if (GameState == 6)
{
Classes.Global_Functions.Wait(100);
int i = 1;
do
{
int MyTeam = mem.ReadInt32((IntPtr)LocalBase + Offsets.OffsetList.Team);
int EntityList = mem.ReadInt32((IntPtr)ClientAdress + Offsets.OffsetList.EntityList + (i - 1) * 0x10);
int HisTeam = mem.ReadInt32((IntPtr)EntityList + Offsets.OffsetList.Team);
if (!mem.ReadBoolean((IntPtr)EntityList + Offsets.OffsetList.Dormant))
{
if (MyTeam != HisTeam)
{
int GlowIndex = mem.ReadInt32((IntPtr)EntityList + Offsets.OffsetList.GlowIndex);
int GlowObject = mem.ReadInt32((IntPtr)ClientAdress + Offsets.OffsetList.GlowObject);
mem.WriteByte((IntPtr)EntityList + 0x70, (byte)colorsE.r);
mem.WriteByte((IntPtr)EntityList + 0x71, (byte)colorsE.g);
mem.WriteByte((IntPtr)EntityList + 0x72, (byte)colorsE.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x4), colorsE.r);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x8), colorsE.g);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0xC), colorsE.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x10), colorsE.a);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x24), true);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x2C), false);
}
if (MyTeam == HisTeam)
{
int GlowIndex = mem.ReadInt32((IntPtr)EntityList + Offsets.OffsetList.GlowIndex);
int GlowObject = mem.ReadInt32((IntPtr)ClientAdress + Offsets.OffsetList.GlowObject);
mem.WriteByte((IntPtr)EntityList + 0x70, (byte)colorsT.r);
mem.WriteByte((IntPtr)EntityList + 0x71, (byte)colorsT.g);
mem.WriteByte((IntPtr)EntityList + 0x72, (byte)colorsT.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x4), colorsT.r);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x8), colorsT.g);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0xC), colorsT.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x10), colorsT.a);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x24), true);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x2C), false);
}
}
i++;
} while (i < 65);
int thisPtr = EngineBase + Offsets.OffsetList.ModelAmbientMin - 0x2c;
xorBase = Convert.ToInt32(255.0f) ^ thisPtr;
mem.WriteInt32((IntPtr)EngineBase + Offsets.OffsetList.ModelAmbientMin - 0x2c, xorBase);
}
}
}
}
public void ChamIt()
{
GlowStruct colorsE = new GlowStruct()
{
r = 255.0f,
g = 0f,
b = 0f,
a = 122.5f,
rwo = true,
rwuo = false
};
GlowStruct colorsT = new GlowStruct()
{
r = 0f,
g = 103.0f,
b = 221.0f,
a = 155.5f,
rwo = true,
rwuo = false
};
while (true)
{
if (chamCHCK.Checked)
{
GameState = mem.ReadInt32((IntPtr)EngineBase + Offsets.OffsetList.GameState);
if (GameState == 6)
{
int i = 1;
do
{
int MyTeam = mem.ReadInt32((IntPtr)LocalBase + Offsets.OffsetList.Team);
int EntityList = mem.ReadInt32((IntPtr)ClientAdress + Offsets.OffsetList.EntityList + (i - 1) * 0x10);
int HisTeam = mem.ReadInt32((IntPtr)EntityList + Offsets.OffsetList.Team);
if (!mem.ReadBoolean((IntPtr)EntityList + Offsets.OffsetList.Dormant))
{
if (MyTeam != HisTeam)
{
int GlowIndex = mem.ReadInt32((IntPtr)EntityList + Offsets.OffsetList.GlowIndex);
int GlowObject = mem.ReadInt32((IntPtr)ClientAdress + Offsets.OffsetList.GlowObject);
mem.WriteByte((IntPtr)EntityList + 0x70, (byte)colorsE.r);
mem.WriteByte((IntPtr)EntityList + 0x71, (byte)colorsE.g);
mem.WriteByte((IntPtr)EntityList + 0x72, (byte)colorsE.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x4), colorsE.r);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x8), colorsE.g);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0xC), colorsE.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x10), colorsE.a);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x24), true);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x2C), true);
//0x26 -> True -----> FULL BEAM
//0x25 -> False -----> Typical Glow
//0x2C -> True ------> Cool Beam
}
if (MyTeam == HisTeam)
{
int GlowIndex = mem.ReadInt32((IntPtr)EntityList + Offsets.OffsetList.GlowIndex);
int GlowObject = mem.ReadInt32((IntPtr)ClientAdress + Offsets.OffsetList.GlowObject);
mem.WriteByte((IntPtr)EntityList + 0x70, (byte)colorsT.r);
mem.WriteByte((IntPtr)EntityList + 0x71, (byte)colorsT.g);
mem.WriteByte((IntPtr)EntityList + 0x72, (byte)colorsT.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x4), colorsT.r);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x8), colorsT.g);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0xC), colorsT.b);
mem.WriteFloat((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x10), colorsT.a);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x24), true);
mem.WriteBoolean((IntPtr)GlowObject + (GlowIndex * 0x38 + 0x2C), true);
}
}
i++;
} while (i < 65);
}
}
}
}
//
//HACKS
//
public static void dwWallhack()
{
if (GetModuleAddress())
{
while (true)
{
if (HackStats.wallhack_use)
{
GlowStruct Enemy = new GlowStruct()
{
r = 1,
g = 0,
b = 0,
a = 1f,
rwo = true,
rwuo = true
};
GlowStruct Team = new GlowStruct()
{
r = 1,
g = 1,
b = 1,
a = 0.800f,
rwo = true,
rwuo = true
};
int address;
int i = 1;
do
{
address = Client + signatures.dwLocalPlayer;
int Player = vam.ReadInt32((IntPtr)address);
address = Player + netvars.m_iTeamNum;
int MyTeam = vam.ReadInt32((IntPtr)address);
address = Client + signatures.dwEntityList + (i - 1) * 0x10;
int EntityList = vam.ReadInt32((IntPtr)address);
address = EntityList + netvars.m_iTeamNum;
int HisTeam = vam.ReadInt32((IntPtr)address);
address = EntityList + netvars.m_iDormant;
if (!vam.ReadBoolean((IntPtr)address))
{
address = EntityList + netvars.m_iGlowIndex;
int GlowIndex = vam.ReadInt32((IntPtr)address);
if (MyTeam == HisTeam)
{
address = Client + signatures.dwGlowObject;
int GlowObject = vam.ReadInt32((IntPtr)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Team.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Team.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Team.rwuo);
}
else
{
address = Client + signatures.dwGlowObject;
int GlowObject = vam.ReadInt32((IntPtr)address);
int calculation = GlowIndex * 0x38 + 0x4;
int current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.r);
calculation = GlowIndex * 0x38 + 0x8;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.g);
calculation = GlowIndex * 0x38 + 0xC;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.b);
calculation = GlowIndex * 0x38 + 0x10;
current = GlowObject + calculation;
vam.WriteFloat((IntPtr)current, Enemy.a);
calculation = GlowIndex * 0x38 + 0x24;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Enemy.rwo);
calculation = GlowIndex * 0x38 + 0x25;
current = GlowObject + calculation;
vam.WriteBoolean((IntPtr)current, Enemy.rwuo);
}
}
i++;
} while (i < 65);
Thread.Sleep(10);
}
}
}
}
