Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

README.md

@@ -0,0 +1,3 @@
+# UwUHax
+
+Thx B0ruk for the base!

aimbot.cpp

@@ -0,0 +1,272 @@
+#include "hooks.h"
+#include "sigs.h"
+
+Aimbot g_Aimbot;
+
+bool shoot;
+static int custom_delay = 0;
+
+int Aimbot::GetAimBone(CBaseEntity* e)
+{
+	int bone = 0;
+
+	if (e)
+	{
+		studiohdr* hdr = pModel->GetStudiomodel(e->GetModel());
+		if (hdr)
+		{
+			for (int i = 0; i < hdr->GetHitboxCount(0); i++)
+			{
+				mstudiobbox* box = hdr->pHitboxSet(0)->pHitbox(i);
+				if (box)
+				{
+					if (box->group == HITGROUP_HEAD)
+					{
+						bone = i;
+					}
+				}
+			}
+		}
+	}
+
+	return bone;
+}
+
+void Aimbot::triggerbot(CUserCmd *cmd, CBaseEntity* local)
+{
+	Vector ViewAngles = cmd->viewangles;
+
+	Vector CrosshairForward;
+	Math::angleVectors(ViewAngles,CrosshairForward);
+
+	CrosshairForward *= 8192.0f;
+
+	Vector TraceSource = local->GetEyePosition();
+	Vector TraceDestination = TraceSource + CrosshairForward;
+
+	raytrace raytrace(TraceSource, TraceDestination);
+	traceclass Trace;
+	tracefitlers Skip = local;
+
+	pEngineTrace->TraceRay(raytrace, &Skip, &Trace);
+
+	if (!Trace.pent)
+		return;
+
+	if (!Trace.pent->ValidEntity())
+		return;
+
+	if (Trace.pent->GetTeamNum() == TEAM_SURVIVOR)
+		return;
+
+	bool didHit = false;
+
+	if ((gCvars.trighead && Trace.hitgroup == HITGROUP_HEAD)
+		|| (gCvars.triggerbody && Trace.hitgroup == HITGROUP_CHEST)
+		|| (gCvars.triggerbody && Trace.hitgroup == HITGROUP_STOMACH)
+		|| (gCvars.TRIGLIMB && Trace.hitgroup == HITGROUP_LEFTARM)
+		|| (gCvars.TRIGLIMB && Trace.hitgroup == HITGROUP_RIGHTARM)
+		|| (gCvars.TRIGLIMB && Trace.hitgroup == HITGROUP_LEFTLEG)
+		|| (gCvars.TRIGLIMB && Trace.hitgroup == HITGROUP_RIGHTLEG))
+	{
+		didHit = true;
+	}
+
+	if (gCvars.trigerdelay >= 1)
+	{
+		if (custom_delay >= gCvars.trigerdelay / 30)
+		{
+			if (didHit)
+			{
+				custom_delay = 0;
+				shoot = true;
+				cmd->buttons |= IN_ATTACK;
+			}
+		}
+		else
+		{
+			custom_delay++;
+		}
+	}
+}
+
+
+bool Aimbot::GetHitboxpos(CBaseEntity* pLocal, CBaseEntity* Entitiy, Vector &vPos, int iHitBox, matrix3x4_t matrix[128])
+{
+	Vector vMax;
+	Vector vMin;
+
+	studiohdr* hdr = pModel->GetStudiomodel(Entitiy->GetModel());
+
+	if (!hdr)
+		return false;
+
+	mstudiobbox* hitbox = hdr->pHitboxSet(0)->pHitbox(iHitBox);
+
+	if (!hitbox)
+		return false;
+
+	Math::VectorTransform(hitbox->bbmin, matrix[hitbox->bone], vMin);
+	Math::VectorTransform(hitbox->bbmax, matrix[hitbox->bone], vMax);
+
+	if (vMin.IsZero() || vMax.IsZero())
+		return false;
+
+	vPos = (vMin + vMax) * 0.5;
+
+	if (IsVisible(vEyePos, vPos, pLocal,Entitiy))
+		return true;
+
+	return false;
+}
+
+bool Aimbot::IsVisible(Vector& vecStart, Vector& vecEnd, CBaseEntity* pLocal, CBaseEntity* target)
+{
+	if (!pLocal)
+		return false;
+
+	if (!target)
+		return false;
+
+	raytrace raytrace(vecStart, vecEnd);
+	traceclass trace;
+	tracefitlers Skip = pLocal;
+
+	pEngineTrace->TraceRay(raytrace, &Skip, &trace);
+
+	if (trace.pent == target || trace.fraction == 1.f)
+		return true;
+
+	return false;
+}
+
+void Aimbot::Main(CUserCmd* pUserCmd, CBaseEntity* pLocal)
+{
+	int iMyTeam = pLocal->GetTeamNum();
+
+	vEyePos = pLocal->GetEyePosition();
+
+	static Vector vClientViewAngles;
+	pEngine->GetViewAngles(vClientViewAngles);
+
+	static Vector vAngle;
+	Math::angleVectors(vClientViewAngles, vAngle);
+
+	Reset();
+
+	for (INT ax = 1; ax <= pEntList->GetHighestEntityIndex(); ax++)
+	{
+		CBaseEntity* entity = pEntList->GetClientEntity(ax);
+
+		if (!entity || entity == pLocal || !entity->ValidEntity())
+			continue;
+
+		if (!entity->GetModel())
+			continue;
+
+		if (entity->GetTeamNum() == TEAM_SURVIVOR)
+			continue;
+
+		if (entity->GetTeamNum() == TEAM_IDK)
+			continue;
+
+		if (entity->IsDormant())
+			continue;
+
+		matrix3x4_t matrix[128];
+
+		if (!entity->SetupBones(matrix))
+			continue;
+
+		int aim = GetAimBone(entity);
+
+		if (!GetHitboxpos(pLocal, entity, vTarget, aim, matrix))
+			continue;
+
+		float fCurrFOV = Math::GetFov(vEyePos, vTarget, vAngle);
+
+		if (fCurrFOV > gCvars.AIMFOV)
+			continue;
+
+		fCurrFOV = (Vector(vTarget - vEyePos).Length());
+
+		if (fBestTarget < fCurrFOV)
+			continue;
+
+		fBestTarget = fCurrFOV;
+
+		vFinal = vTarget;
+
+		iTarget = ax;
+	}
+
+	if (HasTarget())
+	{
+		Math::CalcAngle(vEyePos, vFinal, pUserCmd->viewangles);
+
+		if (gCvars.SMOOTHPITCH > 0 && gCvars.SMOOTHYAW > 0)
+		{
+			vClientViewAngles.x = Math::AngleNormalize(vClientViewAngles.x);
+			vClientViewAngles.y = Math::AngleNormalize(vClientViewAngles.y);
+
+			Vector qDelta = pUserCmd->viewangles - vClientViewAngles;
+
+			qDelta.x = Math::AngleNormalize(qDelta.x);
+			qDelta.y = Math::AngleNormalize(qDelta.y);
+
+			pUserCmd->viewangles.x = vClientViewAngles.x + qDelta.x / (float)gCvars.SMOOTHPITCH;
+			pUserCmd->viewangles.y = vClientViewAngles.y + qDelta.y / (float)gCvars.SMOOTHYAW;
+
+			pUserCmd->viewangles.x = Math::AngleNormalize(pUserCmd->viewangles.x);
+			pUserCmd->viewangles.y = Math::AngleNormalize(pUserCmd->viewangles.y);
+		}
+
+		if (!gCvars.SILENTAIM)
+		{
+			pEngine->SetViewAngles(pUserCmd->viewangles);
+		}
+
+		if (gCvars.AUTOFIRE)
+		{
+			pUserCmd->buttons |= IN_ATTACK;
+		}
+	}
+}
+
+void Aimbot::FixMovement(CUserCmd* c, Vector &qOld)
+{
+	Vector vMove(c->forwardmove, c->sidemove, c->upmove);
+	float fSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y);
+	static Vector qMove;
+	Math::vectorAngles(vMove, qMove);
+
+	float fYaw = DEG2RAD(c->viewangles.y - qOld.y + qMove.y);
+
+	c->forwardmove = cos(fYaw) * fSpeed * 1;
+	c->sidemove = sin(fYaw) * fSpeed;
+}
+
+void Aimbot::ApplyRecoil(CBaseEntity *plocal, Vector &angles, float factor)
+{
+	angles += plocal->GetPunchAngle() * factor;
+}
+
+void Aimbot::ApplySpread(int sequence_number, CBaseEntity *plocal, Vector &angles, float factor)
+{
+	auto w = reinterpret_cast<CBaseCombatWeapon*>(pEntList->GetClientEntityFromHandle(plocal->GetActiveWeaponHandle()));
+
+	if (!w)
+		return;
+
+	int random_seed = MD5_PseudoRandom(sequence_number) & 0x7fffffff;
+
+	static auto SharedRandomFloat = (float(*)(const char *, float, float, int))FindProlog(FindString(GetModuleHandle("client"), "SharedRandomFloat"));
+	static int &r_random_seed = **(int **)FindPattern((void *)SharedRandomFloat, 0x100, ((const pattern *)"\x01\x01\x00\x00\x00\xA1"));
+
+	r_random_seed = random_seed;
+
+	float spread = w->GetWeaponSpread();
+
+	angles.x += SharedRandomFloat("CTerrorGun::FireBullet HorizSpread", -spread, spread, 0) * factor;
+	angles.y += SharedRandomFloat("CTerrorGun::FireBullet VertSpread", -spread, spread, 0) * factor;
+}

aimbot.h

@@ -0,0 +1,43 @@
+
+
+class Aimbot
+{
+public:
+	void Main(CUserCmd* pUserCmd, CBaseEntity* pLocal);
+
+	int GetAimBone(CBaseEntity* e);
+
+	bool GetHitboxpos(CBaseEntity* pLocal, CBaseEntity* Entitiy, Vector &vPos, int iHitBox, matrix3x4_t matrix[128]);
+
+	void ApplySpread(int sequence_number, CBaseEntity *plocal, Vector &angles, float factor);
+
+	void FixMovement(CUserCmd* c, Vector &qOld);
+
+	void ApplyRecoil(CBaseEntity *plocal, Vector &angles, float factor);
+
+	bool IsVisible(Vector& vecStart, Vector& vecEnd, CBaseEntity* pLocal, CBaseEntity* target);
+
+	void triggerbot(CUserCmd *cmd, CBaseEntity* local);
+
+	void Reset()
+	{
+		iTarget = -1;
+		fBestTarget = 99999.9f;
+		vTarget.Zero();
+		vFinal.Zero();
+	}
+
+	bool HasTarget()
+	{
+		return (iTarget != -1);
+	}
+
+	int iTarget;
+	float fBestTarget;
+	Vector vTarget;
+	Vector vFinal;
+	Vector vEyePos;
+};
+
+extern Aimbot g_Aimbot;
+

baseentity.h

@@ -0,0 +1,433 @@
+
+#include "netvars.h"
+#include "variables.h"
+
+enum classids
+{
+	Boomer = 0,
+	Charger = 99,
+	CTerrorPlayer = 232,
+	Hunter = 263,
+	Infected = 264,
+	Jockey = 265,
+	Smoker = 270,
+	Spitter = 272,
+	SurvivorBot = 275,
+	Tank = 276,
+	Witch = 277,
+};
+
+enum WeaponIDs
+{
+	WeaponCSBase = 0,
+	AssaultRifle = 5,
+	AutoShotgun = 4,
+	BaseBackpackItem = 0,
+	BoomerClaw = 41,
+	Chainsaw = 20,
+	ChargerClaw = 40,
+	ColaBottles = 28,
+	FireworkCrate = 29,
+	FirstAidKit = 12,
+	GasCan = 16,
+	Gnome = 27,
+	GrenadeLauncher = 21,
+	HunterClaw = 39,
+	Adrenaline = 23,
+	ItemAmmoPack = 22,
+	ItemDefibrillator = 24,
+	ItemUpgradePackExplosive = 31,
+	ItemUpgradePackIncendiary = 30,
+	VomitJar = 25,
+	JockeyClaw = 44,
+	Molotov = 13,
+	OxygenTank = 18,
+	PainPills = 15,
+	PipeBomb = 14,
+	Pistol = 1,
+	MagnumPistol = 32,
+	PropaneTank = 17,
+	PumpShotgun = 3,
+	AK47 = 26,
+	Desert = 9,
+	M60 = 37,
+	SG552 = 34,
+	Chrome = 8,
+	SPAS = 11,
+	MP5 = 33,
+	Silenced = 7,
+	SmokerClaw = 42,
+	SniperRifle = 6,
+	AWP = 35,
+	Military = 10,
+	Scout = 36,
+	SpitterClaw = 43,
+	SubMachinegun = 2,
+	TankClaw = 38,
+	TerrorMeleeWeapon = 19,
+	WeaponSpawn = 8,
+};
+
+enum TeamIndexes
+{
+	TEAM_UNASSIGNED,
+	TEAM_SPECTATOR,
+	TEAM_SURVIVOR,
+	TEAM_ZOMBY,
+	TEAM_IDK,
+};
+
+enum GROUP
+{
+	GROUP_INVALID = 0,
+	GROUP_TANK,
+	GROUP_BITCH,
+	GROUP_SPECIAL,
+	GROUP_INFECTED,
+	GROUP_PLAYER
+};
+
+#define pRenderables 0x4
+#define pNetworkables 0x8
+
+struct CBaseEntity
+{
+	DWORD* GetModel()
+	{
+		PVOID pRenderable = (PVOID)(this + pRenderables);
+		typedef DWORD* (__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(pRenderable, 8)(pRenderable);
+	}
+
+	int GetIndex()
+	{
+		PVOID pNetworkable = (PVOID)(this + pNetworkables);
+		typedef int(__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(pNetworkable, 8)(pNetworkable);
+	}
+
+	bool SetupBones(void* mtx)
+	{
+		PVOID pRenderable = (PVOID)(this + pRenderables);
+		typedef bool(__thiscall* OriginalFn)(PVOID, void*, int, long, float);
+		return getvfunc<OriginalFn>(pRenderable, 13)(pRenderable, mtx, 128, 0x100, 0);
+	}
+
+	bool IsDormant()
+	{
+		PVOID pNetworkable = (PVOID)(this + pNetworkables);
+		typedef bool(__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(pNetworkable, 7)(pNetworkable);
+	}
+
+	const Vector& GetAbsOrigin()
+	{
+		typedef const Vector& (__thiscall *GetAbsOrg_t)(PVOID);
+		return getvfunc<GetAbsOrg_t>(this, 11)(this);
+	}
+
+	ClientClass* GetClientClass()
+	{
+		PVOID pNetworkable = (PVOID)(this + pNetworkables);
+		typedef ClientClass* (__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(pNetworkable, 1)(pNetworkable);
+	}
+
+	Vector GetMins()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseEntity", "m_vecMins");
+		return *(Vector*)((uintptr_t)this + iOffset);
+	}
+	Vector GetMaxs()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseEntity", "m_vecMaxs");
+		return *(Vector*)((uintptr_t)this + iOffset);
+	}
+
+	unsigned short GetSolidFlags()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseEntity", "m_usSolidFlags");
+		return *(unsigned short*)((uintptr_t)this + iOffset);
+	}
+
+	unsigned char GetLifeState()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_lifeState");
+		return *(unsigned char*)((uintptr_t)this + iOffset);
+	}
+
+	int GetHealth()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_iHealth");
+		return *(int*)((uintptr_t)this + iOffset);
+	}
+
+	Vector GetVelocity()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_vecVelocity[0]");
+		return *(Vector*)((uintptr_t)this + iOffset);
+	}
+
+	Vector GetVecViewOffset()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_vecViewOffset[0]");
+		return *(Vector*)((uintptr_t)this + iOffset);
+	}
+
+	Vector GetEyePosition()
+	{
+		return GetAbsOrigin() + GetVecViewOffset();
+	}
+
+	int GetFlags()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_fFlags");
+		return *(int*)((uintptr_t)this + iOffset);
+	}
+
+	bool IsAlive()
+	{
+		return (GetLifeState() == LIFE_ALIVE && GetHealth() > 0);
+	}
+
+	int GetTeamNum()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseEntity", "m_iTeamNum");
+		return *(int*)((uintptr_t)this + iOffset);
+	}
+
+	Vector GetVecOrigin()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseEntity", "m_vecOrigin");
+		return *(Vector*)((uintptr_t)this + iOffset);
+	}
+
+	Vector GetPunchAngle()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_vecPunchAngle");
+		return *(Vector*)((DWORD)this + iOffset);
+	}
+
+	int GetTickBase()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BasePlayer", "m_nTickBase");
+		return *(int*)((uintptr_t)this + iOffset);
+	}
+
+	HANDLE GetActiveWeaponHandle()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseCombatCharacter", "m_hActiveWeapon");
+		return *(HANDLE*)((uintptr_t)this + iOffset);
+	}
+
+	inline const std::uint32_t Sequence()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseAnimating", "m_nSequence");
+		return *(std::uint32_t*)(reinterpret_cast<std::uintptr_t>(this) + iOffset);
+	}
+
+	const GROUP GetGroup()
+	{
+		constexpr std::uint32_t m_Bitch = classids::Witch;
+		constexpr std::uint32_t m_Tanks = classids::Tank;
+
+		constexpr std::uint32_t m_Special[] = 
+		{
+	         classids::Boomer, classids::Charger, classids::Smoker,
+	         classids::Hunter, classids::Jockey, classids::Spitter
+		};
+
+		constexpr std::uint32_t m_Infected = classids::Infected;
+		constexpr std::uint32_t m_Player[] = { classids::CTerrorPlayer, classids::SurvivorBot };
+
+		std::uint32_t m_ClassID = this->GetClientClass()->GetClassID;
+
+		if (m_ClassID == m_Infected)
+			return GROUP_INFECTED;
+
+		if (m_ClassID == m_Bitch)
+			return GROUP_BITCH;
+
+		if (m_ClassID == m_Tanks)
+			return GROUP_TANK;
+
+		else if (std::find(std::begin(m_Special), std::end(m_Special), m_ClassID) != std::end(m_Special))
+			return GROUP_SPECIAL;
+
+		else if (std::find(std::begin(m_Player), std::end(m_Player), m_ClassID) != std::end(m_Player))
+			return GROUP_PLAYER;
+
+		return GROUP_INVALID;
+	}
+
+	const bool ValidEntity()
+	{
+		if (this->IsDormant())
+			return false;
+
+		const auto nTeam = this->GetTeamNum();
+
+		if (nTeam != TEAM_SURVIVOR && nTeam != TEAM_ZOMBY)
+			return false;
+
+		auto m_Group = this->GetGroup();
+		auto m_Sequence = this->Sequence();
+		auto m_SolidFlags = this->GetSolidFlags();
+
+		if (m_Group == GROUP_INVALID)
+			return false;
+
+		if (m_Group == GROUP_TANK)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+
+			if (m_Sequence > 70)
+				return false;
+		}
+
+		if (m_Group == GROUP_BITCH)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+
+			if (m_Sequence > 70)
+				return false;
+		}
+
+		else if (m_Group == GROUP_SPECIAL)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+		}
+
+		else if (m_Group == GROUP_INFECTED)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+
+			if (m_Sequence > 305)
+				return false;
+		}
+
+		return true;
+	}
+
+	const bool ValidEntityIgnoreInfected()
+	{
+		if (this->IsDormant())
+			return false;
+
+		const auto nTeam = this->GetTeamNum();
+
+		if (nTeam != TEAM_SURVIVOR && nTeam != TEAM_ZOMBY)
+			return false;
+
+		auto m_Group = this->GetGroup();
+		auto m_Sequence = this->Sequence();
+		auto m_SolidFlags = this->GetSolidFlags();
+
+		if (m_Group == GROUP_INVALID)
+			return false;
+
+		if (m_Group == GROUP_TANK)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+
+			if (m_Sequence > 70)
+				return false;
+		}
+
+		if (m_Group == GROUP_BITCH)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+
+			if (m_Sequence > 70)
+				return false;
+		}
+
+		else if (m_Group == GROUP_SPECIAL)
+		{
+			if (m_SolidFlags & 4)
+				return false;
+		}
+
+		else if (m_Group == GROUP_INFECTED)
+		{
+			if (gCvars.INGOREINFECTED)
+				return false;
+
+			if (m_SolidFlags & 4)
+				return false;
+
+			if (m_Sequence > 305)
+				return false;
+		}
+
+		return true;
+	}
+};
+
+template<typename T>
+inline T ReadPtr(const void *base, int o)
+{
+	return *(T *)((char *)base + o);
+}
+
+struct CBaseCombatWeapon
+{
+	float GetNextPrimaryAttack()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseCombatWeapon", "m_flNextPrimaryAttack");
+		return *(float*)((uintptr_t)this + iOffset);
+	}
+
+	HANDLE Owner()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseCombatWeapon", "m_hOwner");
+		return *(HANDLE*)(reinterpret_cast<uintptr_t>(this) + iOffset);
+	}
+
+	inline float GetWeaponSpread()
+	{
+		return ReadPtr<float>(this, 3340);
+	}
+
+	int GetWeaponID()
+	{
+		typedef int(__thiscall* oWeaponID)(PVOID);
+		return getvfunc< oWeaponID >(this, 383)(this);
+	}
+
+	bool HasAmmo()
+	{
+		static int iOffset = g_Netvarmanager.GetOffset("DT_BaseCombatWeapon", "m_iClip1");
+		return ((*(PINT)((DWORD)this + iOffset)) > 0);
+	}
+
+	bool IsAimWep()
+	{
+		int iWpnID = GetWeaponID();
+
+		return (iWpnID == AssaultRifle
+			|| iWpnID == AutoShotgun
+			|| iWpnID == Pistol
+			|| iWpnID == MagnumPistol
+			|| iWpnID == PumpShotgun
+			|| iWpnID == AK47
+			|| iWpnID == Desert
+			|| iWpnID == M60
+			|| iWpnID == SG552
+			|| iWpnID == Chrome
+			|| iWpnID == SPAS
+			|| iWpnID == MP5
+			|| iWpnID == Silenced
+			|| iWpnID == SniperRifle
+			|| iWpnID == AWP
+			|| iWpnID == Scout
+			|| iWpnID == Military);
+	}
+};
+

bhop.h

@@ -0,0 +1,32 @@
+#pragma once
+
+
+void RunBhop(CUserCmd* cmd, CBaseEntity* pLocal)
+{
+	static bool jumped_last_tick = false;
+	static bool should_fake_jump = false;
+
+	if (!jumped_last_tick && should_fake_jump)
+	{
+		should_fake_jump = false;
+		cmd->buttons |= IN_JUMP;
+	}
+	else if (cmd->buttons & IN_JUMP)
+	{
+		if (pLocal->GetFlags() & FL_ONGROUND)
+		{
+			jumped_last_tick = true;
+			should_fake_jump = true;
+		}
+		else
+		{
+			cmd->buttons &= ~IN_JUMP;
+			jumped_last_tick = false;
+		}
+	}
+	else
+	{
+		jumped_last_tick = false;
+		should_fake_jump = false;
+	}
+}

cmove.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include "bhop.h"
+
+void CreateMove(CUserCmd* cmd)
+{
+	CBaseEntity* pLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
+	CBaseCombatWeapon* pWeapon = (CBaseCombatWeapon*)pEntList->GetClientEntityFromHandle(pLocal->GetActiveWeaponHandle());
+
+	if (pLocal && pWeapon && pLocal->IsAlive())
+	{
+		if (gCvars.AUTOBH)
+		{
+			RunBhop(cmd, pLocal);
+		}
+
+		if (gCvars.LAGFAST > 0 && GetAsyncKeyState(gCvars.LAGKEY))
+		{
+			Sequence::RemoveConds(gCvars.LAGFAST);
+		}
+
+		if (pWeapon->HasAmmo())
+		{
+			Vector qOldAngle = cmd->viewangles;
+
+			float fCurTime = pGlobalvars->interval_per_tick * (pLocal->GetTickBase() + 1);
+			float fNextPrimary = pWeapon->GetNextPrimaryAttack();
+
+			bool bCanFire = true;
+
+			static bool bOldBullet;
+
+			if ((fNextPrimary > fCurTime) || bOldBullet)
+				bCanFire = false;
+
+			if (!(fNextPrimary > fCurTime))
+				bOldBullet = false;
+
+			if (pLocal->GetTeamNum() == TEAM_SURVIVOR)
+			{
+				if (GetAsyncKeyState(gCvars.triggerkey))
+				{
+					g_Aimbot.triggerbot(cmd, pLocal);
+				}
+
+				if (gCvars.ENABLEAIM && pWeapon->IsAimWep())
+				{
+					if (gCvars.AIMONFIRE)
+					{
+						if ((cmd->buttons & IN_ATTACK))
+						{
+							g_Aimbot.Main(cmd, pLocal);
+						}
+					}
+					else
+					{
+						if (bCanFire)
+						{
+							g_Aimbot.Main(cmd, pLocal);
+						}
+					}
+				}
+
+				if (gCvars.NORECOIL)
+				{
+					g_Aimbot.ApplyRecoil(pLocal, cmd->viewangles, -1.0f);
+				}
+
+				if (gCvars.NOSPREAD)
+				{
+					if ((cmd->buttons & IN_ATTACK))
+					{
+						g_Aimbot.ApplySpread(cmd->command_number, pLocal, cmd->viewangles, -1.0f);
+					}
+				}
+
+				g_Aimbot.FixMovement(cmd, qOldAngle);
+			}
+		}
+	}
+}
+
+template<typename T> inline T get_BP()
+{
+	__asm mov eax, ebp
+}
+
+template<typename T> inline T get_SI()
+{
+	__asm mov eax, esi
+}
+
+using SetViewAngleFn = void(__stdcall*)(Vector &);
+SetViewAngleFn org_SetViewAngles = nullptr;
+
+void __stdcall hooked_SetViewAngles(Vector &angles)
+{
+	CUserCmd* cmd = get_SI<CUserCmd*>();
+	unsigned* sequence_number = (*get_BP<unsigned**>() + 2);
+
+	org_SetViewAngles(angles);
+
+	if (cmd && cmd->command_number == *sequence_number)
+	{
+		if (gCvars.SPEEDFAST > 0)
+		{
+			static int i = 0;
+
+			if (gCvars.SPEEDFAST && GetAsyncKeyState(gCvars.SPEEDKEY) && i-- > 0)
+				*(****get_BP<unsigned long*****>() + 1) -= 5;
+			else
+				i = gCvars.SPEEDFAST;
+		}
+
+		CreateMove(cmd);
+
+		*sequence_number = cmd->command_number;
+	}
+}

debugoverlay.h

@@ -0,0 +1,11 @@
+
+
+class CDebugOverlay
+{
+public:
+	bool ScreenPosition(const Vector& vIn, Vector& vOut)
+	{
+		typedef bool(__thiscall* OriginalFn)(PVOID, const Vector&, Vector&);
+		return getvfunc<OriginalFn>(this, 12)(this, vIn, vOut);
+	}
+};

dllmain.cpp

@@ -0,0 +1,45 @@
+
+
+#include "hooks.h"
+#include "model.h"
+#include "panel.h"
+#include "cmove.h"
+#include "hooking.hpp"
+
+vmt_hook* paint;
+vmt_hook* engine;
+vmt_hook* drawmodel;
+
+void InitThread()
+{	
+	static bool once = false;
+
+	if (!once)
+	{
+		InitialiseInterfaces();
+		g_Netvarmanager.Init();
+
+		paint = new vmt_hook(pPanel);
+		painttraverse_original = paint->hook<paint_traverse_t>(41, hkPaintTraverse);
+
+		engine = new vmt_hook(pEngine);
+		org_SetViewAngles = engine->hook<SetViewAngleFn>(20, hooked_SetViewAngles);
+
+		drawmodel = new vmt_hook(pModelRender);
+		draw_model_original = drawmodel->hook<DrawModelExecuteFn>(19, hkDrawModelExecute);
+
+		Draw::InitFonts();
+
+		once = true;
+	}
+}
+
+int __stdcall DllMain(void*, int r, void*)
+{
+	if (r == 1)
+	{
+		InitThread();
+	}
+
+	return 1;
+}

drawing.cpp

@@ -0,0 +1,110 @@
+#include "hooks.h"
+
+HFont Fonts::m_MenuFont;
+HFont Fonts::m_ListItemFont;
+HFont Fonts::m_WatermarkFont;
+HFont Fonts::m_VelocityFont;
+
+VOID Draw::InitFonts()
+{
+	if (pSurface == NULL)
+		return;
+
+	pSurface->SetFontGlyphSet(Fonts::m_MenuFont = pSurface->Create_Font(), "Visitor TT2 BRK", 15, 500, 0, 0, 0x200);
+	pSurface->SetFontGlyphSet(Fonts::m_ListItemFont = pSurface->Create_Font(), "Visitor TT2 BRK", 13, 500, 0, 0, 0x200);
+	pSurface->SetFontGlyphSet(Fonts::m_WatermarkFont = pSurface->Create_Font(), "Tahoma", 13, 700, 0, 0, 0x200);
+	pSurface->SetFontGlyphSet(Fonts::m_VelocityFont = pSurface->Create_Font(), "Tahoma", 24, 700, 0, 0, 0x200);
+}
+
+#define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+void Draw::DrawMonitorBar(int x, int y, int cur, const char* title)
+{
+	cur = clamp(cur, 0, 100);
+
+	Draw::FillRGBA(x, y, 30, 160, (int)(cur*2.55), (255 - (int)(cur*2.55)), 0, 255);
+	Draw::FillRGBA(x, y, 30, 160 - (cur * 1.6), 0, 0, 0, 255);
+	Draw::DrawStringA(Fonts::m_ListItemFont, false, x, y + 169, 255, 255, 255, 255, title);
+}
+
+void Draw::OutlinedRectangle(int x, int y, int w, int h, int r, int g, int b, int a)
+{
+	Draw::FillRGBA(x, y, w, 1, r, g, b, a);
+	Draw::FillRGBA(x, y, 1, h, r, g, b, a);
+	Draw::FillRGBA(x + w, y, 1, h + 1, r, g, b, a);
+	Draw::FillRGBA(x, y + h, w, 1, r, g, b, a);
+}
+
+void Draw::DrawTexts(unsigned long font, int x, int y, int r, int g, int b, int a, const wchar_t * text)
+{
+	pSurface->DrawSetTextPos(x, y);
+	pSurface->DrawSetTextFont(font);
+	pSurface->DrawSetTextColor(r, g, b, a);
+	pSurface->DrawPrintText(text, wcslen(text));
+}
+
+void Draw::SoftOutlinedRectangle(int x, int y, int w, int h, int r, int g, int b, int a)
+{
+	Draw::FillRGBA(x + 2, y, w - 3, 1, r, g, b, a);
+	Draw::FillRGBA(x + 1, y + 1, 1, 1, r, g, b, a);
+	Draw::FillRGBA(x, y + 2, 1, h - 3, r, g, b, a);
+	Draw::FillRGBA(x + 1, y + h - 1, 1, 1, r, g, b, a);
+	Draw::FillRGBA(x + w, y + 2, 1, h - 3, r, g, b, a);
+	Draw::FillRGBA(x + w - 1, y + 1, 1, 1, r, g, b, a);
+	Draw::FillRGBA(x + 2, y + h, w - 3, 1, r, g, b, a);
+	Draw::FillRGBA(x + w - 1, y + h - 1, 1, 1, r, g, b, a);
+}
+
+void Draw::FillRGBA(int x, int y, int w, int h, int r, int g, int b, int a)
+{
+	pSurface->DrawSetColor(r, g, b, a);
+	pSurface->DrawFilledRect(x, y, x + w, y + h);
+}
+
+std::wstring Draw::stringToWide(const std::string& text)
+{
+	std::wstring wide(text.length(), L' ');
+	std::copy(text.begin(), text.end(), wide.begin());
+
+	return wide;
+}
+
+int Draw::getWidht(unsigned long font, const char* input)
+{
+	INT iWide = 0;
+	INT iTall = 0;
+	INT iBufSize = MultiByteToWideChar(CP_UTF8, 0x0, input, -1, NULL, 0);
+
+	wchar_t* pszUnicode = new wchar_t[iBufSize];
+
+	MultiByteToWideChar(CP_UTF8, 0x0, input, -1, pszUnicode, iBufSize);
+
+	pSurface->GetTextSize(font, pszUnicode, iWide, iTall);
+
+	delete[] pszUnicode;
+
+	return iWide;
+}
+
+void Draw::DrawStringA(unsigned long font, bool center, int x, int y, int r, int g, int b, int a, const char *input, ...)
+{
+	CHAR szBuffer[MAX_PATH];
+
+	if (!input)
+		return;
+
+	vsprintf_s(szBuffer, input, (char*)&input + _INTSIZEOF(input));
+
+	if (center)
+		x -= getWidht(font, szBuffer) / 2;
+
+	pSurface->DrawSetTextColor(r, g, b, a);
+	pSurface->DrawSetTextFont(font);
+	pSurface->DrawSetTextPos(x, y);
+	std::wstring wide = stringToWide(std::string(szBuffer));
+	pSurface->DrawPrintText(wide.c_str(), wide.length());
+}
+
+bool Draw::WorldToScreen(const Vector &vOrigin, Vector &vScreen)
+{
+	return (pDebugOverlay->ScreenPosition(vOrigin, vScreen) != 1);
+}

drawing.h

@@ -0,0 +1,26 @@
+#pragma once
+
+typedef unsigned long HFont;
+
+namespace Fonts
+{
+	extern HFont m_MenuFont;
+	extern HFont m_ListItemFont;
+	extern HFont m_WatermarkFont;
+	extern HFont m_VelocityFont;
+}
+
+namespace Draw
+{
+	VOID InitFonts();
+	void FillRGBA(int x, int y, int w, int h, int r, int g, int b, int a);
+	bool WorldToScreen(const Vector &vOrigin, Vector &vScreen);
+	INT getWidht(unsigned long font, const char* input);
+	std::wstring stringToWide(const std::string& text);
+	VOID DrawStringA(unsigned long font, bool center, int x, int y, int r, int g, int b, int a, const char *input, ...);
+	void DrawTexts(unsigned long font, int x, int y, int r, int g, int b, int a, const wchar_t * text);
+	void DrawMonitorBar(int x, int y, int cur, const char * title);
+	void OutlinedRectangle(int x, int y, int w, int h, int r, int g, int b, int a);
+	void SoftOutlinedRectangle(int x, int y, int w, int h, int r, int g, int b, int a);
+}
+

engineclient.h

@@ -0,0 +1,79 @@
+class INetChannel
+{
+private:
+	__forceinline float GetLatency(int flow)
+	{
+		return getvfunc< float(__thiscall*)(decltype(this), int) >(this, 9)(this, flow);
+	}
+};
+
+class CEngineClient
+{
+public:
+	void GetScreenSize(int& width, int& height)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int&, int&);
+		return getvfunc<OriginalFn>(this, 5)(this, width, height);
+	}
+
+	int GetLocalPlayer(VOID)
+	{
+		typedef int(__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(this, 12)(this);
+	}
+
+	void GetViewAngles(Vector& vAngles)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, Vector&);
+		return getvfunc< OriginalFn >(this, 19)(this, vAngles);
+	}
+
+	void SetViewAngles(Vector& vAngles)
+	{
+		typedef void(__thiscall* oSetViewAngles)(PVOID, Vector&);
+		return getvfunc< oSetViewAngles >(this, 20)(this, vAngles);
+	}
+
+	int GetMaxClients()
+	{
+		typedef bool(__thiscall* oGetMaxClients)(PVOID);
+		return getvfunc< oGetMaxClients >(this, 21)(this);
+	}
+
+	INetChannel* GetNetChannelInfo(void)
+	{
+		typedef INetChannel* (__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(this, 74)(this);
+	}
+};
+
+class CEntityList
+{
+public:
+	CBaseEntity* GetClientEntity(int entnum)
+	{
+		typedef CBaseEntity* (__thiscall* OriginalFn)(PVOID, int);
+		return getvfunc<OriginalFn>(this, 3)(this, entnum);
+	}
+	CBaseEntity *GetClientEntityFromHandle(HANDLE hEnt)
+	{
+		typedef CBaseEntity* (__thiscall* OriginalFn)(PVOID, HANDLE);
+		return getvfunc<OriginalFn>(this, 4)(this, hEnt);
+	}
+	int GetHighestEntityIndex(void)
+	{
+		typedef int(__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(this, 8)(this);
+	}
+};
+
+class HLCLient
+{
+public:
+	ClientClass* GetAllClasses(VOID)
+	{
+		typedef ClientClass* (__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(this, 7)(this);
+	}
+};
+

enginetrace.h

@@ -0,0 +1,62 @@
+
+
+struct raytrace
+{
+	raytrace(const Vector& src, const Vector& dest) : start(src), delta(dest - src) { isSwept = delta.x || delta.y || delta.z; }
+	Vector start{ };
+	float pad{ };
+	Vector delta{ };
+	byte pad2[40]{ };
+	bool isRay{ true };
+	bool isSwept{ };
+};
+
+
+struct tracefitlers
+{
+	tracefitlers(const CBaseEntity* entity) : skip{ entity } { }
+	virtual bool shouldHitEntity(CBaseEntity* entity, int) { return entity != skip; }
+	virtual int getTraceType() const { return 0; }
+	const void* skip;
+};
+
+struct traceclass
+{
+	Vector		startpos;
+	Vector		endpos;
+
+	struct
+	{
+		Vector	normal;
+		float	distance;
+		char	type;
+		char	signbits;
+		short	unused;
+	}
+	plane;
+
+	float		fraction;
+	int			contents;
+	short		dispflags;
+	bool		allsolid;
+	bool		startsolid;
+	float		fractionleftsolid;
+	const char	*name;
+	short		surfaceprops;
+	short		flags;
+	int			hitgroup;
+	short		physicsbone;
+	CBaseEntity	*pent;
+	int			hitbox;
+};
+
+class CEnginetrace
+{
+public:
+	void TraceRay(const raytrace &ray, tracefitlers *pTraceFilter, traceclass *ptrace)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, const raytrace &, int, tracefitlers *, traceclass *);
+		return getvfunc<OriginalFn>(this, 5)(this, ray, 0x46004003, pTraceFilter, ptrace);
+	}
+};
+

exploit.cpp

@@ -0,0 +1,9 @@
+#include "hooks.h"
+
+
+void Sequence::RemoveConds(int value)
+{
+	INetChannel* ch = (INetChannel*)pEngine->GetNetChannelInfo();
+	int& m_nOutSequenceNr = *(int*)((unsigned)ch + 8);
+	m_nOutSequenceNr += value;
+}

exploit.h

@@ -0,0 +1,6 @@
+
+
+namespace Sequence
+{
+	void RemoveConds(int value);
+}

globalvars.h

@@ -0,0 +1,35 @@
+
+
+
+class CGlobalVarsBase
+{
+public:
+	float     realtime;                     // 0x0000
+	int       framecount;                   // 0x0004
+	float     absoluteframetime;            // 0x0008
+											//float     absoluteframe; // 0x000C
+	float     curtime;                      // 0x0010
+	float     frametime;                    // 0x0014
+	int       maxClients;                   // 0x0018
+	int       tickcount;                    // 0x001C
+	float     interval_per_tick;            // 0x0020
+	float     interpolation_amount;         // 0x0024
+	int       simTicksThisFrame;            // 0x0028
+	int       network_protocol;             // 0x002C
+	void*     pSaveData;                    // 0x0030
+	bool      m_bClient;                    // 0x0031
+	bool      m_bRemoteClient;              // 0x0032
+private:
+	int       nTimestampNetworkingBase;
+	int       nTimestampRandomizeWindow;
+};
+
+class IPlayerInfoManager
+{
+public:
+	CGlobalVarsBase* GetGlobalVars()
+	{
+		typedef CGlobalVarsBase* (__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(this, 1)(this);
+	}
+};

hooking.hpp

@@ -0,0 +1,34 @@
+
+
+class vmt_hook
+{
+public:
+	vmt_hook(void* classptr)
+	{
+		this->m_class_pointer = reinterpret_cast<void***>(classptr);
+		m_old_vmt = *m_class_pointer;
+
+		size_t table_size = 0;
+		while (m_old_vmt[table_size])
+			table_size++;
+
+		m_new_vmt = new void*[table_size + 1];
+		memcpy(&m_new_vmt[1], m_old_vmt, sizeof(void*) * table_size);
+		m_new_vmt[0] = m_old_vmt[-1];
+
+		*m_class_pointer = &m_new_vmt[1];
+	}
+
+	template<typename fn = void*>
+	fn hook(size_t index, void* new_function)
+	{
+		if (new_function)
+			m_new_vmt[index + 1] = new_function;
+		return reinterpret_cast<fn>(m_old_vmt[index]);
+	}
+
+private:
+	void*** m_class_pointer = nullptr;
+	void** m_old_vmt = nullptr;
+	void** m_new_vmt = nullptr;
+};

hooks.h

@@ -0,0 +1,20 @@
+
+
+
+
+#include <Windows.h>
+#include <vector>
+
+#include "vector.h"
+#include "math.h"
+#include "include.h"
+#include "interfaces.h"
+#include "drawing.h"
+#include "aimbot.h"
+#include "visuals.h"
+#include "exploit.h"
+#include "mouse.h"
+#include "menu.h"
+#include "variables.h"
+
+

include.h

@@ -0,0 +1,26 @@
+
+
+template <typename t>
+t getvfunc(void* class_pointer, size_t index)
+{
+	return (*(t**)class_pointer)[index];
+}
+
+#define	LIFE_ALIVE	0 
+#define	FL_ONGROUND		(1<<0)
+#define IN_ATTACK		(1 << 0)
+#define IN_JUMP			(1 << 1)
+#define IN_USE			(1 << 5)
+
+#include "modelsinfo.h"
+#include "debugoverlay.h"
+#include "md5hash.h"
+#include "recvprop.h"
+#include "baseentity.h"
+#include "engineclient.h"
+#include "surface.h"
+#include "materials.h"
+#include "globalvars.h"
+#include "panels.h"
+#include "usercmd.h"
+#include "enginetrace.h"

interfaces.cpp

@@ -0,0 +1,43 @@
+#include "hooks.h"
+#include "sigs.h"
+
+
+void InitialiseInterfaces()
+{
+	auto EnginePointer = get_module_factory(GetModuleHandleW(L"engine.dll"));
+	auto ClientPointer = get_module_factory(GetModuleHandleW(L"client.dll"));
+	auto VGUISurfacePointer = get_module_factory(GetModuleHandleW(L"vguimatsurface.dll"));
+	auto VGUI2Pointer = get_module_factory(GetModuleHandleW(L"vgui2.dll"));
+	auto MaterialPointer = get_module_factory(GetModuleHandleW(L"materialsystem.dll"));
+	auto ServerPointer = get_module_factory(GetModuleHandleW(L"server.dll"));
+
+	pInfoPlayer = (IPlayerInfoManager*)ServerPointer("PlayerInfoManager002", nullptr);
+	pClient = (HLCLient*)ClientPointer("VClient016", nullptr);
+	pEngine = (CEngineClient*)EnginePointer("VEngineClient013", nullptr);
+	pEntList = (CEntityList*)ClientPointer("VClientEntityList003", nullptr);
+	pModel = (CModelInfo*)EnginePointer("VModelInfoClient004", nullptr);
+	pModelRender = (IVModelRender*)EnginePointer("VEngineModel016", nullptr);
+	pMaterialSystem = (IMaterialSystem*)MaterialPointer("VMaterialSystem080", nullptr);
+	pPanel = (IPanel*)VGUI2Pointer("VGUI_Panel009", nullptr);
+	pSurface = (ISurface*)VGUISurfacePointer("VGUI_Surface031", nullptr);
+	pEngineTrace = (CEnginetrace*)EnginePointer("EngineTraceClient003", nullptr);
+	pDebugOverlay = (CDebugOverlay*)EnginePointer("VDebugOverlay003", nullptr);
+
+	pClientMode = **(void***)(Findrekt("client.dll", "89 04 B5 ? ? ? ? E8") + 3);
+	pGlobalvars = pInfoPlayer->GetGlobalVars();
+}
+
+IPlayerInfoManager* pInfoPlayer;
+CGlobalVarsBase* pGlobalvars;
+void* pClientMode;
+CDebugOverlay* pDebugOverlay;
+CEngineClient* pEngine;
+IPanel* pPanel;
+CEntityList* pEntList;
+ISurface* pSurface;
+IMaterialSystem* pMaterialSystem;
+IVModelRender* pModelRender;
+CModelInfo* pModel;
+HLCLient* pClient;
+CEnginetrace* pEngineTrace;
+

interfaces.h

@@ -0,0 +1,23 @@
+
+
+extern void InitialiseInterfaces();
+
+extern IPlayerInfoManager* pInfoPlayer;
+extern CGlobalVarsBase* pGlobalvars;
+extern void* pClientMode;
+extern CDebugOverlay* pDebugOverlay;
+extern CEngineClient* pEngine;
+extern IPanel* pPanel;
+extern CEntityList* pEntList;
+extern ISurface* pSurface;
+extern IMaterialSystem* pMaterialSystem;
+extern IVModelRender* pModelRender;
+extern CModelInfo* pModel;
+extern HLCLient* pClient;
+extern CEnginetrace* pEngineTrace;
+
+typedef void* (*CreateInterfaceFn)(const char* pName, int* pReturnCode);
+inline CreateInterfaceFn get_module_factory(HMODULE module)
+{
+	return reinterpret_cast<CreateInterfaceFn>(GetProcAddress(module, "CreateInterface"));
+}

l4d2hook.sln

@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.28307.1340
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "l4d2hook", "l4d2hook.vcxproj", "{B47833C2-CC00-4490-A751-A16553374E0E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{B47833C2-CC00-4490-A751-A16553374E0E}.Release|x86.ActiveCfg = Release|Win32
+		{B47833C2-CC00-4490-A751-A16553374E0E}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8946D11E-242F-40AE-8EDC-714D57FCE5DC}
+	EndGlobalSection
+EndGlobal

l4d2hook.vcxproj

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="aimbot.cpp" />
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="drawing.cpp" />
+    <ClCompile Include="exploit.cpp" />
+    <ClCompile Include="interfaces.cpp" />
+    <ClCompile Include="math.cpp" />
+    <ClCompile Include="md5hash.cpp" />
+    <ClCompile Include="menu.cpp" />
+    <ClCompile Include="mouse.cpp" />
+    <ClCompile Include="netvars.cpp" />
+    <ClCompile Include="sigs.cpp" />
+    <ClCompile Include="variables.cpp" />
+    <ClCompile Include="visuals.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="aimbot.h" />
+    <ClInclude Include="baseentity.h" />
+    <ClInclude Include="bhop.h" />
+    <ClInclude Include="cmove.h" />
+    <ClInclude Include="debugoverlay.h" />
+    <ClInclude Include="drawing.h" />
+    <ClInclude Include="engineclient.h" />
+    <ClInclude Include="enginetrace.h" />
+    <ClInclude Include="exploit.h" />
+    <ClInclude Include="globalvars.h" />
+    <ClInclude Include="hooking.hpp" />
+    <ClInclude Include="hooks.h" />
+    <ClInclude Include="include.h" />
+    <ClInclude Include="interfaces.h" />
+    <ClInclude Include="materials.h" />
+    <ClInclude Include="math.h" />
+    <ClInclude Include="md5hash.h" />
+    <ClInclude Include="menu.h" />
+    <ClInclude Include="model.h" />
+    <ClInclude Include="modelsinfo.h" />
+    <ClInclude Include="mouse.h" />
+    <ClInclude Include="netvars.h" />
+    <ClInclude Include="panel.h" />
+    <ClInclude Include="panels.h" />
+    <ClInclude Include="recvprop.h" />
+    <ClInclude Include="sigs.h" />
+    <ClInclude Include="surface.h" />
+    <ClInclude Include="usercmd.h" />
+    <ClInclude Include="variables.h" />
+    <ClInclude Include="vector.h" />
+    <ClInclude Include="visuals.h" />
+    <ClInclude Include="vmatrix.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{B47833C2-CC00-4490-A751-A16553374E0E}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <ProjectName>l4d2hook</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <LibraryPath>$(LibraryPath)</LibraryPath>
+    <TargetName>insomnia</TargetName>
+    <IncludePath>$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CSSBASE_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>TurnOffAllWarnings</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <TargetMachine>MachineX86</TargetMachine>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

l4d2hook.vcxproj.filters

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="aimbot.cpp" />
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="drawing.cpp" />
+    <ClCompile Include="exploit.cpp" />
+    <ClCompile Include="interfaces.cpp" />
+    <ClCompile Include="math.cpp" />
+    <ClCompile Include="md5hash.cpp" />
+    <ClCompile Include="menu.cpp" />
+    <ClCompile Include="mouse.cpp" />
+    <ClCompile Include="netvars.cpp" />
+    <ClCompile Include="sigs.cpp" />
+    <ClCompile Include="variables.cpp" />
+    <ClCompile Include="visuals.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="aimbot.h" />
+    <ClInclude Include="baseentity.h" />
+    <ClInclude Include="bhop.h" />
+    <ClInclude Include="cmove.h" />
+    <ClInclude Include="debugoverlay.h" />
+    <ClInclude Include="drawing.h" />
+    <ClInclude Include="engineclient.h" />
+    <ClInclude Include="enginetrace.h" />
+    <ClInclude Include="exploit.h" />
+    <ClInclude Include="globalvars.h" />
+    <ClInclude Include="hooking.hpp" />
+    <ClInclude Include="hooks.h" />
+    <ClInclude Include="include.h" />
+    <ClInclude Include="interfaces.h" />
+    <ClInclude Include="materials.h" />
+    <ClInclude Include="math.h" />
+    <ClInclude Include="md5hash.h" />
+    <ClInclude Include="menu.h" />
+    <ClInclude Include="model.h" />
+    <ClInclude Include="modelsinfo.h" />
+    <ClInclude Include="mouse.h" />
+    <ClInclude Include="netvars.h" />
+    <ClInclude Include="panel.h" />
+    <ClInclude Include="panels.h" />
+    <ClInclude Include="recvprop.h" />
+    <ClInclude Include="sigs.h" />
+    <ClInclude Include="surface.h" />
+    <ClInclude Include="usercmd.h" />
+    <ClInclude Include="variables.h" />
+    <ClInclude Include="vector.h" />
+    <ClInclude Include="visuals.h" />
+    <ClInclude Include="vmatrix.h" />
+  </ItemGroup>
+</Project>

l4d2hook.vcxproj.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>

materials.h

@@ -0,0 +1,61 @@
+#pragma once
+
+
+struct ModelRenderInfo_t
+{
+	Vector origin;
+	Vector angles;
+	void* renderable;
+	const void *pModel;
+	const matrix3x4_t *pModelToWorld;
+	const matrix3x4_t *pLightingOffset;
+	const Vector* lightingOrigin;
+	int flags;
+	int entity_index;
+};
+
+enum MaterialVarFlag
+{
+	NO_DRAW = (1 << 2),
+	ZNEARER = (1 << 10),
+	NOCULL = (1 << 13),
+	NOFOG = (1 << 14),
+	IGNOREZ = (1 << 15),
+	HALFLAMBERT = (1 << 27)
+};
+
+class IMaterial
+{
+public:
+	void ColorModulate(float r, float g, float b)
+	{
+		typedef void(__thiscall* ColorModulateFn)(void*, float, float, float);
+		getvfunc<ColorModulateFn>(this, 28)(this, r, g, b);
+	}
+
+	void SetMaterialVarFlag(MaterialVarFlag flag, bool on)
+	{
+		typedef void(__thiscall* SetMaterialVarFlagFn)(void*, MaterialVarFlag, bool);
+		getvfunc<SetMaterialVarFlagFn>(this, 29)(this, flag, on);
+	}
+};
+
+class IMaterialSystem
+{
+public:
+	IMaterial *FindMaterial(char const* pMaterialName, const char *pTextureGroupName, bool complain = true, const char *pComplainPrefix = NULL)
+	{
+		typedef IMaterial*(__thiscall* OriginalFn)(PVOID, char const*, const char*, bool, const char*);
+		return getvfunc<OriginalFn>(this, 71)(this, pMaterialName, pTextureGroupName, complain, pComplainPrefix);
+	}
+};
+
+class IVModelRender
+{
+public:
+	void ForcedMaterialOverride(IMaterial* mat)
+	{
+		typedef void(__thiscall *OriginalFn)(void*, IMaterial*, int);
+		return getvfunc<OriginalFn>(this, 1)(this, mat, 0);
+	}
+};

math.cpp

@@ -0,0 +1,130 @@
+#include "hooks.h"
+
+
+float Math::DotProduct(const float *v1, const float *v2)
+{
+	return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+}
+
+float Math::sseSqrt(float x)
+{
+	float root = 0.0f;
+
+	__asm
+	{
+		sqrtss xmm0, x
+		movss root, xmm0
+	}
+
+	return root;
+}
+
+void Math::vectorAngles(Vector forward, Vector &angles)
+{
+	if (forward[1] == 0.0f && forward[0] == 0.0f)
+	{
+		angles[0] = (forward[2] > 0.0f) ? 270.0f : 90.0f;
+		angles[1] = 0.0f;
+	}
+	else
+	{
+		float len2d = sseSqrt(square(forward[0]) + square(forward[1]));
+
+		angles[0] = RAD2DEG(atan2f(-forward[2], len2d));
+		angles[1] = RAD2DEG(atan2f(forward[1], forward[0]));
+
+		if (angles[0] < 0.0f) angles[0] += 360.0f;
+		if (angles[1] < 0.0f) angles[1] += 360.0f;
+	}
+
+	angles[2] = 0.0f;
+}
+
+VOID Math::VectorTransform(const Vector in1, const matrix3x4_t& in2, Vector& out)
+{
+	float buf[3];
+	buf[0] = in1.x;
+	buf[1] = in1.y;
+	buf[2] = in1.z;
+
+	out[0] = DotProduct(buf, in2[0]) + in2[0][3];
+	out[1] = DotProduct(buf, in2[1]) + in2[1][3];
+	out[2] = DotProduct(buf, in2[2]) + in2[2][3];
+}
+
+float Math::GetFov(Vector vLocalOrigin, Vector vPosition, Vector vForward)
+{
+	Vector vLocal;
+
+	VectorSubtract(vPosition, vLocalOrigin, vLocal);
+
+	vLocal.NormalizeInPlace();
+
+	float fValue = vForward.Dot(vLocal);
+
+	if (fValue < -1.0f)
+		fValue = -1.0f;
+
+	if (fValue > 1.0f)
+		fValue = 1.0f;
+
+	return RAD2DEG(acos(fValue));
+}
+
+void Math::CalcAngle(Vector &vSource, Vector &vDestination, Vector &qAngle)
+{
+	Vector vDelta = vSource - vDestination;
+
+	float fHyp = (vDelta.x * vDelta.x) + (vDelta.y * vDelta.y);
+
+	float fRoot;
+
+	__asm
+	{
+		sqrtss xmm0, fHyp
+		movss fRoot, xmm0
+	}
+
+	qAngle.x = RAD2DEG(atan(vDelta.z / fRoot));
+	qAngle.y = RAD2DEG(atan(vDelta.y / vDelta.x));
+
+	if (vDelta.x >= 0.0f)
+		qAngle.y += 180.0f;
+
+	qAngle.x = AngleNormalize(qAngle.x);
+	qAngle.y = AngleNormalize(qAngle.y);
+}
+
+void sinCos(float radians, PFLOAT sine, PFLOAT cosine)
+{
+	__asm
+	{
+		fld dword ptr[radians]
+		fsincos
+		mov edx, dword ptr[cosine]
+		mov eax, dword ptr[sine]
+		fstp dword ptr[edx]
+		fstp dword ptr[eax]
+	}
+}
+
+void Math::angleVectors(Vector angles, Vector &f)
+{
+	float sp, sy, sr, cp, cy, cr;
+
+	sinCos(DEG2RAD(angles[0]), &sp, &cp);
+	sinCos(DEG2RAD(angles[1]), &sy, &cy);
+	sinCos(DEG2RAD(angles[2]), &sr, &cr);
+
+	f[0] = cp * cy;
+	f[1] = cp * sy;
+	f[2] = -sp;
+}
+
+float Math::AngleNormalize(float angle)
+{
+	while (angle < -180)    angle += 360;
+	while (angle > 180)    angle -= 360;
+
+	return angle;
+}

math.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "vmatrix.h"
+
+#define PI 3.14159265358979323846f
+#define DEG2RAD( x ) ( ( float )( x ) * ( float )( ( float )( PI ) / 180.0f ) )
+#define RAD2DEG( x ) ( ( float )( x ) * ( float )( 180.0f / ( float )( PI ) ) )
+#define square( x ) ( x * x )
+
+
+namespace Math
+{
+	float sseSqrt(float x);
+
+	void vectorAngles(Vector forward, Vector &angles);
+
+	float DotProduct(const float *v1, const float *v2);
+
+	VOID VectorTransform(const Vector in1, const matrix3x4_t& in2, Vector& out);
+
+	float GetFov(Vector vLocalOrigin, Vector vPosition, Vector vForward);
+
+	void CalcAngle(Vector &vSource, Vector &vDestination, Vector &qAngle);
+
+	void angleVectors(Vector angles, Vector &f);
+
+	float AngleNormalize(float angle);
+}

md5hash.cpp

@@ -0,0 +1,192 @@
+#include "md5hash.h"
+
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+#define MD5STEP(f, w, x, y, z, data, s) \
+		( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+static void MD5Transform(unsigned buf[4], unsigned const in[16])
+{
+	register unsigned a, b, c, d;
+
+	a = buf[0];
+	b = buf[1];
+	c = buf[2];
+	d = buf[3];
+
+	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+	buf[0] += a;
+	buf[1] += b;
+	buf[2] += c;
+	buf[3] += d;
+}
+
+void MD5Init(MD5Context_t *ctx)
+{
+	ctx->buf[0] = 0x67452301;
+	ctx->buf[1] = 0xefcdab89;
+	ctx->buf[2] = 0x98badcfe;
+	ctx->buf[3] = 0x10325476;
+
+	ctx->bits[0] = 0;
+	ctx->bits[1] = 0;
+}
+
+void MD5Update(MD5Context_t *ctx, unsigned char const *buf, unsigned len)
+{
+	unsigned t;
+
+	t = ctx->bits[0];
+	if ((ctx->bits[0] = t + ((unsigned)len << 3)) < t)
+		ctx->bits[1]++;
+	ctx->bits[1] += len >> 29;
+
+	t = (t >> 3) & 0x3f;
+
+	if (t)
+	{
+		unsigned char *p = (unsigned char *)ctx->in + t;
+
+		t = 64 - t;
+		if (len < t)
+		{
+			memcpy(p, buf, len);
+			return;
+		}
+		memcpy(p, buf, t);
+		//byteReverse(ctx->in, 16);
+		MD5Transform(ctx->buf, (unsigned *)ctx->in);
+		buf += t;
+		len -= t;
+	}
+
+	while (len >= 64)
+	{
+		memcpy(ctx->in, buf, 64);
+		//byteReverse(ctx->in, 16);
+		MD5Transform(ctx->buf, (unsigned *)ctx->in);
+		buf += 64;
+		len -= 64;
+	}
+
+	memcpy(ctx->in, buf, len);
+}
+
+void MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], MD5Context_t *ctx)
+{
+	unsigned count;
+	unsigned char *p;
+
+	count = (ctx->bits[0] >> 3) & 0x3F;
+
+	p = ctx->in + count;
+	*p++ = 0x80;
+
+	count = 64 - 1 - count;
+
+	if (count < 8)
+	{
+		memset(p, 0, count);
+		//byteReverse(ctx->in, 16);
+		MD5Transform(ctx->buf, (unsigned *)ctx->in);
+
+		memset(ctx->in, 0, 56);
+	}
+	else
+	{
+		memset(p, 0, count - 8);
+	}
+	//byteReverse(ctx->in, 14);
+
+	((unsigned *)ctx->in)[14] = ctx->bits[0];
+	((unsigned *)ctx->in)[15] = ctx->bits[1];
+
+	MD5Transform(ctx->buf, (unsigned *)ctx->in);
+	//byteReverse((unsigned char *) ctx->buf, 4);
+	memcpy(digest, ctx->buf, MD5_DIGEST_LENGTH);
+	memset(ctx, 0, sizeof(ctx));
+}
+
+unsigned MD5_PseudoRandom(unsigned nSeed)
+{
+	MD5Context_t ctx;
+	unsigned char digest[MD5_DIGEST_LENGTH]; // The MD5 Hash
+
+	memset(&ctx, 0, sizeof(ctx));
+
+	MD5Init(&ctx);
+	MD5Update(&ctx, (unsigned char*)&nSeed, sizeof(nSeed));
+	MD5Final(digest, &ctx);
+
+	return *(unsigned*)(digest + 6);	// use 4 middle bytes for random value
+}

md5hash.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <string.h>
+
+#define MD5_DIGEST_LENGTH 16  
+
+typedef struct
+{
+	unsigned		buf[4];
+	unsigned		bits[2];
+	unsigned char	in[64];
+} MD5Context_t;
+
+void MD5Init(MD5Context_t *context);
+void MD5Update(MD5Context_t *context, unsigned char const *buf, unsigned len);
+void MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], MD5Context_t *context);
+
+unsigned MD5_PseudoRandom(unsigned nSeed);

menu.cpp

@@ -0,0 +1,600 @@
+#include "hooks.h"
+
+
+cMenu g_Menu(400,200,290,253);
+
+bool bSliderFix[50];
+
+int iSliderIndex = -1;
+int iCurrSlider;
+
+DWORD dwWait;
+
+#define COLOR1 60, 60, 60, 255
+#define COLOR2 85, 85, 85, 255
+#define COLOR3 0, 0, 0, 255
+#define COLOR4 35, 35, 35, 255
+#define COLOR5 50, 50, 50, 255
+#define COLOR6 100, 100, 100, 255
+#define COLOR7 73, 73, 73, 255
+#define COLOR8 65, 65, 65, 255
+
+#define COLOR9 (gCvars.espcolor[0]), (gCvars.espcolor[1]), (gCvars.espcolor[2]), 255
+
+#define LISTITEM_TEXTCOLOR 255, 255, 255, 255
+
+#define ELEMENT_SEPERATION 20
+#define CHECKBOX_SEPERATION_FROM_TEXT 100
+#define CHECKBOX_SIZE 13
+
+#define DEFAULT_X_TO_ADD (70 + CHECKBOX_SIZE + 40)
+
+#define DROPDOWN_WIDTH 57
+#define DROPDOWN_HEIGHT 15
+
+#define ADDER_SIZE 12
+#define ADDER_SEPERATE_FROM_BOXES 44 
+
+cMenu::cMenu(int x, int y, int w, int h)
+{
+	m_x = x;
+	m_y = y;
+	m_w = w;
+	m_h = h;
+}
+
+char *fuckingkeynames[] = { "M2","F","Z","Q","V" };
+float fuckingkeyvalues[] = { 0x02,0x46,0x5A,0x51,0x56 };
+
+void cMenu::InitMenuElements()
+{
+	static cMenuSection msAimbot;
+	static cMenuSection msAimbotSliders;
+	static cMenuSection radarslider;
+	static cMenuSection msEsp;
+	static cMenuSection msMisc;
+	static cMenuSection msRemovals;
+	static cMenuSection msskinss;
+	static cMenuSection hoodrich;
+
+	int iRowTwo = DEFAULT_X_TO_ADD;
+
+	int iUsualX = m_x + 10;
+
+	iCurrSlider = 0;
+
+	switch (GetTabIndex())
+	{
+	case AIMTAB:
+
+		msAimbot.ClearSection();
+		msAimbotSliders.ClearSection();
+
+		msAimbot.Draw(iUsualX, m_y + 30, m_w - 22, 80);
+
+		msAimbot.AddElement(ONOFF, -3, L" AIM ENABLE", &gCvars.ENABLEAIM);
+		msAimbot.AddElement(ONOFF, -3, L" AIM ON FIRE", &gCvars.AIMONFIRE);
+		msAimbot.AddElement(ONOFF, -3, L" SILENT AIM", &gCvars.SILENTAIM);
+
+		msAimbot.RestartSection();
+
+		msAimbot.AddElement(ONOFF, iRowTwo, L"        NORECOIL", &gCvars.NORECOIL);
+		msAimbot.AddElement(ONOFF, iRowTwo, L"        NOSPREAD", &gCvars.NOSPREAD);
+		msAimbot.AddElement(ONOFF, iRowTwo, L"        AUTOFIRE", &gCvars.AUTOFIRE);
+
+		msAimbotSliders.Draw(iUsualX, m_y + 116, m_w - 22, 124);
+
+		msAimbotSliders.SetSlider(iCurrSlider, true);
+		msAimbotSliders.AddElement(SLIDER, 0, L"TARGET SELECTION FOV", &gCvars.AIMFOV, 0, 180);
+		msAimbotSliders.SetSlider(iCurrSlider, true);
+		msAimbotSliders.AddElement(SLIDER, 0, L"SMOOTHNESS PITCH", &gCvars.SMOOTHPITCH, 0, 255);
+		msAimbotSliders.SetSlider(iCurrSlider, true);
+		msAimbotSliders.AddElement(SLIDER, 0, L"SMOOTHNESS YAW", &gCvars.SMOOTHYAW, 0, 255);
+
+		break;
+
+	case ESPTAB:
+
+		msEsp.ClearSection();
+		radarslider.ClearSection();
+
+		msEsp.Draw(iUsualX, m_y + 30, m_w - 22, 90);
+
+		msEsp.AddElement(ONOFF, 0, L"ESP NAME", &gCvars.ESPNAME);
+		msEsp.AddElement(ONOFF, 0, L"ESP BOX", &gCvars.ESPBOX);
+		msEsp.AddElement(ONOFF, 0, L"ESP HEALTH", &gCvars.ESPHEALTH);
+		msEsp.AddElement(ONOFF, 0, L"IGNORE INFECTED", &gCvars.INGOREINFECTED);
+		msEsp.RestartSection();
+		msEsp.AddElement(ONOFF, iRowTwo, L"        CHAMS", &gCvars.CHAMS);
+		msEsp.AddElement(ONOFF, iRowTwo, L"        CHAM XQZ", &gCvars.CHAMSXQZ);
+		msEsp.AddElement(ONOFF, iRowTwo, L"        CHAM HAND", &gCvars.CHAMHAND);
+
+		radarslider.Draw(iUsualX, m_y + 116, m_w - 22, 124);
+
+		radarslider.SetSlider(iCurrSlider, true);
+		radarslider.AddElement(SLIDER, 0, L"RED", &gCvars.espcolor[0], 0, 255);
+		radarslider.SetSlider(iCurrSlider, true);
+		radarslider.AddElement(SLIDER, 0, L"GREEN", &gCvars.espcolor[1], 0, 255);
+		radarslider.SetSlider(iCurrSlider, true);
+		radarslider.AddElement(SLIDER, 0, L"BLUE", &gCvars.espcolor[2], 0, 255);
+
+		break;
+
+	case MISCTAB:
+
+		msRemovals.ClearSection();
+		msskinss.ClearSection();
+		hoodrich.ClearSection();
+
+		hoodrich.Draw(iUsualX, m_y + 30, m_w - 22, 64);
+		hoodrich.SetValueNames(fuckingkeynames, fuckingkeyvalues, 5);
+		hoodrich.AddElement(ADDER, -20, L"      SEQUENCE", &gCvars.LAGFAST, 0, 1000);
+		hoodrich.AddElement(DROPDOWN, -20, L"      KEYBIND", &gCvars.LAGKEY);
+		hoodrich.RestartSection();
+		hoodrich.SetValueNames(fuckingkeynames, fuckingkeyvalues, 5);
+		hoodrich.AddElement(ADDER, iRowTwo -14, L"      OVERSPED", &gCvars.SPEEDFAST, 0, 10);
+		hoodrich.AddElement(DROPDOWN, iRowTwo -14, L"      KEYBIND", &gCvars.SPEEDKEY);
+
+
+		msRemovals.Draw(iUsualX, m_y + 100, m_w - 175, 140);
+		msRemovals.AddElement(ONOFF, -17, L"     BUNNYHOP", &gCvars.AUTOBH);
+		msRemovals.AddElement(ONOFF, -17, L"     VELOCITY", &gCvars.velocity);
+		msRemovals.AddElement(ONOFF, -17, L"     RADAR", &gCvars.radar);
+		msRemovals.AddElement(ONOFF, -17, L"     WATERMARK", &gCvars.watermark);
+		msRemovals.AddElement(ONOFF, -17, L"     NO VOMIT", &gCvars.NOVOMIT);
+		msRemovals.AddElement(ONOFF, -17, L"     MONITOR", &gCvars.drawmonitor);
+
+		msskinss.Draw(iUsualX + 120, m_y + 100, m_w - 142, 140);
+
+		msskinss.AddElement(ONOFF, -9, L"   TRIGGERBOT", &gCvars.trigenable);
+		msskinss.AddElement(ONOFF, -9, L"   TRIG HEAD", &gCvars.trighead);
+		msskinss.AddElement(ONOFF, -9, L"   TRIG BODY", &gCvars.triggerbody);
+		msskinss.AddElement(ONOFF, -9, L"   TRIG LIMB", &gCvars.TRIGLIMB);
+		msskinss.SetValueNames(fuckingkeynames, fuckingkeyvalues, 5);
+		msskinss.AddElement(DROPDOWN, -10, L"    KEY BIND", &gCvars.triggerkey);
+		msskinss.AddElement(ADDER, -10, L"    DELAY", &gCvars.trigerdelay, 1, 150);
+
+		hoodrich.PostSection();
+		msskinss.PostSection();
+		msRemovals.PostSection();
+		break;
+	}
+}
+
+int iNubLoop[] = {22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+
+void cMenu::DrawTab(int index, int &setindex, int x, int y, const char *pszTitle)
+{
+	static int iWidth = 90;
+	static int iHeight = 22;
+
+	bool bOverTri = false;
+
+	bool bOverBack = g_Mouse.IsOver(x + iHeight, y - iHeight, iWidth + 1 - iHeight, iHeight + 1);
+
+	bool bSame = setindex == index;
+
+	for (int ax = 0; ax <= iHeight; ax++)
+	{
+		if (g_Mouse.IsOver(x + ax, y - ax, 2, ax) || g_Mouse.IsOver(x + iWidth + ax, y - iHeight, 2, iNubLoop[ax]))
+		{
+			bOverTri = true;
+			break;
+		}
+	}
+
+	for (int i = 0; i <= iHeight; i++)
+	{
+		if (bSame)
+		{
+			pSurface->DrawSetColor(COLOR7);
+
+			pSurface->DrawLine(x + i, y, x + iHeight + i, y - iHeight);
+			pSurface->DrawLine(x + iWidth + iHeight - i, y - iHeight, x + iWidth - i, y);
+
+			if (i == iHeight)
+				Draw::FillRGBA(x + iHeight, y - iHeight, iWidth - iHeight, iHeight + 1, COLOR7);
+		}
+		else
+		{
+			if (bOverBack || bOverTri)
+				pSurface->DrawSetColor(COLOR8);
+			else
+				pSurface->DrawSetColor(COLOR1);
+
+			pSurface->DrawLine(x + i, y, x + iHeight + i, y - iHeight);
+			pSurface->DrawLine(x + iWidth + iHeight - i, y - iHeight, x + iWidth - i, y);
+
+			if (g_Mouse.HasMouseOneJustBeenReleased() && (bOverBack || bOverTri))
+				setindex = index;
+
+			if (i == iHeight)
+			{
+				if (bOverBack || bOverTri)
+					Draw::FillRGBA(x + iHeight, y - iHeight, iWidth - iHeight, iHeight + 1, COLOR8);
+				else
+					Draw::FillRGBA(x + iHeight, y - iHeight, iWidth - iHeight, iHeight + 1, COLOR1);
+			}
+		}
+	}
+
+	pSurface->DrawSetColor(COLOR2);
+
+	pSurface->DrawLine(x, y, x + iHeight, y - iHeight);
+	pSurface->DrawLine(x + iHeight, y - iHeight, x + iWidth + iHeight + 1, y - iHeight);
+	pSurface->DrawLine(x + iWidth, y, x + iWidth + iHeight, y - iHeight);
+	pSurface->DrawLine(x, y, x + iWidth, y);
+	Draw::DrawStringA(Fonts::m_WatermarkFont, true, x + (iWidth + iHeight) * 0.5, y + 1 - iHeight, COLOR9, pszTitle);
+}
+
+void cMenu::DrawMenu()
+{
+	Draw::FillRGBA(m_x + 22, m_y - 22, 80 * NUM_OF_TABS + 20, 23, COLOR4);
+
+	pSurface->DrawSetColor(COLOR1);
+
+	DrawTab(AIMTAB, iTabIndex, m_x, m_y, "AIM");
+	DrawTab(ESPTAB, iTabIndex, m_x + 100, m_y, "VISUALS");
+	DrawTab(MISCTAB, iTabIndex, m_x + 200, m_y, "MISC");
+
+	Draw::FillRGBA(m_x, m_y + 1, m_w, m_h, COLOR3);
+	Draw::FillRGBA(m_x + 1, m_y + 2, m_w - 2, m_h - 2, COLOR4);
+	Draw::FillRGBA(m_x + 6, m_y + 7, m_w - 12, m_h - 12, COLOR3);
+	Draw::FillRGBA(m_x + 7, m_y + 8, m_w - 14, m_h - 14, COLOR5);
+	Draw::FillRGBA(m_x + 5, m_y + 6, m_w - 10, 17, COLOR3);
+	Draw::FillRGBA(m_x + 5, m_y + 7, m_w - 10, 15, COLOR5);
+
+    #define BUILDSTAMP ( L"BUILD DATE: " __DATE__ L" @ " __TIME__ )
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x + 15, m_y + 7, COLOR9, BUILDSTAMP);
+
+	Draw::FillRGBA(m_x - 15, m_y + 95, 15, 55, COLOR3);
+
+	if (g_Mouse.OneLeftClick(m_x - 14, m_y + 96, 14, 53)) //LOAD CFG
+	{
+		Config->Save();
+	}
+
+	if (g_Mouse.LeftClick(m_x - 14, m_y + 96, 14, 53))
+		Draw::FillRGBA(m_x - 15, m_y + 95, 15, 55, COLOR9);
+
+	Draw::FillRGBA(m_x - 14, m_y + 96, 14, 53, COLOR6);
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x - 10, m_y + 95, COLOR9, L"S");
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x - 10, m_y + 107, COLOR9, L"A");
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x - 10, m_y + 119, COLOR9, L"V");
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x - 10, m_y + 131, COLOR9, L"E");
+
+
+	Draw::FillRGBA(m_x + m_w, m_y + 95, 15, 55, COLOR3);
+
+	if (g_Mouse.OneLeftClick(m_x + m_w, m_y + 96, 14, 53)) //SAVE CFG
+	{
+		Config->Load();
+	}
+
+	if (g_Mouse.LeftClick(m_x + m_w, m_y + 96, 15, 55))
+		Draw::FillRGBA(m_x + m_w, m_y + 95, 15, 55, COLOR9);
+
+	Draw::FillRGBA(m_x + m_w, m_y + 96, 14, 53, COLOR6);
+
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x + m_w + 3, m_y + 95, COLOR9, L"L");
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x + m_w + 3, m_y + 107, COLOR9, L"O");
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x + m_w + 3, m_y + 119, COLOR9, L"A");
+	Draw::DrawTexts(Fonts::m_MenuFont, m_x + m_w + 3, m_y + 131, COLOR9, L"D");
+
+	InitMenuElements();
+}
+
+void cMenuSection::Draw(int x, int y, int w, int h)
+{
+	Draw::FillRGBA(x,y,10,1,COLOR2);
+	Draw::FillRGBA(x,y,1,h,COLOR2);
+	Draw::FillRGBA(x,y+h,w,1,COLOR2);
+	Draw::FillRGBA(x+w,y,1,h+1,COLOR2);
+	Draw::FillRGBA(x, y, w, 1, COLOR2);
+
+	SetSectionPos(x,y);
+}
+
+void cMenuSection::DrawAllDropDowns()
+{
+	int iNumOfDropDowns = vecDropDowns.size();
+
+	int iWhich = -1;
+
+	for(int i2 = (iNumOfDropDowns - 1); i2 >= 0; i2--)
+	{
+		bool bIsActive = bActiveDropDown[i2];
+
+		if(bIsActive)
+		{
+			iWhich = i2;
+
+			dwWait = GetTickCount() + 700;
+			break;
+		}
+	}
+
+	for(int i = (iNumOfDropDowns - 1); i >= 0; i--)
+	{
+		int e_x = vecDropDowns[i].x;
+		int e_y = vecDropDowns[i].y;
+		int iCount = vecDropDowns[i].iCount;
+
+		bool bIsActive = bActiveDropDown[i];
+
+		char **ppszNames = vecDropDowns[i].ppszNames;
+		float *fValues  = vecDropDowns[i].fValues;
+		float *cvar = vecDropDowns[i].cvar;
+
+		if(bIsActive)
+		{
+			int string_x = e_x + (DROPDOWN_WIDTH * 0.5);
+
+			for(int ax = 0; ax < iCount; ax++)
+			{
+				if(g_Mouse.IsOver(e_x,e_y + (ax * DROPDOWN_HEIGHT),DROPDOWN_WIDTH,DROPDOWN_HEIGHT))
+				{
+					if(!g_Menu.IsHandlingItem())
+						g_Menu.AddMenuFlag(FL_DISABLEDRAG);
+
+					Draw::FillRGBA(e_x + 1,e_y + 1 + (ax * DROPDOWN_HEIGHT),DROPDOWN_WIDTH - 1,DROPDOWN_HEIGHT - (ax == (iCount - 1) ? 1 : 0),COLOR5);
+					
+					if(g_Mouse.HasMouseOneJustBeenReleased())
+					{
+						*cvar = fValues[ax];
+
+						bActiveDropDown[i] = false;
+					}
+				}
+				else
+				{
+					Draw::FillRGBA(e_x + 1,e_y + 1 + (ax * DROPDOWN_HEIGHT),DROPDOWN_WIDTH - 1,DROPDOWN_HEIGHT - (ax == (iCount - 1) ? 1 : 0),COLOR4);
+				
+					if(g_Mouse.HasMouseOneJustBeenReleased())
+					{
+						bActiveDropDown[i] = false;
+					}
+				}
+
+				if(ax == (iCount - 1))
+					Draw::SoftOutlinedRectangle(e_x,e_y,DROPDOWN_WIDTH,(ax + 1) * DROPDOWN_HEIGHT,COLOR3);
+
+				if(*cvar == fValues[ax])
+					Draw::DrawStringA(Fonts::m_ListItemFont,true,string_x,e_y + (ax * DROPDOWN_HEIGHT),COLOR9,ppszNames[ax]);
+				else
+					Draw::DrawStringA(Fonts::m_ListItemFont,true,string_x,e_y + (ax * DROPDOWN_HEIGHT),LISTITEM_TEXTCOLOR,ppszNames[ax]);
+			}
+		}
+		else
+		{
+			if(g_Mouse.IsOver(e_x,e_y,DROPDOWN_WIDTH,DROPDOWN_HEIGHT))
+			{
+				if(!g_Menu.IsHandlingItem())
+					g_Menu.AddMenuFlag(FL_DISABLEDRAG);
+
+				Draw::FillRGBA(e_x + 1,e_y + 1,DROPDOWN_WIDTH - 1,DROPDOWN_HEIGHT - 1,COLOR5);
+
+				if(g_Mouse.HasMouseOneJustBeenReleased() && (dwWait < GetTickCount() || iWhich == -1))
+				{
+					bActiveDropDown[i] = true;
+				}
+			}
+			else
+				Draw::FillRGBA(e_x + 1,e_y + 1,DROPDOWN_WIDTH - 1,DROPDOWN_HEIGHT - 1,COLOR4);
+
+			Draw::SoftOutlinedRectangle(e_x,e_y,DROPDOWN_WIDTH,DROPDOWN_HEIGHT,COLOR3);
+
+			int string_x = e_x + (DROPDOWN_WIDTH * 0.5);
+			int string_y = e_y;
+
+			for(int ax = 0; ax < iCount; ax++)
+			{
+				if(*cvar == fValues[ax])
+				{
+					Draw::DrawStringA(Fonts::m_ListItemFont,true,string_x,string_y,LISTITEM_TEXTCOLOR,ppszNames[ax]);
+					break;
+				}
+			}
+		}
+	}
+
+	ClearAllElementSpecifics();
+}
+
+void cMenuSection::AddElement(int iType, int add_to_x, const wchar_t *pszElementName, float *cvar, float min, float max, float step)
+{
+	int e_x = s_x + 10 + add_to_x;
+	int e_y = s_y + 15 + (iSection * ELEMENT_SEPERATION);
+
+	bool bDropDownActive = false;
+
+	for (int i2 = 0; i2 < 50; i2++)
+	{
+		bDropDownActive = bActiveDropDown[i2];
+
+		if (bDropDownActive)
+			break;
+	}
+
+	if (iType == ONOFF)
+	{
+		Draw::DrawTexts(Fonts::m_WatermarkFont, e_x, e_y, LISTITEM_TEXTCOLOR, pszElementName);
+
+		e_x += CHECKBOX_SEPERATION_FROM_TEXT;
+
+		if (g_Mouse.OneLeftClick(e_x - 3, e_y - 3, CHECKBOX_SIZE + 5, CHECKBOX_SIZE + 5) && !bDropDownActive)
+			*cvar = !*cvar;
+
+		e_y += 1;
+
+		Draw::FillRGBA(e_x, e_y, CHECKBOX_SIZE, CHECKBOX_SIZE, COLOR7);
+
+		if (*cvar)
+		{
+			pSurface->DrawSetColor(COLOR4);
+
+			pSurface->DrawLine(e_x + 2, e_y + 2, e_x + CHECKBOX_SIZE - 1, e_y + CHECKBOX_SIZE - 1);
+			pSurface->DrawLine(e_x + CHECKBOX_SIZE - 2, e_y + 2, e_x + 1, e_y + CHECKBOX_SIZE - 1);
+		}
+
+		if (g_Mouse.IsOver(e_x, e_y, CHECKBOX_SIZE, CHECKBOX_SIZE))
+		{
+			Draw::OutlinedRectangle(e_x, e_y, CHECKBOX_SIZE, CHECKBOX_SIZE, COLOR9);
+
+			if (!g_Menu.IsHandlingItem())
+				g_Menu.AddMenuFlag(FL_DISABLEDRAG);
+		}
+		else
+			Draw::OutlinedRectangle(e_x, e_y, CHECKBOX_SIZE, CHECKBOX_SIZE, COLOR4);
+	}
+	else if (iType == DROPDOWN)
+	{
+		Draw::DrawTexts(Fonts::m_WatermarkFont, e_x, e_y, LISTITEM_TEXTCOLOR, pszElementName);
+
+		e_y += 1;
+
+		DropDown_t ddNew;
+
+		ddNew.x = e_x + CHECKBOX_SEPERATION_FROM_TEXT - 20;
+		ddNew.y = e_y - 2;
+		ddNew.fValues = fValueList;
+		ddNew.cvar = cvar;
+		ddNew.ppszNames = ppszValueNames;
+		ddNew.iCount = iValueCount;
+
+		AddDropDownToDrawList(ddNew);
+	}
+	else if (iType == SLIDER)
+	{
+		float Scale = max / 245;
+
+		bool bOver = false;
+
+
+		wchar_t szCopy[256];
+
+		wcscpy_s(szCopy, pszElementName);
+		swprintf_s(szCopy, L"%s %2.2f", pszElementName, *cvar);
+
+		Draw::DrawTexts(Fonts::m_WatermarkFont, e_x, e_y - 7, LISTITEM_TEXTCOLOR, szCopy);
+
+
+		e_y += 8;
+
+		Draw::FillRGBA(e_x + 3, e_y + 7, 240, 1, 115, 120, 123, 185);
+
+		int mouse_x, mouse_y;
+		g_Mouse.GetMousePosition(mouse_x, mouse_y);
+
+		if (mouse_x >= (e_x - 3) && mouse_x <= (e_x + fLength + 3) && mouse_y >= (e_y) && mouse_y <= (e_y + 10) && GetAsyncKeyState(VK_LBUTTON) && (iSliderIndex == -1) && dwWait < GetTickCount() && !bSliderFix[iCurrSlider])
+		{
+			iSliderIndex = iCurrSlider;
+			bSliderFix[iCurrSlider] = true;
+
+			if (!g_Menu.IsHandlingItem())
+				g_Menu.AddMenuFlag(FL_DISABLEDRAG);
+		}
+
+		if (mouse_x >= (e_x - 1000) && mouse_x <= (e_x + fLength + 1000) && mouse_y >= (e_y - 1000) && mouse_y <= (e_y + 1000) && GetAsyncKeyState(VK_LBUTTON) && !bDropDownActive)
+		{
+			if (bSliderFix[iCurrSlider])
+			{
+				*cvar = min + (mouse_x - e_x) * Scale;
+
+				bOver = true;
+
+				if (!g_Menu.IsHandlingItem())
+					g_Menu.AddMenuFlag(FL_DISABLEDRAG);
+			}
+		}
+		else if (bSliderFix[iCurrSlider])
+		{
+			iSliderIndex = -1;
+			bSliderFix[iCurrSlider] = false;
+		}
+
+		if (*cvar > max)
+			*cvar = max;
+
+		if (*cvar < min)
+			*cvar = min;
+
+		static int iSizeOf = 6;
+
+		for (int nu = 0; nu <= iSizeOf; nu++)
+		{
+			Draw::FillRGBA(e_x + (*cvar / Scale) - iSizeOf + nu, e_y + iSizeOf - nu, (iSizeOf + 1) - nu, 1, COLOR4);
+			Draw::FillRGBA(e_x + (*cvar / Scale) - iSizeOf + nu, e_y + iSizeOf + nu, (iSizeOf + 1) - nu, 1, COLOR4);
+
+			Draw::FillRGBA(e_x + (*cvar / Scale), e_y + iSizeOf - nu, (iSizeOf + 1) - nu, 1, COLOR4);
+			Draw::FillRGBA(e_x + (*cvar / Scale), e_y + iSizeOf + nu, (iSizeOf + 1) - nu, 1, COLOR4);
+		}
+
+		if (g_Mouse.IsOver(e_x + (*cvar / Scale) - iSizeOf, e_y - 1, 10, 14) || bOver)
+			pSurface->DrawSetColor(COLOR9);
+		else
+			pSurface->DrawSetColor(COLOR6);
+
+		pSurface->DrawLine(e_x + (*cvar / Scale) - (iSizeOf + 1), e_y + iSizeOf, e_x + (*cvar / Scale), e_y - 1);
+		pSurface->DrawLine(e_x + (*cvar / Scale), e_y - 1, e_x + (*cvar / Scale) + (iSizeOf + 1), e_y + iSizeOf);
+		pSurface->DrawLine(e_x + (*cvar / Scale) + (iSizeOf + 1), e_y + iSizeOf, e_x + (*cvar / Scale), e_y + (iSizeOf * 2 + 1));
+		pSurface->DrawLine(e_x + (*cvar / Scale), e_y + (iSizeOf * 2 + 1), e_x + (*cvar / Scale) - (iSizeOf + 1), e_y + iSizeOf);
+	}
+	else if (iType == ADDER)
+	{
+
+	    Draw::DrawTexts(Fonts::m_WatermarkFont, e_x, e_y, LISTITEM_TEXTCOLOR, pszElementName);
+
+		e_y += 1;
+
+		e_x += (CHECKBOX_SEPERATION_FROM_TEXT - 20);
+
+		Draw::FillRGBA(e_x, e_y, ADDER_SIZE, ADDER_SIZE, COLOR7);
+
+		if (g_Mouse.IsOver(e_x, e_y, ADDER_SIZE, ADDER_SIZE))
+		{
+			Draw::OutlinedRectangle(e_x, e_y, ADDER_SIZE, ADDER_SIZE, COLOR9);
+
+			if (g_Mouse.HasMouseOneJustBeenReleased() && !bDropDownActive)
+				*cvar -= step;
+
+			if (g_Mouse.IsMouseTwoBeingHeld() && !bDropDownActive)
+				*cvar -= 1;
+		}
+		else
+			Draw::OutlinedRectangle(e_x, e_y, ADDER_SIZE, ADDER_SIZE, COLOR4);
+
+		Draw::DrawStringA(Fonts::m_ListItemFont, true, e_x + ADDER_SIZE * 0.5, e_y - 1, COLOR9, "<");
+
+		Draw::DrawStringA(Fonts::m_WatermarkFont, true, e_x - 6 + ADDER_SIZE + ADDER_SEPERATE_FROM_BOXES * 0.5, e_y - 2, LISTITEM_TEXTCOLOR, "%2.0f", *cvar);
+
+		e_x += ADDER_SEPERATE_FROM_BOXES;
+
+		Draw::FillRGBA(e_x, e_y, ADDER_SIZE, ADDER_SIZE, COLOR7);
+
+		if (g_Mouse.IsOver(e_x, e_y, ADDER_SIZE, ADDER_SIZE))
+		{
+			Draw::OutlinedRectangle(e_x, e_y, ADDER_SIZE, ADDER_SIZE, COLOR9);
+
+			if (g_Mouse.HasMouseOneJustBeenReleased() && !bDropDownActive)
+				*cvar += step;
+
+			if (g_Mouse.IsMouseTwoBeingHeld() && !bDropDownActive)
+				*cvar += 1;
+		}
+		else
+			Draw::OutlinedRectangle(e_x, e_y, ADDER_SIZE, ADDER_SIZE, COLOR4);
+
+
+		Draw::DrawStringA(Fonts::m_ListItemFont, true, e_x + ADDER_SIZE * 0.5, e_y - 1, COLOR9, ">");
+
+		//clamp but go to min,max instead of not allowing to increase/decrease
+		if (*cvar < min)
+			*cvar = max;
+
+		if (*cvar > max)
+			*cvar = min;
+	}
+
+	PostElement((iType == SLIDER ? 2 : 1));
+}

menu.h

@@ -0,0 +1,172 @@
+
+
+#define NUM_OF_TABS 3
+
+enum
+{
+	FL_DISABLEDRAG = (1 << 1)
+};
+
+enum
+{
+	AIMTAB,
+	ESPTAB,
+	MISCTAB
+};
+
+enum
+{
+	ONOFF,
+	DROPDOWN,
+	SLIDER,
+	ADDER
+};
+
+typedef struct DropDown_s
+{
+	int x, y;
+	int iCount;
+
+	float *fValues;
+	float *cvar;
+
+	char **ppszNames;
+} DropDown_t;
+
+class cMenuSection
+{
+public:
+	void Draw(int x, int y, int w, int h);
+
+	void AddElement(int iType, int add_to_x, const wchar_t *pszElementName, float *cvar, float min = 0, float max = 1, float step = 1);
+
+	void DrawAllDropDowns();
+
+	void PostSection()
+	{
+		DrawAllDropDowns();
+	}
+
+	void ClearSection()
+	{
+		vecDropDowns.clear();
+
+		RestartSection();
+	}
+
+	void RestartSection()
+	{
+		iSection = 0;
+	}
+
+	void PostElement(int increment = 1)
+	{
+		iSection += increment;
+	}
+	
+	void SetSlider(int &iCurrentSlider, bool bColor = false, float fLen = 360.0f)
+	{
+		bColored = bColor;
+
+		fLength = fLen;
+		
+		iCurrentSlider++;
+	}
+
+	void SetSectionPos(int x, int y)
+	{
+		s_x = x;
+		s_y = y;
+	}
+
+	void SetValueNames(char **szArrayArray, float *fArray, int iCount)
+	{
+		ppszValueNames = szArrayArray;
+		fValueList = fArray;
+		iValueCount = iCount;
+	}
+
+	void ClearAllElementSpecifics()
+	{
+		SetValueNames(NULL,NULL,0);
+	}
+
+private:
+	void AddDropDownToDrawList(DropDown_t ddNew)
+	{
+		vecDropDowns.push_back(ddNew);
+	}
+
+	int iSection;
+	int s_x, s_y;
+
+	//dropdown specifics
+	//----------------------
+	float *fValueList;
+	char **ppszValueNames;
+	int iValueCount;
+	bool bActiveDropDown[50];
+	std::vector<DropDown_t> vecDropDowns;
+	//----------------------
+
+	//slider specifics
+	//----------------------
+	bool bColored;
+	float fLength;
+};
+
+class cMenu
+{
+public:
+	cMenu(int x, int y, int w, int h);
+
+	void InitMenuElements();
+
+	void DrawMenu();
+
+	void SetMenuPos(int x, int y)
+	{
+		m_x = x;
+		m_y = y;
+	}
+
+	void GetMenuPos(int &out_x, int &out_y)
+	{
+		out_x = m_x;
+		out_y = m_y;
+	}
+
+	void GetMenuSize(int &out_w, int &out_h)
+	{
+		out_w = m_w;
+		out_h = m_h;
+	}
+
+	bool IsHandlingItem()
+	{
+		return (iMenuFlags & FL_DISABLEDRAG);
+	}
+
+	void AddMenuFlag(int iFlag)
+	{
+		iMenuFlags |= iFlag;
+	}
+
+	void RemoveMenuFlag(int iFlag)
+	{
+		iMenuFlags &= ~iFlag;
+	}
+
+	int GetTabIndex()
+	{
+		return iTabIndex;
+	}
+private:
+	void DrawTab(int index, int &setindex, int x, int y, const char *pszTitle);
+
+	int m_x, m_y, m_w, m_h;
+	int iMenuFlags;
+	int iTabIndex;
+};
+
+extern cMenu g_Menu;

model.h

@@ -0,0 +1,60 @@
+
+void OverridematerialXQZ(IMaterial* mat, float r, float g, float b)
+{
+	mat->SetMaterialVarFlag(IGNOREZ, true);
+	mat->SetMaterialVarFlag(ZNEARER, true);
+	mat->SetMaterialVarFlag(NOCULL, true);
+	mat->SetMaterialVarFlag(NOFOG, true);
+	mat->SetMaterialVarFlag(HALFLAMBERT, true);
+	mat->ColorModulate(r / 255, g / 255, b / 255);
+	pModelRender->ForcedMaterialOverride(mat);
+}
+
+void Overridematerial(IMaterial* mat, float r, float g, float b)
+{
+	mat->SetMaterialVarFlag(IGNOREZ, false);
+	mat->SetMaterialVarFlag(ZNEARER, true);
+	mat->SetMaterialVarFlag(NOCULL, true);
+	mat->SetMaterialVarFlag(NOFOG, true);
+	mat->SetMaterialVarFlag(HALFLAMBERT, true);
+	mat->ColorModulate(r / 255, g / 255, b / 255);
+	pModelRender->ForcedMaterialOverride(mat);
+}
+
+typedef void(__thiscall *DrawModelExecuteFn)(IVModelRender*, void*, const ModelRenderInfo_t&, matrix3x4_t*);
+DrawModelExecuteFn draw_model_original = nullptr;
+
+void __stdcall hkDrawModelExecute(void* state, const ModelRenderInfo_t &pInfo, matrix3x4_t *pCustomBoneToWorld)
+{
+	static IMaterial* material = pMaterialSystem->FindMaterial("debug/debugambientcube", "Model textures");
+	static IMaterial* vomitboomer = pMaterialSystem->FindMaterial(("particle/screenspaceboomervomit"), "Particle textures");
+
+	if (pInfo.pModel && pInfo.entity_index && material && vomitboomer)
+	{
+		const char *pszModelName = pModel->GetModelName(pInfo.pModel);
+		CBaseEntity* pEntity = (CBaseEntity*)pEntList->GetClientEntity(pInfo.entity_index);
+
+		vomitboomer->SetMaterialVarFlag(NO_DRAW, gCvars.NOVOMIT);
+
+		if (gCvars.CHAMHAND && pszModelName && strstr(pszModelName, "models/weapons/arms/v_arms"))
+		{
+			Overridematerial(material, gCvars.espcolor[0], gCvars.espcolor[1], gCvars.espcolor[2]);
+		}
+
+		if (gCvars.CHAMS && pEntity)
+		{
+			if (pEntity->GetTeamNum() == TEAM_ZOMBY && pEntity->GetGroup() && pEntity->ValidEntity())
+			{
+				if (gCvars.CHAMSXQZ)
+				{
+					OverridematerialXQZ(material, gCvars.espcolor[1], gCvars.espcolor[2], gCvars.espcolor[0]);
+					draw_model_original(pModelRender, state, pInfo, pCustomBoneToWorld);
+				}
+				Overridematerial(material, gCvars.espcolor[0], gCvars.espcolor[1], gCvars.espcolor[2]);
+			}
+		}
+	}
+
+	draw_model_original(pModelRender, state, pInfo, pCustomBoneToWorld);
+	pModelRender->ForcedMaterialOverride(nullptr);
+}

modelsinfo.h

@@ -0,0 +1,67 @@
+#pragma once
+
+enum
+{
+	HITGROUP_GENERIC = 0,
+	HITGROUP_HEAD = 1,
+	HITGROUP_CHEST = 2,
+	HITGROUP_STOMACH = 3,
+	HITGROUP_LEFTARM = 4,
+	HITGROUP_RIGHTARM = 5,
+	HITGROUP_LEFTLEG = 6,
+	HITGROUP_RIGHTLEG = 7,
+	HITGROUP_GEAR = 10,
+};
+
+struct mstudiobbox
+{
+	int         bone;
+	int         group;
+	Vector		bbmin;
+	Vector		bbmax;
+	int         szhitboxnameindex;
+	int         unused[8];
+};
+
+struct mstudiohitboxset
+{
+	int                   sznameindex;
+	inline char* const    pszName(void) const { return ((char*)this) + sznameindex; }
+	int                   numhitboxes;
+	int                   hitboxindex;
+	inline mstudiobbox*   pHitbox(int i) const { return (mstudiobbox*)(((BYTE*)this) + hitboxindex) + i; };
+};
+
+struct studiohdr
+{
+	unsigned char     pad[0xAC];
+	int               numhitboxsets;
+	int               hitboxsetindex;
+
+	mstudiohitboxset* pHitboxSet(int i) const
+	{
+		return (mstudiohitboxset*)(((BYTE*)this) + hitboxsetindex) + i;
+	};
+
+	inline int GetHitboxCount(int set) const
+	{
+		mstudiohitboxset const* s = pHitboxSet(set);
+		if (!s)
+			return 0;
+		return s->numhitboxes;
+	}
+};
+
+class CModelInfo
+{
+public:
+	inline const char* GetModelName(const void* Model)
+	{
+		return getvfunc<const char*(__thiscall *)(void*, const void*)>(this, 3)(this, Model);
+	}
+	studiohdr* GetStudiomodel(const DWORD *mod)
+	{
+		typedef studiohdr* (__thiscall* GetStudiomodelFn)(void*, const DWORD*);
+		return getvfunc< GetStudiomodelFn >(this, 30)(this, mod);
+	}
+};

mouse.cpp

@@ -0,0 +1,100 @@
+#include "hooks.h"
+
+cMouse g_Mouse;
+
+void cMouse::Drag(bool& bDrag, bool bCheck, bool bDragCheck,int& x, int& y, int& xdif, int& ydif)
+{
+	if(bCheck)								  
+	{					
+		if(bDragCheck || (mouse1pressed && bDrag))		  
+		{
+			if(!bDrag)					  
+				bDrag = true;
+
+			if(xdif == -1 || ydif == -1)	  
+			{							
+				xdif = mouse_x - x;	  
+				ydif = mouse_y - y;	  
+			}
+
+			x += mouse_x - (xdif + x); 
+			y += mouse_y - (ydif + y); 
+		}									  
+		else								  
+		{			
+			if(bDrag)
+				bDrag = false;
+
+			xdif = -1;						  
+			ydif = -1;						  
+		}									  
+	}
+}
+
+bool cMouse::LeftClick(int x,int y,int w,int h)
+{
+	return (mouse1pressed && IsOver(x,y,w,h));
+}
+
+bool cMouse::OneLeftClick(int x,int y,int w,int h)
+{
+	return (mouse1released && IsOver(x,y,w,h));
+}
+
+bool cMouse::IsOver(int x,int y,int w,int h)
+{
+	return (mouse_x > x  && w+x > mouse_x && mouse_y > y  && h+y > mouse_y);
+}
+
+void cMouse::Update()
+{
+	int width, height;
+	pEngine->GetScreenSize(width, height);
+
+	static auto window = FindWindowA(0, "Valve001");
+
+	tagPOINT tp;
+	GetCursorPos(&tp);
+
+	LPPOINT pPoint = &tp;
+	ScreenToClient(window, pPoint);
+
+	mouse_x = pPoint->x;
+	mouse_y = pPoint->y;
+
+	if (mouse_x > width)
+		mouse_x = width;
+
+	if (mouse_x < 0)
+		mouse_x = 0;
+
+	if (mouse_y > height)
+		mouse_y = height;
+
+	if (mouse_y < 0)
+		mouse_y = 0;
+
+	if (GetAsyncKeyState(VK_LBUTTON))
+		mouse1pressed = true;
+	else if (!GetAsyncKeyState(VK_LBUTTON))
+	{
+		if (mouse1pressed)
+			mouse1released = true;
+		else
+			mouse1released = false;
+
+		mouse1pressed = false;
+	}
+
+	if (GetAsyncKeyState(VK_RBUTTON))
+		mouse2pressed = true;
+	else if (!GetAsyncKeyState(VK_RBUTTON))
+	{
+		if (mouse2pressed)
+			mouse2released = true;
+		else
+			mouse2released = false;
+
+		mouse2pressed = false;
+	}
+}

mouse.h

@@ -0,0 +1,42 @@
+#define MAX_DRAG_OBJECTS 3
+
+class cMouse
+{
+public:
+	void Update();
+
+	bool LeftClick(int x,int y,int w,int h);
+	bool OneLeftClick(int x,int y,int w,int h);
+	bool IsOver(int x,int y,int w,int h);
+
+	void Drag(bool& bDrag, bool bCheck, bool bDragCheck,int& x, int& y, int& xdif, int& ydif);
+
+	void GetMousePosition(int &posx, int &posy)
+	{
+		posx = mouse_x;
+		posy = mouse_y;
+	}
+
+	bool HasMouseOneJustBeenReleased()
+	{
+		return mouse1released;
+	}
+
+	bool IsMouseTwoBeingHeld()
+	{
+		return mouse2pressed;
+	}
+
+	bool bDragged[MAX_DRAG_OBJECTS];
+	int iDiffX[MAX_DRAG_OBJECTS];
+	int iDiffY[MAX_DRAG_OBJECTS];
+
+	int mouse_x, mouse_y;
+private:
+	bool mouse1pressed;
+	bool mouse2pressed;
+	bool mouse2released;
+	bool mouse1released;
+};
+
+extern cMouse g_Mouse;

netvars.cpp

@@ -0,0 +1,141 @@
+
+#include "hooks.h"
+
+Netvarmanager g_Netvarmanager;
+
+void Netvarmanager::Init(void)
+{
+	m_tables.clear();
+	m_savedproxy.clear();
+
+	ClientClass *clientClass = pClient->GetAllClasses();
+
+	if (!clientClass)
+	{
+		return;
+	}
+
+	while (clientClass)
+	{
+		RecvTable *recvTable = clientClass->GetTable;
+
+		m_tables.push_back(recvTable);
+
+		clientClass = clientClass->NextClass;
+	}
+}
+
+Netvarmanager::~Netvarmanager(void)
+{
+	for (int i = 0; i < m_savedproxy.size(); i++)
+	{
+		RecvProp *recvProp = 0;
+		Get_Prop(m_savedproxy[i].szTableName, m_savedproxy[i].szPropName, &recvProp);
+
+		if (!recvProp)
+			return;
+
+		recvProp->m_ProxyFn = m_savedproxy[i].SavedProxy;
+	}
+}
+
+int Netvarmanager::GetOffset(const char *tableName, const char *propName)
+{
+	int offset = Get_Prop(tableName, propName);
+
+	if (!offset)
+	{
+		return 0;
+	}
+
+	return offset;
+}
+
+
+int Netvarmanager::Get_Prop(const char *tableName, const char *propName, RecvProp **prop)
+{
+	RecvTable *recvTable = GetTable(tableName);
+
+	if (!recvTable)
+	{
+		return 0;
+	}
+
+
+	int offset = Get_Prop(recvTable, propName, prop);
+
+	if (!offset)
+	{
+		return 0;
+	}
+
+
+	return offset;
+}
+
+
+int Netvarmanager::Get_Prop(RecvTable *recvTable, const char *propName, RecvProp **prop)
+{
+	int extraOffset = 0;
+
+	for (int i = 0; i < recvTable->m_nProps; ++i)
+	{
+		RecvProp *recvProp = &recvTable->m_pProps[i];
+
+
+		RecvTable *child = recvProp->m_pDataTable;
+
+		if (child
+			&& (child->m_nProps > 0))
+		{
+			int tmp = Get_Prop(child, propName, prop);
+
+			if (tmp)
+			{
+				extraOffset += (recvProp->m_Offset + tmp);
+			}
+		}
+
+
+		if (_stricmp(recvProp->m_pVarName, propName))
+		{
+			continue;
+		}
+
+
+		if (prop)
+		{
+			*prop = recvProp;
+		}
+
+		return (recvProp->m_Offset + extraOffset);
+	}
+
+	return extraOffset;
+}
+
+
+RecvTable *Netvarmanager::GetTable(const char *tableName)
+{
+	if (m_tables.empty())
+	{
+		return 0;
+	}
+
+
+	for each (RecvTable *table in m_tables)
+	{
+		if (!table)
+		{
+			continue;
+		}
+
+
+		if (_stricmp(table->m_pNetTableName, tableName) == 0)
+		{
+			return table;
+		}
+	}
+
+	return 0;
+}

netvars.h

@@ -0,0 +1,24 @@
+#pragma once
+
+typedef struct
+{
+	char szTableName[256];
+	char szPropName[256];
+	RecvVarProxyFn SavedProxy;
+} Oldproxy_t;
+
+class Netvarmanager
+{
+public:
+	~Netvarmanager(void);
+	void Init();
+	int GetOffset(const char *tableName, const char *propName);
+private:
+	int Get_Prop(const char *tableName, const char *propName, RecvProp **prop = 0);
+	int Get_Prop(RecvTable *recvTable, const char *propName, RecvProp **prop = 0);
+	RecvTable *GetTable(const char *tableName);
+	std::vector<RecvTable*> m_tables;
+	std::vector<Oldproxy_t> m_savedproxy;
+};
+
+extern Netvarmanager g_Netvarmanager;

panel.h

@@ -0,0 +1,152 @@
+#pragma once
+
+bool bMenu = false;
+
+using paint_traverse_t = void(__thiscall *)(void*, unsigned int, bool, bool);
+paint_traverse_t painttraverse_original = nullptr;
+
+void __fastcall hkPaintTraverse(void* pPanels, int edx, unsigned int vguiPanel, bool forceRepaint, bool allowForce)
+{
+	painttraverse_original(pPanels, vguiPanel, forceRepaint, allowForce);
+
+	CBaseEntity* pLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
+
+	if (!pLocal)//superior way of checking if we are ingame
+	{
+		static unsigned int FocusOverlayPanel = 0;
+
+		static bool FoundPanel = false;
+
+		if (!FoundPanel)
+		{
+			PCHAR szPanelName = (PCHAR)pPanel->GetName(vguiPanel);
+			if (strstr(szPanelName, "MainMenu"))
+			{
+				FocusOverlayPanel = vguiPanel;
+
+				FoundPanel = true;
+			}
+		}
+		else if (FocusOverlayPanel == vguiPanel)
+		{
+			if (GetAsyncKeyState(VK_DELETE) & 1)
+				bMenu = !bMenu;
+
+			if (gCvars.watermark)
+			{
+				Draw::DrawTexts(Fonts::m_MenuFont, 20, 20, 255, 255, 255, 255, L"INTERWEBZ");
+			}
+
+			if (bMenu)
+			{
+				g_Mouse.Update();
+
+				int copy_x, copy_y;
+				int copy_w, copy_h;
+
+				g_Menu.GetMenuPos(copy_x, copy_y);
+				g_Menu.GetMenuSize(copy_w, copy_h);
+
+				g_Menu.DrawMenu();
+
+				g_Mouse.Drag(g_Mouse.bDragged[0],
+					!g_Menu.IsHandlingItem(),
+					g_Mouse.LeftClick(copy_x, copy_y, copy_w, copy_h), copy_x, copy_y, g_Mouse.iDiffX[0], g_Mouse.iDiffY[0]);
+
+				g_Menu.SetMenuPos(copy_x, copy_y);
+
+				if (g_Menu.IsHandlingItem())
+					g_Menu.RemoveMenuFlag(FL_DISABLEDRAG);
+			}
+
+			if (!pLocal)
+			{
+				FoundPanel = false;
+			}
+		}
+	}
+
+	if (pLocal)//WERE INGAME LOL
+	{
+		static unsigned int FocusOverlayPanel = 0;
+
+		static bool FoundPanel = false;
+
+		if (!FoundPanel)
+		{
+			PCHAR szPanelName = (PCHAR)pPanel->GetName(vguiPanel);
+			if (strstr(szPanelName, "FocusOverlayPanel"))
+			{
+				FocusOverlayPanel = vguiPanel;
+
+				FoundPanel = true;
+			}
+		}
+		else if (FocusOverlayPanel == vguiPanel)
+		{
+			if (GetAsyncKeyState(VK_DELETE) & 1)
+				bMenu = !bMenu;
+
+			int iScreenWidth, iScreenHeight;
+			pEngine->GetScreenSize(iScreenWidth, iScreenHeight);
+
+			if (gCvars.ESPBOX || gCvars.ESPNAME || gCvars.ESPHEALTH)
+			{
+				ESP::draw(pLocal);
+			}
+
+			if (gCvars.watermark)
+			{
+				Draw::DrawTexts(Fonts::m_MenuFont, 20, 20, 255, 255, 255, 255, L"INTERWEBZ");
+			}
+
+			if (gCvars.radar)
+			{
+				ESP::DrawRadarBack(iScreenWidth, iScreenHeight);
+				ESP::drawradar(iScreenWidth, iScreenHeight, pLocal);
+			}
+
+			if (pLocal->IsAlive())
+			{
+				if (gCvars.velocity)
+				{
+					ESP::drawvelocity(iScreenWidth, iScreenHeight, pLocal);
+				}
+
+				if (gCvars.drawmonitor)
+				{
+					ESP::DrawMonitor(iScreenWidth, iScreenHeight, pLocal);
+				}
+			}
+
+			pPanel->SetMouseInputEnabled(vguiPanel, bMenu);
+
+			if (bMenu)
+			{
+				g_Mouse.Update();
+
+				int copy_x, copy_y;
+				int copy_w, copy_h;
+
+				g_Menu.GetMenuPos(copy_x, copy_y);
+				g_Menu.GetMenuSize(copy_w, copy_h);
+
+				g_Menu.DrawMenu();
+
+				g_Mouse.Drag(g_Mouse.bDragged[0],
+					!g_Menu.IsHandlingItem(),
+					g_Mouse.LeftClick(copy_x, copy_y, copy_w, copy_h), copy_x, copy_y, g_Mouse.iDiffX[0], g_Mouse.iDiffY[0]);
+
+				g_Menu.SetMenuPos(copy_x, copy_y);
+
+				if (g_Menu.IsHandlingItem())
+					g_Menu.RemoveMenuFlag(FL_DISABLEDRAG);
+			}
+
+			if (pLocal)
+			{
+				FoundPanel = false;
+			}
+		}
+	}
+}

panels.h

@@ -0,0 +1,17 @@
+
+
+
+class IPanel
+{
+public:
+	void SetMouseInputEnabled(unsigned int iPanel, bool bState)
+	{
+		return (getvfunc<void(__thiscall*)(PVOID, int, bool)>(this, 32))(this, iPanel, bState);
+	}
+
+	const char *GetName(unsigned int vguiPanel)
+	{
+		typedef const char* (__thiscall* OriginalFn)(PVOID, unsigned int);
+		return getvfunc<OriginalFn>(this, 36)(this, vguiPanel);
+	}
+};

recvprop.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <Windows.h>
+
+struct RecvProp;
+
+class DVariant
+{
+public:
+	union
+	{
+		float	m_Float;
+		long	m_Int;
+		char	*m_pString;
+		void	*m_pData;
+		float	m_Vector[3];
+	};
+};
+
+namespace SourceEngine
+{
+	enum class SendPropType
+	{
+		DPT_Int = 0,
+		DPT_Float,
+		DPT_Vector,
+		DPT_VectorXY, // Only encodes the XY of a vector, ignores Z
+		DPT_String,
+		DPT_Array,     // An array of the base types (can't be of datatables).
+		DPT_DataTable,
+		DPT_Int64,
+		DPT_NUMSendPropTypes
+	};
+};
+
+class CRecvProxyData
+{
+public:
+	const RecvProp	*m_pRecvProp;
+	DVariant		m_Value;
+	int				m_iElement;
+	int				m_ObjectID;
+};
+
+typedef void(*RecvVarProxyFn)(const CRecvProxyData *pData, void *pStruct, void *pOut);
+
+struct RecvTable
+{
+	RecvProp		*m_pProps;
+	int				m_nProps;
+	void			*m_pDecoder;
+	char			*m_pNetTableName;
+	bool			m_bInitialized;
+	bool			m_bInMainList;
+};
+
+struct RecvProp
+{
+	char					*m_pVarName;
+	int						m_RecvType;
+	int						m_Flags;
+	int						m_StringBufferSize;
+	bool					m_bInsideArray;
+	const void				*m_pExtraData;
+	RecvProp				*m_pArrayProp;
+	void*					m_ArrayLengthProxy;
+	void*					m_ProxyFn;
+	void*					m_DataTableProxyFn;
+	RecvTable				*m_pDataTable;
+	int						m_Offset;
+	int						m_ElementStride;
+	int						m_nElements;
+	const char				*m_pParentArrayPropName;
+};
+
+struct ClientClass
+{
+	BYTE _chPadding[8];
+	char * GetName;
+	RecvTable * GetTable;
+	ClientClass * NextClass;
+	int GetClassID;
+};

sigs.cpp

@@ -0,0 +1,132 @@
+
+#include "sigs.h"
+
+DWORD Findrekt(std::string moduleName, std::string Mask)
+{
+	const char* pat = Mask.c_str();
+	DWORD firstMatch = 0;
+	DWORD rangeStart = (DWORD)GetModuleHandleA(moduleName.c_str());
+	MODULEINFO miModInfo; GetModuleInformation(GetCurrentProcess(), (HMODULE)rangeStart, &miModInfo, sizeof(MODULEINFO));
+	DWORD rangeEnd = rangeStart + miModInfo.SizeOfImage;
+	for (DWORD pCur = rangeStart; pCur < rangeEnd; pCur++)
+	{
+		if (!*pat)
+		{
+			return firstMatch;
+		}
+		if (*(PBYTE)pat == '\?' || *(BYTE*)pCur == getByte(pat))
+		{
+			if (!firstMatch)
+			{
+				firstMatch = pCur;
+			}
+
+			if (!pat[2])
+			{
+				return firstMatch;
+			}
+
+
+			if (*(PWORD)pat == '\?\?' || *(PBYTE)pat != '\?')
+			{
+				pat += 3;
+			}
+			else
+			{
+				pat += 2; //one ?
+			}
+
+		}
+		else
+		{
+			pat = Mask.c_str();
+			firstMatch = 0;
+		}
+	}
+	return NULL;
+}
+
+bool streq(const char *s1, const char *s2)
+{
+	for (; *s1 == *s2; s1++, s2++)
+	{
+		if (*s1 == '\0')
+			return true;
+	}
+
+	return false;
+}
+
+void *FindString(void *ptr, const char *string)
+{
+	char *start;
+	char *str = nullptr;
+
+	for (start = (char *)ptr; str == nullptr; start++)
+	{
+		if (streq(start, string))
+			str = start;
+	}
+
+	while (1)
+	{
+		if (*(char **)start == str)
+			return start;
+
+		start--;
+	}
+
+	return nullptr;
+}
+
+void *FindPattern(void *start, unsigned int len, const pattern *data)
+{
+	const char *pattern = (char *)data + 5;
+	const char *q = (char *)start;
+
+	for (int i = 0, mask = *(int *)((char *)data + 1); i < len; i++, q++)
+	{
+		const char *seq = pattern;
+		const char *mem = q;
+
+
+		register bool g = true;
+
+		for (int x = 0; x < 32; x++)
+		{
+			if ((mask & (1 << x)) && (mem[x] != *seq++))
+			{
+				g = false;
+				break;
+			}
+		}
+
+		if (g) return (void *)(q + (int)*(unsigned char *)data);
+	}
+
+	return nullptr;
+}
+
+void *FindPattern(const char *l, const pattern *data)
+{
+	return FindPattern(GetModuleHandle(l), -1, data);
+}
+
+void *FindProlog(void *ptr)
+{
+	unsigned char *ins = (unsigned char *)ptr;
+
+	while (ins > 0)
+	{
+		if ((ins[0] & 0xf0) == 0x50 &&
+			(ins[1] & 0xf0) == 0x80 &&
+			(ins[2] & 0x0f) == 0x0c)
+		{
+			return ins;
+		}
+
+		ins--;
+	}
+
+	return nullptr;
+}

sigs.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <Windows.h>
+#include <vector>
+#include <Psapi.h>
+
+#define INRANGE(x,a,b)    (x >= a && x <= b) 
+#define getBits( x )    (INRANGE((x&(~0x20)),'A','F') ? ((x&(~0x20)) - 'A' + 0xa) : (INRANGE(x,'0','9') ? x - '0' : 0))
+#define getByte( x )    (getBits(x[0]) << 4 | getBits(x[1]))
+
+class pattern;
+
+DWORD Findrekt(std::string moduleName, std::string Mask);
+void *FindString(void *, const char *);
+void *FindProlog(void *);
+void *FindPattern(void *, unsigned int, const pattern *);
+void *FindPattern(const char *, const pattern *);

surface.h

@@ -0,0 +1,74 @@
+
+
+class ISurface
+{
+public:
+
+	void DrawSetColor(int r, int g, int b, int a)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int, int, int, int);
+		getvfunc<OriginalFn>(this, 11)(this, r, g, b, a);
+	}
+
+	void DrawFilledRect(int x0, int y0, int x1, int y1)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int, int, int, int);
+		getvfunc<OriginalFn>(this, 12)(this, x0, y0, x1, y1);
+	}
+
+	void DrawOutlinedRect(int x0, int y0, int x1, int y1)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int, int, int, int);
+		getvfunc<OriginalFn>(this, 14)(this, x0, y0, x1, y1);
+	}
+
+	void DrawLine(int x0, int y0, int x1, int y1)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int, int, int, int);
+		getvfunc<OriginalFn>(this, 15)(this, x0, y0, x1, y1);
+	}
+
+	void DrawSetTextFont(unsigned long font)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, unsigned long);
+		getvfunc<OriginalFn>(this, 17)(this, font);
+	}
+
+	void DrawSetTextColor(int r, int g, int b, int a)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int, int, int, int);
+		getvfunc<OriginalFn>(this, 19)(this, r, g, b, a);
+	}
+
+	void DrawSetTextPos(int x, int y)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, int, int);
+		getvfunc<OriginalFn>(this, 20)(this, x, y);
+	}
+
+	void DrawPrintText(const wchar_t *text, int textLen)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, const wchar_t *, int, int);
+		return getvfunc<OriginalFn>(this, 22)(this, text, textLen, 0);
+	}
+
+	unsigned long Create_Font()
+	{
+		typedef unsigned int(__thiscall* OriginalFn)(PVOID);
+		return getvfunc<OriginalFn>(this, 63)(this);
+	}
+
+	void SetFontGlyphSet(unsigned long &font, const char *windowsFontName, int tall, int weight, int blur, int scanlines, int flags)
+	{
+		typedef void(__thiscall* OriginalFn)(PVOID, unsigned long, const char*, int, int, int, int, int, int, int);
+		getvfunc<OriginalFn>(this, 64)(this, font, windowsFontName, tall, weight, blur, scanlines, flags, 0, 0);
+	}
+
+	void GetTextSize(unsigned long font, const wchar_t *text, int &wide, int &tall)
+	{
+		typedef void(__thiscall* OriginalFn)(void*, unsigned long font, const wchar_t *text, int &wide, int &tall);
+		getvfunc<OriginalFn>(this, 72)(this, font, text, wide, tall);
+	}
+};
+
+

usercmd.h

@@ -0,0 +1,17 @@
+
+
+
+class CUserCmd
+{
+public:
+	virtual ~CUserCmd() {};
+	std::int32_t command_number;
+	std::int32_t tick_count;
+	Vector viewangles;
+	float forwardmove;
+	float sidemove;
+	float upmove;
+	std::int32_t buttons;
+};
+
+

variables.cpp

@@ -0,0 +1,95 @@
+#include "variables.h"
+
+void CConfig::Setup()
+{
+	SetupValue(gCvars.flRadarPos_x, false, ("Config"), ("flRadarPos_x"));
+	SetupValue(gCvars.flRadarPos_y, false, ("Config"), ("flRadarPos_y"));
+	SetupValue(gCvars.SMOOTHYAW, false, ("Config"), ("SMOOTHYAW"));
+	SetupValue(gCvars.SMOOTHPITCH, false, ("Config"), ("SMOOTHPITCH"));
+	SetupValue(gCvars.ENABLEAIM, false, ("Config"), ("ENABLEAIM"));
+	SetupValue(gCvars.AIMONFIRE, false, ("Config"), ("AIMONFIRE"));
+	SetupValue(gCvars.AIMFOV, false, ("Config"), ("AIMFOV"));
+	SetupValue(gCvars.NORECOIL, false, ("Config"), ("NORECOIL"));
+	SetupValue(gCvars.NOSPREAD, false, ("Config"), ("NOSPREAD"));
+	SetupValue(gCvars.AUTOFIRE, false, ("Config"), ("AUTOFIRE"));
+	SetupValue(gCvars.SILENTAIM, false, ("Config"), ("SILENTAIM"));
+	SetupValue(gCvars.ESPBOX, false, ("Config"), ("ESPBOX"));
+	SetupValue(gCvars.ESPNAME, false, ("Config"), ("ESPNAME"));
+	SetupValue(gCvars.ESPHEALTH, false, ("Config"), ("ESPHEALTH"));
+	SetupValue(gCvars.INGOREINFECTED, false, ("Config"), ("INGOREINFECTED"));
+	SetupValue(gCvars.CHAMS, false, ("Config"), ("CHAMS"));
+	SetupValue(gCvars.CHAMSXQZ, false, ("Config"), ("CHAMSXQZ"));
+	SetupValue(gCvars.CHAMHAND, false, ("Config"), ("CHAMHAND"));
+	SetupValue(gCvars.AUTOBH, false, ("Config"), ("AUTOBH"));
+	SetupValue(gCvars.AUTOFIRE, false, ("Config"), ("AUTOFIRE"));
+	SetupValue(gCvars.SILENTAIM, false, ("Config"), ("SILENTAIM"));
+	SetupValue(gCvars.radar, false, ("Config"), ("radar"));
+	SetupValue(gCvars.watermark, false, ("Config"), ("watermark"));
+	SetupValue(gCvars.velocity, false, ("Config"), ("velocity"));
+	SetupValue(gCvars.SILENTAIM, false, ("Config"), ("SILENTAIM"));
+	SetupValue(gCvars.triggerkey, false, ("Config"), ("triggerkey"));
+	SetupValue(gCvars.trigenable, false, ("Config"), ("trigenable"));
+	SetupValue(gCvars.trighead, false, ("Config"), ("trighead"));
+	SetupValue(gCvars.triggerbody, false, ("Config"), ("triggerbody"));
+	SetupValue(gCvars.trigerdelay, false, ("Config"), ("trigerdelay"));
+	SetupValue(gCvars.TRIGLIMB, false, ("Config"), ("TRIGLIMB"));
+	SetupValue(gCvars.NOVOMIT, false, ("Config"), ("NOVOMIT"));
+	SetupValue(gCvars.espcolor[0], false, ("Config"), ("espcolor0"));
+	SetupValue(gCvars.espcolor[1], false, ("Config"), ("espcolor1"));
+	SetupValue(gCvars.espcolor[2], false, ("Config"), ("espcolor2"));
+	SetupValue(gCvars.SPEEDKEY, false, ("Config"), ("SPEEDKEY"));
+	SetupValue(gCvars.SPEEDFAST, false, ("Config"), ("SPEEDFAST"));
+	SetupValue(gCvars.LAGKEY, false, ("Config"), ("LAGKEY"));
+	SetupValue(gCvars.LAGFAST, false, ("Config"), ("LAGFAST"));
+	SetupValue(gCvars.drawmonitor, false, ("Config"), ("drawmonitor"));
+	SetupValue(gCvars.f1monitorpos_x, false, ("Config"), ("f1monitorpos_x"));
+	SetupValue(gCvars.f1monitorpos_y, false, ("Config"), ("f1monitorpos_y"));
+}
+
+void CConfig::SetupValue(float &value, float def, std::string category, std::string name)
+{
+	value = def;
+	floats.push_back(new ConfigValue<float>(category, name, &value));
+}
+
+void CConfig::Save()
+{
+	static TCHAR path[MAX_PATH];
+	std::string folder, file;
+
+	if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, path)))
+	{
+		folder = std::string(path) + ("\\l4d2hack\\");
+		file = std::string(path) + ("\\l4d2hack\\config.ini");
+	}
+
+	CreateDirectory(folder.c_str(), NULL);
+
+	for (auto value : floats)
+		WritePrivateProfileString(value->category.c_str(), value->name.c_str(), std::to_string(*value->value).c_str(), file.c_str());
+}
+
+void CConfig::Load()
+{
+	static TCHAR path[MAX_PATH];
+	std::string folder, file;
+
+	if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, path)))
+	{
+		folder = std::string(path) + ("\\l4d2hack\\");
+		file = std::string(path) + ("\\l4d2hack\\config.ini");
+	}
+
+	CreateDirectory(folder.c_str(), NULL);
+
+	char value_l[32] = { '\0' };
+
+	for (auto value : floats)
+	{
+		GetPrivateProfileString(value->category.c_str(), value->name.c_str(), "", value_l, 32, file.c_str());
+		*value->value = (float)atof(value_l);
+	}
+}
+
+CConfig* Config = new CConfig();
+CGlobalVariables gCvars;

variables.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <vector>
+#include <ShlObj.h>
+#include <sstream>
+
+template <typename T>
+class ConfigValue
+{
+public:
+	ConfigValue(std::string category_, std::string name_, T* value_)
+	{
+		category = category_;
+		name = name_;
+		value = value_;
+	}
+
+	std::string category, name;
+	T* value;
+};
+
+class CConfig
+{
+protected:
+	std::vector<ConfigValue<float>*> floats;
+private:
+	void SetupValue(float&, float, std::string, std::string);
+public:
+	CConfig()
+	{
+		Setup();
+	}
+
+	void Setup();
+	void Save();
+	void Load();
+};
+
+class CGlobalVariables
+{
+public:
+	float SMOOTHYAW;
+	float SMOOTHPITCH;
+	float ENABLEAIM;
+	float AIMONFIRE;
+	float AIMFOV;
+	float NORECOIL;
+	float NOSPREAD;
+	float AUTOFIRE;
+	float SILENTAIM;
+	float ESPBOX;
+	float ESPNAME;
+	float ESPHEALTH;
+	float INGOREINFECTED;
+	float CHAMS;
+	float CHAMSXQZ;
+	float CHAMHAND;
+	float AUTOBH;
+	float iSavedRadarX;
+	float iSavedRadarY;
+	float flRadarPos_x = 120;
+	float flRadarPos_y = 120;
+	float radar;
+	float espcolor[3];
+	float watermark;
+	float velocity;
+	float triggerkey;
+	float trigenable;
+	float trighead;
+	float triggerbody;
+	float trigerdelay;
+	float TRIGLIMB;
+	float NOVOMIT;
+	float SPEEDKEY;
+	float SPEEDFAST;
+	float LAGKEY;
+	float LAGFAST;
+	float drawmonitor;
+	float f1monitorpos_x = 400;
+	float f1monitorpos_y = 400;
+};
+
+extern CConfig* Config;
+extern CGlobalVariables gCvars;

vector.h

@@ -0,0 +1,218 @@
+#pragma once
+
+class Vector
+{
+public:
+	Vector();
+	Vector(float x, float y, float z);
+
+	Vector&	operator +=(const Vector&);
+	Vector&	operator -=(const Vector&);
+	Vector&	operator *=(const float);
+
+	float&	operator [](int index);
+
+	Vector	operator+(const Vector& v) const;
+	Vector	operator-(const Vector& v) const;
+	Vector	operator*(float fl) const;
+	Vector&	operator = (const Vector&);
+
+	bool	IsZero(float tolerance = FLT_EPSILON);
+	void    Zero();
+	float	Length2D();
+	float	Length2DSqr();
+	float	Length();
+	float	Normalize();
+	float	NormalizeInPlace();
+	float	length_sqr();
+	float	Dot(const Vector&);
+
+	float	x;
+	float	y;
+	float	z;
+};
+
+inline bool Vector::IsZero(float tolerance)
+{
+	return (x > -tolerance && x < tolerance && y > -tolerance && y < tolerance && z > -tolerance && z < tolerance);
+}
+
+inline Vector& Vector::operator += (const Vector &in)
+{
+	x += in.x;
+	y += in.y;
+	z += in.z;
+
+	return *this;
+}
+
+inline Vector& Vector::operator -= (const Vector &in)
+{
+	x -= in.x;
+	y -= in.y;
+	z -= in.z;
+
+	return *this;
+}
+
+inline Vector& Vector::operator *= (const float in)
+{
+	x *= in;
+	y *= in;
+	z *= in;
+
+	return *this;
+}
+
+inline float& Vector::operator [] (int index)
+{
+	return ((&x)[index]);
+}
+
+inline Vector Vector::operator+(const Vector& v) const
+{
+	Vector res;
+	res.x = x + v.x;
+	res.y = y + v.y;
+	res.z = z + v.z;
+	return res;
+}
+
+inline Vector Vector::operator-(const Vector& v) const
+{
+	Vector res;
+	res.x = x - v.x;
+	res.y = y - v.y;
+	res.z = z - v.z;
+	return res;
+}
+
+inline Vector Vector::operator*(float fl) const
+{
+	Vector res;
+	res.x = x * fl;
+	res.y = y * fl;
+	res.z = z * fl;
+	return res;
+}
+
+
+inline Vector& Vector::operator = (const Vector &in)
+{
+	x = in.x;
+	y = in.y;
+	z = in.z;
+
+	return *this;
+}
+
+inline Vector::Vector()
+{
+	x = y = z = 0.f;
+}
+
+inline void Vector::Zero()
+{
+	x = y = z = 0.f;
+}
+
+inline Vector::Vector(float _x, float _y, float _z)
+{
+	x = _x;
+	y = _y;
+	z = _z;
+}
+
+inline float Vector::Length2D()
+{
+	float root = 0.f;
+	float sqst = x * x + y * y;
+
+	__asm
+	{
+		sqrtss xmm0, sqst
+		movss root, xmm0
+	}
+
+	return root;
+}
+
+inline float Vector::Length2DSqr()
+{
+	return x * x + y * y;
+}
+
+inline float Vector::Dot(const Vector &in)
+{
+	return (x * in.x + y * in.y + z * in.z);
+}
+
+inline float Vector::length_sqr()
+{
+	return x * x + y * y + z * z;
+}
+
+inline float Vector::Length()
+{
+	float root = 0.f;
+	float sqsr = x * x + y * y + z * z;
+
+	__asm
+	{
+		sqrtss xmm0, sqsr
+		movss root, xmm0
+	}
+
+	return root;
+}
+
+inline float Vector::Normalize()
+{
+	float flLength = Length();
+	float flLengthNormal = 1.f / (FLT_EPSILON + flLength);
+
+	x = x * flLengthNormal;
+	y = y * flLengthNormal;
+	z = z * flLengthNormal;
+
+	return flLength;
+}
+
+inline float Vector::NormalizeInPlace()
+{
+	return Normalize();
+}
+
+class VectorAligned : public Vector
+{
+public:
+	VectorAligned()
+	{
+		x = y = z = 0;
+	}
+
+	VectorAligned(const Vector &in)
+	{
+		x = in.x;
+		y = in.y;
+		z = in.z;
+	}
+
+	float w;
+};
+
+FORCEINLINE void VectorSubtract(const Vector& a, const Vector& b, Vector& c)
+{
+	c.x = a.x - b.x;
+	c.y = a.y - b.y;
+	c.z = a.z - b.z;
+}
+
+FORCEINLINE void VectorAdd(const Vector& a, const Vector& b, Vector& c)
+{
+	c.x = a.x + b.x;
+	c.y = a.y + b.y;
+	c.z = a.z + b.z;
+}
+
+

visuals.cpp

@@ -0,0 +1,402 @@
+#include "hooks.h"
+
+#define COLORESP (gCvars.espcolor[0]), (gCvars.espcolor[1]), (gCvars.espcolor[2]), 255
+
+void ESP::DrawMonitor(int x, int y, CBaseEntity * entity)
+{
+	int sizex = 50;
+	int sizey = 100;
+
+	if (g_Mouse.LeftClick(gCvars.f1monitorpos_x - (sizex / 2) - 6, gCvars.f1monitorpos_y - (sizey / 2) - 6, sizex * 2 + 12, sizey * 2 + 12))
+	{
+		gCvars.f1monitorpos_x = g_Mouse.mouse_x;
+		gCvars.f1monitorpos_y = g_Mouse.mouse_y;
+		gCvars.f1monitorpos_x = gCvars.f1monitorpos_x;
+		gCvars.f1monitorpos_y = gCvars.f1monitorpos_y;
+	}
+
+	int centerx = gCvars.f1monitorpos_x + (sizex / 2);
+	int centery = gCvars.f1monitorpos_y + (sizey / 2);
+
+	Draw::FillRGBA(centerx - sizex - 6, centery - sizey - 20, 2 * sizex + 12, 2 * sizey + 26, 35, 35, 35, 255);
+	Draw::OutlinedRectangle(centerx - sizex - 6, centery - sizey - 20, 2 * sizex + 12, 2 * sizey + 26, 0, 0, 0, 254);
+
+	Draw::DrawStringA(Fonts::m_MenuFont, false, centerx - sizex, centery - sizey - 19, 255, 255, 255, 255, "Monitor");
+	Draw::FillRGBA(centerx - sizex, centery - sizey, 2 * sizex, 2 * sizey, 50, 50, 50, 255);
+
+	Draw::OutlinedRectangle(centerx - sizex, centery - sizey, 2 * sizex, 2 * sizey, 0, 0, 0, 254);
+
+	int iSpeed = 0;
+	float flPunch = 0.0f;
+
+	Vector vSpeed = entity->GetVelocity();
+	iSpeed = (int)vSpeed.Length2D();
+
+	Vector pAngle = entity->GetPunchAngle();
+	float flModifier = pAngle.Normalize();
+
+	flModifier -= (10.0f + flModifier * 0.5f) * pGlobalvars->interval_per_tick;
+	pAngle *= flModifier;
+	flPunch = ((pAngle.x * 17.77777777777778) * 1.25);
+
+	Draw::DrawMonitorBar(centerx - sizex + 9, centery - sizey + 12, (-flPunch), "Recoil");
+	Draw::DrawMonitorBar(centerx - sizex + 59, centery - sizey + 12, (iSpeed * 0.2), "Speed");
+}
+
+RECT ESP::DynamicBox(CBaseEntity* pPlayer, bool& PVS, CBaseEntity* local)
+{
+	Vector trans = pPlayer->GetAbsOrigin();
+
+	Vector min;
+	Vector max;
+
+	min = pPlayer->GetMins();
+	max = pPlayer->GetMaxs();
+
+	Vector pointList[] = {
+		Vector(min.x, min.y, min.z),
+		Vector(min.x, max.y, min.z),
+		Vector(max.x, max.y, min.z),
+		Vector(max.x, min.y, min.z),
+		Vector(max.x, max.y, max.z),
+		Vector(min.x, max.y, max.z),
+		Vector(min.x, min.y, max.z),
+		Vector(max.x, min.y, max.z)
+	};
+
+	Vector Distance = pointList[0] - pointList[1];
+	int dst = Distance.Length();
+	dst /= 1.3f;
+	Vector angs;
+	Math::CalcAngle(trans, local->GetEyePosition(), angs);
+
+	Vector all[8];
+	angs.y += 45;
+	for (int i = 0; i < 4; i++)
+	{
+		Math::angleVectors(angs,all[i]);
+		all[i] *= dst;
+		all[i + 4] = all[i];
+		all[i].z = max.z;
+		all[i + 4].z = min.z;
+		VectorAdd(all[i], trans, all[i]);
+		VectorAdd(all[i + 4], trans, all[i + 4]);
+		angs.y += 90;
+	}
+
+	Vector flb, brt, blb, frt, frb, brb, blt, flt;
+	PVS = true;
+
+	if (!Draw::WorldToScreen(all[3], flb))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[0], blb))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[2], frb))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[6], blt))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[5], brt))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[4], frt))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[1], brb))
+		PVS = false;
+	if (!Draw::WorldToScreen(all[7], flt))
+		PVS = false;
+
+	Vector arr[] = { flb, brt, blb, frt, frb, brb, blt, flt };
+
+	float left = flb.x;
+	float top = flb.y;
+	float right = flb.x;
+	float bottom = flb.y;
+
+	for (int i = 0; i < 8; i++)
+	{
+		if (left > arr[i].x)
+			left = arr[i].x;
+		if (top > arr[i].y)
+			top = arr[i].y;
+		if (right < arr[i].x)
+			right = arr[i].x;
+		if (bottom < arr[i].y)
+			bottom = arr[i].y;
+	}
+	RECT rect;
+	rect.left = left;
+	rect.bottom = bottom;
+	rect.right = right;
+	rect.top = top;
+	return rect;
+}
+
+
+void ESP::drawvelocity(int screenWidth, int screenHeight, CBaseEntity* local_player)
+{
+	Vector speed = local_player->GetVelocity();
+
+	int intspeed = round(speed.Length2D());
+
+	char vel[256];
+
+	sprintf_s(vel, "%d", intspeed);
+
+	Draw::DrawStringA(Fonts::m_VelocityFont, true, screenWidth / 2, screenHeight - 100, COLORESP, vel);
+}
+
+void ESP::drawradar(int screenwidght, int screenhight, CBaseEntity* local)
+{
+	for (int ax = 1; ax <= pEntList->GetHighestEntityIndex(); ax++)
+	{
+		CBaseEntity * pEntity = pEntList->GetClientEntity(ax);
+
+		if (!pEntity || pEntity == local || pEntity->IsDormant())
+			continue;
+
+		if (!pEntity->GetModel())
+			continue;
+
+		if (pEntity->GetTeamNum() == TEAM_SURVIVOR)
+			continue;
+
+		std::int32_t nClassID = pEntity->GetClientClass()->GetClassID;
+
+		if (!pEntity->GetGroup() && !pEntity->ValidEntity())
+			continue;
+
+		static Vector vClientViewAngles;
+
+		pEngine->GetViewAngles(vClientViewAngles);
+
+		DrawRadarPoint(pEntity->GetAbsOrigin(), local->GetAbsOrigin(), vClientViewAngles);
+	}
+}
+
+void ESP::DrawRadarBack(int screenwidght, int screenhight)
+{
+	bool bSave_Radar_Pos = true;
+
+	int size = 110;
+	size -= 10;
+
+	if (g_Mouse.LeftClick(gCvars.flRadarPos_x - (size / 2) - 6, gCvars.flRadarPos_y - (size / 2) - 6, size * 2 + 12, size * 2 + 12))
+	{
+		if (!bSave_Radar_Pos)
+		{
+			gCvars.iSavedRadarX = g_Mouse.mouse_x - gCvars.flRadarPos_x;
+			gCvars.iSavedRadarY = g_Mouse.mouse_y - gCvars.flRadarPos_y;
+			bSave_Radar_Pos = true;
+		}
+		gCvars.flRadarPos_x = g_Mouse.mouse_x;
+		gCvars.flRadarPos_y = g_Mouse.mouse_y;
+		gCvars.flRadarPos_x = gCvars.flRadarPos_x - gCvars.iSavedRadarX;
+		gCvars.flRadarPos_y = gCvars.flRadarPos_y - gCvars.iSavedRadarY;
+	}
+	else
+	{
+		bSave_Radar_Pos = false;
+	}
+
+	int centerx = gCvars.flRadarPos_x + (size / 2);
+	int centery = gCvars.flRadarPos_y + (size / 2);
+
+	Draw::FillRGBA(centerx - size - 6, centery - size - 20, 2 * size + 12, 2 * size + 26, 35, 35, 35, 255);
+	Draw::OutlinedRectangle(centerx - size - 6, centery - size - 20, 2 * size + 12, 2 * size + 26, 0, 0, 0, 254);
+
+	Draw::DrawStringA(Fonts::m_MenuFont, false, centerx - size, centery - size - 19, 255, 255, 255, 255, "Radar");
+	Draw::FillRGBA(centerx - size, centery - size, 2 * size, 2 * size, 50, 50, 50, 255);
+
+	Draw::OutlinedRectangle(centerx - size, centery - size, 2 * size, 2 * size, 0, 0, 0, 254);
+	Draw::FillRGBA(centerx, centery - size, 1, 2 * size, 0, 0, 0, 120);
+	Draw::FillRGBA(centerx - size, centery, 2 * size, 1, 0, 0, 0, 120);
+}
+
+void ESP::DrawRadarPoint(Vector vecOriginx, Vector vecOriginy, Vector vAngle)
+{
+	int size = 110;
+
+	int centerx = gCvars.flRadarPos_x + (size / 2);
+	int centery = gCvars.flRadarPos_y + (size / 2);
+
+	float dx = vecOriginx.x - vecOriginy.x;
+	float dy = vecOriginx.y - vecOriginy.y;
+	float flAngle = vAngle.y;
+	float yaw = (flAngle)* (PI / 180.0);
+	float mainViewAngles_CosYaw = cos(yaw);
+	float mainViewAngles_SinYaw = sin(yaw);
+	float x = dy * (-mainViewAngles_CosYaw) + dx * mainViewAngles_SinYaw;
+	float y = dx * (-mainViewAngles_CosYaw) - dy * mainViewAngles_SinYaw;
+	float range = size * 30;
+	if (fabs(x) > range || fabs(y) > range)
+	{
+		if (y > x)
+		{
+			if (y > -x) {
+				x = range * x / y;
+				y = range;
+			}
+			else {
+				y = -range * y / x;
+				x = -range;
+			}
+		}
+		else {
+			if (y > -x) {
+				y = range * y / x;
+				x = range;
+			}
+			else {
+				x = -range * x / y;
+				y = -range;
+			}
+		}
+	}
+	int ScreenX = centerx + int(x / range * float(size));
+	int ScreenY = centery + int(y / range * float(size));
+	size -= 10;
+	int radar_menu_x = centerx;
+	int radar_menu_y = centery;
+
+	if (ScreenX < radar_menu_x - size)
+		ScreenX = radar_menu_x - size + 1;
+	else if (ScreenX > radar_menu_x + size)
+		ScreenX = radar_menu_x + size - 3;
+
+	if (ScreenY < radar_menu_y - size)
+		ScreenY = radar_menu_y - size + 2;
+	else if (ScreenY > radar_menu_y + size)
+		ScreenY = radar_menu_y + size - 4;
+
+	Draw::FillRGBA(ScreenX - 1, ScreenY - 1, 4, 4, 255, 255, 255, 255);
+}
+
+void ESP::draw(CBaseEntity* pLocal)
+{
+	Vector screen, worldpos;
+
+	int iMyTeam = pLocal->GetTeamNum();
+
+	for (int i = 1; i <= pEntList->GetHighestEntityIndex(); i++)
+	{
+		CBaseEntity * pEntity = pEntList->GetClientEntity(i);
+
+		if (!pEntity || pEntity == pLocal || pEntity->IsDormant())
+			continue;
+
+		if (!pEntity->GetModel())
+			continue;
+
+		int iTeamNum = pEntity->GetTeamNum();
+
+		if (iTeamNum == iMyTeam)
+			continue;
+
+		//Draw Player Box ESP
+		if (pEntity->GetGroup() && pEntity->ValidEntityIgnoreInfected())
+		{
+			DrawPlayer(pEntity, pLocal);
+		}
+	}
+}
+
+void ESP::DrawBox(const RECT& rect)
+{
+	pSurface->DrawSetColor(COLORESP);
+	pSurface->DrawOutlinedRect(rect.left, rect.top, rect.right, rect.bottom);
+	pSurface->DrawSetColor(0,0,0,255);
+	pSurface->DrawOutlinedRect(rect.left - 1, rect.top - 1, rect.right + 1, rect.bottom + 1);
+	pSurface->DrawOutlinedRect(rect.left + 1, rect.top + 1, rect.right - 1, rect.bottom - 1);
+}
+
+
+void ESP::DrawPlayer(CBaseEntity * pEntity, CBaseEntity * local)
+{
+	bool PVS = false;
+	RECT rect = DynamicBox(pEntity, PVS, local);
+
+	if (gCvars.ESPBOX)
+	{
+		DrawBox(rect);
+	}
+
+	if (gCvars.ESPNAME || gCvars.ESPHEALTH)
+	{
+		int middle = ((rect.right - rect.left) / 2) + rect.left;
+
+		char * szname{ pEntity->GetClientClass()->GetName };
+
+		int inthealth = pEntity->GetHealth();
+
+		char helfl[256];
+
+		sprintf_s(helfl, "(%d)", inthealth);
+
+		if (local->GetTeamNum() == TEAM_SURVIVOR)
+		{
+
+			if (pEntity->GetGroup() == GROUP_INFECTED)
+			{
+				if (gCvars.ESPNAME)
+				{
+					if (gCvars.INGOREINFECTED)
+						return;
+
+					Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.top - 15, 255, 255, 255, 255, "zombie");
+				}
+			}
+
+			if (pEntity->GetGroup() == GROUP_SPECIAL)
+			{
+				if (gCvars.ESPNAME)
+				{
+					Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.top - 15, 255, 255, 255, 255, szname);
+				}
+
+				if (gCvars.ESPHEALTH)
+				{
+					Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.bottom + 1, 255, 255, 255, 255, helfl);
+				}
+			}
+
+			if (pEntity->GetGroup() == GROUP_TANK)
+			{
+				if (gCvars.ESPNAME)
+				{
+					Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.top - 15, 255, 255, 255, 255, "Tank");
+				}
+
+				if (gCvars.ESPHEALTH)
+				{
+					Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.bottom + 1, 255, 255, 255, 255, helfl);
+				}
+			}
+
+			if (pEntity->GetGroup() == GROUP_BITCH)
+			{
+				if (gCvars.ESPNAME)
+				{
+					Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.top - 15, 255, 255, 255, 255, "Witch");
+				}
+			}
+		}
+
+		if (local->GetTeamNum() == TEAM_ZOMBY)
+		{
+			if (pEntity->GetGroup() == GROUP_PLAYER)
+			{
+				if (pEntity->GetTeamNum() == TEAM_SURVIVOR && pEntity->GetLifeState() == LIFE_ALIVE)
+				{
+					if (gCvars.ESPNAME)
+					{
+						Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.top - 15, 255, 255, 255, 255, "Survivor");
+					}
+
+					if (gCvars.ESPHEALTH)
+					{
+						Draw::DrawStringA(Fonts::m_MenuFont, true, middle, rect.bottom + 1, 255, 255, 255, 255, helfl);
+					}
+				}
+			}
+		}
+	}
+}

visuals.h

@@ -0,0 +1,15 @@
+
+
+namespace ESP
+{
+	void DrawMonitor(int x, int y, CBaseEntity * entity);
+	RECT DynamicBox(CBaseEntity* pPlayer, bool& PVS, CBaseEntity* local);
+	void draw(CBaseEntity* local);
+	void DrawPlayer(CBaseEntity * pEntity,CBaseEntity * local);
+	void DrawBox(const RECT& rect);
+	void drawradar(int screenwidght, int screenheight, CBaseEntity* local);
+	void DrawRadarBack(int screenwidght, int screenheight);
+	void DrawRadarPoint(Vector vecOriginx, Vector vecOriginy, Vector vAngle);
+	void drawvelocity(int screenWidth, int screenHeight, CBaseEntity* local_player);
+}
+

vmatrix.h

@@ -0,0 +1,44 @@
+#pragma once
+
+struct matrix3x4_t
+{
+	matrix3x4_t() {}
+	matrix3x4_t(
+		float m00, float m01, float m02, float m03,
+		float m10, float m11, float m12, float m13,
+		float m20, float m21, float m22, float m23)
+	{
+		m_flMatVal[0][0] = m00;	m_flMatVal[0][1] = m01; m_flMatVal[0][2] = m02; m_flMatVal[0][3] = m03;
+		m_flMatVal[1][0] = m10;	m_flMatVal[1][1] = m11; m_flMatVal[1][2] = m12; m_flMatVal[1][3] = m13;
+		m_flMatVal[2][0] = m20;	m_flMatVal[2][1] = m21; m_flMatVal[2][2] = m22; m_flMatVal[2][3] = m23;
+	}
+	void Init(const Vector& xAxis, const Vector& yAxis, const Vector& zAxis, const Vector &vecOrigin)
+	{
+		m_flMatVal[0][0] = xAxis.x; m_flMatVal[0][1] = yAxis.x; m_flMatVal[0][2] = zAxis.x; m_flMatVal[0][3] = vecOrigin.x;
+		m_flMatVal[1][0] = xAxis.y; m_flMatVal[1][1] = yAxis.y; m_flMatVal[1][2] = zAxis.y; m_flMatVal[1][3] = vecOrigin.y;
+		m_flMatVal[2][0] = xAxis.z; m_flMatVal[2][1] = yAxis.z; m_flMatVal[2][2] = zAxis.z; m_flMatVal[2][3] = vecOrigin.z;
+	}
+
+	matrix3x4_t(const Vector& xAxis, const Vector& yAxis, const Vector& zAxis, const Vector &vecOrigin)
+	{
+		Init(xAxis, yAxis, zAxis, vecOrigin);
+	}
+	float *operator[](int i)
+	{
+		return m_flMatVal[i];
+	}
+	const float *operator[](int i) const
+	{
+		return m_flMatVal[i];
+	}
+	float *Base()
+	{
+		return &m_flMatVal[0][0];
+	}
+	const float *Base() const
+	{
+		return &m_flMatVal[0][0];
+	}
+
+	float m_flMatVal[3][4];
+};