#include "Game.h"

PModule modEngine, modClient;
PMemory mem;
HANDLE TargetProcess;
DWORD DwClient;
DWORD DwEngine;

DWORD DwEntityList = 0x04A17BD4;
DWORD DwEnginePointer = 0x005CE1C4;
DWORD DwLocalPlayer = 0x00A75CCC;
DWORD DwViewAngle = 0x00004CE0;
DWORD dwSpotted = 0x935;
DWORD dwjump = 0x04AA8930;
DWORD offGlow = 0x04B2AAA4;
DWORD offEntityList = 0x04A17BD4;
DWORD offLocalPlayer = 0x00A75CCC;

const DWORD DwCrosshairId = 0x2410;
const DWORD DwVecViewOffset = 0x104;
const DWORD DwVecOrigin = 0x134;
const DWORD DwVecPunch = 0x13E8;
const DWORD DwTeamNumber = 0xF0;
const DWORD DwShotsFired = 0x1D6C;
const DWORD DwFlags = 0x100;
const DWORD DwBoneMatrix = 0xA78;
const DWORD DwEntitySize = 0x10;
const DWORD DwHealth = 0xFC;
const DWORD DwLifeState = 0x25B;
const DWORD DwVecVelocity = 0x110;
const DWORD offEntityTeam = 0xF0;

float PitchMinPunch = 2.f;
float PitchMaxPunch = 2.f;
float YawMinPunch = 2.f;
float YawMaxPunch = 2.f;
float smoothamount = 20.f;
int TargetBone = 10;

bool glowEnabled = true;
bool aimEnabled = true;
bool radarEnabled = true;
bool trigEnabled = false;

DWORD TrigVkeyCode;
DWORD ForceAimVkeyCode;
DWORD AutoAimVkeyCode;
DWORD ESPVkeyCode;
DWORD PanicVkeyCode;
DWORD RadarVkeyCode;
DWORD AimVkeyCode;
DWORD NewAimVkeyCode = 1;


[junk_enable /]
[enc_string_enable /]


struct
{
	DWORD GetBaseEntity(int PlayerNumber)
	{
		return mem.Read<DWORD>(DwClient + DwEntityList + (DwEntitySize * PlayerNumber));
	}

	bool IsDead(int PlayerNumber)
	{
		DWORD BaseEntity = GetBaseEntity(PlayerNumber);
		if (BaseEntity)
		{
			return mem.Read<bool>(BaseEntity + DwLifeState);
		}
	}

	int GetTeam(int PlayerNumber)
	{
		DWORD BaseEntity = GetBaseEntity(PlayerNumber);
		if (BaseEntity)
		{
			return mem.Read<int>(BaseEntity + DwTeamNumber);
		}
	}

	void GetVelocity(int PlayerNumber, float* Buffer)
	{
		DWORD BaseEntity = GetBaseEntity(PlayerNumber);
		if (BaseEntity)
		{
			mem.Read<float*>(BaseEntity + DwVecVelocity, true, 3, Buffer);
		}
	}

	void GetBonePosition(int PlayerNumber, float* BonePosition)
	{
		DWORD BaseEntity = GetBaseEntity(PlayerNumber);
		if (BaseEntity)
		{
			DWORD BoneMatrix = mem.Read<DWORD>(BaseEntity + DwBoneMatrix);
			if (BoneMatrix)
			{
				mem.Read<float*>(BoneMatrix + 0x30 * TargetBone + 0x0C, true, 1, &BonePosition[0]);
				mem.Read<float*>(BoneMatrix + 0x30 * TargetBone + 0x1C, true, 1, &BonePosition[1]);
				mem.Read<float*>(BoneMatrix + 0x30 * TargetBone + 0x2C, true, 1, &BonePosition[2]);
			}
		}
	}

}EntityList;

struct
{

	DWORD GetPlayerBase()
	{
		return mem.Read<DWORD>(DwClient + DwLocalPlayer);
	}

	void SetAngles(float* Angles)
	{
		DWORD AnglePointer = mem.Read<DWORD>(DwEngine + DwEnginePointer);
		if (AnglePointer)
		{
			mem.Write<float*>(AnglePointer + DwViewAngle, Angles, true, 3);
		}
	}

	void GetVelocity(float* Buffer)
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			mem.Read<float*>(PlayerBase + DwVecVelocity, true, 3, Buffer);
		}
	}

	void GetAngles(float* Angles)
	{
		DWORD AnglePointer = mem.Read<DWORD>(DwEngine + DwEnginePointer);
		if (AnglePointer)
		{
			mem.Read<float*>(AnglePointer + DwViewAngle, true, 3, Angles);
		}
	}

	int GetTeam()
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			return mem.Read<int>(PlayerBase + DwTeamNumber);
		}
	}

	int GetCrosshairId()
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			return mem.Read<int>(PlayerBase + DwCrosshairId) - 1;
		}
	}

	void GetPunch(float* Punch)
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			mem.Read<float*>(PlayerBase + DwVecPunch, true, 2, Punch);
		}
	}

	float GetViewOrigin()
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			float Vecview[3];
			mem.Read<float*>(PlayerBase + DwVecViewOffset, true, 3, Vecview);
			return Vecview[2];
		}
	}

	void GetPosition(float* Position)
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			mem.Read<float*>(PlayerBase + DwVecOrigin, true, 3, Position);
		}
	}

	int GetShotsFired()
	{
		DWORD PlayerBase = GetPlayerBase();
		if (PlayerBase)
		{
			return mem.Read<int>(PlayerBase + DwShotsFired);
		}
	}

}NewPlayer;



void AngleNormalize(float* angle)
{
	if (angle[0] > 89.0f && angle[0] <= 180.0f)
	{
		angle[0] = 89.0f;
	}
	if (angle[0] > 180.f)
	{
		angle[0] -= 360.f;
	}
	if (angle[0] < -89.0f)
	{
		angle[0] = -89.0f;
	}
	if (angle[1] > 180.f)
	{
		angle[1] -= 360.f;
	}
	if (angle[1] < -180.f)
	{
		angle[1] += 360.f;
	}
	if (angle[2] != 0.0f)
	{
		angle[2] = 0.0f;
	}
}

void calcang(float *src, float *dst, float *angles)
{
	random_device Random;
	mt19937 RandomGen(Random());
	uniform_real<float> RandomXdistrib(PitchMinPunch, PitchMaxPunch);
	uniform_real<float> RandomYdistrib(YawMinPunch, YawMaxPunch);
	float MyPunch[2];
	NewPlayer.GetPunch(MyPunch);
	float pitchreduction = RandomXdistrib(RandomGen);
	float yawreduction = RandomYdistrib(RandomGen);
	float delta[3] = { (src[0] - dst[0]), (src[1] - dst[1]), ((src[2] + NewPlayer.GetViewOrigin()) - dst[2]) };
	float hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);
	angles[0] = atanf(delta[2] / hyp) * 57.295779513082f - MyPunch[0] * pitchreduction;
	angles[1] = atanf(delta[1] / delta[0]) * 57.295779513082f - MyPunch[1] * yawreduction;
	angles[2] = 0.0f;
	if (delta[0] >= 0.0)
	{
		angles[1] += 180.0f;
	}
}

void SmoothAngleSet(float* dest, float* orig)
{
	float SmoothAngles[3];
	SmoothAngles[0] = dest[0] - orig[0];
	SmoothAngles[1] = dest[1] - orig[1];
	SmoothAngles[2] = 0.0f;
	AngleNormalize(SmoothAngles);
	SmoothAngles[0] = orig[0] + SmoothAngles[0] / 100.0f * smoothamount;
	SmoothAngles[1] = orig[1] + SmoothAngles[1] / 100.0f * smoothamount;
	SmoothAngles[2] = 0.0f;
	AngleNormalize(SmoothAngles);
	NewPlayer.SetAngles(SmoothAngles);
	Sleep(1);
}

void Click()
{
	mouse_event(MOUSEEVENTF_LEFTDOWN, NULL, NULL, NULL, NULL);
	Sleep(1);
	mouse_event(MOUSEEVENTF_LEFTUP, NULL, NULL, NULL, NULL);
	Sleep(30);
}

void VelocityComp(int PlayerNumber, float* EnemyPos)
{
	float EnemyVelocity[3];
	float MyVelocity[3];
	EntityList.GetVelocity(PlayerNumber, EnemyVelocity);
	NewPlayer.GetVelocity(MyVelocity);
	EnemyPos[0] = EnemyPos[0] + (EnemyVelocity[0] / 100.f) * (40.f / smoothamount);
	EnemyPos[1] = EnemyPos[1] + (EnemyVelocity[1] / 100.f) * (40.f / smoothamount);
	EnemyPos[2] = EnemyPos[2] + (EnemyVelocity[2] / 100.f) * (40.f / smoothamount);
	EnemyPos[0] = EnemyPos[0] - (MyVelocity[0] / 100.f) * (40.f / smoothamount);
	EnemyPos[1] = EnemyPos[1] - (MyVelocity[1] / 100.f) * (40.f / smoothamount);
	EnemyPos[2] = EnemyPos[2] - (MyVelocity[2] / 100.f) * (40.f / smoothamount);
}



DWORD WINAPI AB(LPVOID params)
{
	while (!GetAsyncKeyState(PanicVkeyCode))
	{
		Sleep(1);

		if (GetAsyncKeyState(PanicVkeyCode))
		{
			ExitThread(0);
		}

		if (aimEnabled)
		{
			int PlayerNumber = NewPlayer.GetCrosshairId();

			while (GetAsyncKeyState(NewAimVkeyCode) < 0 && NewPlayer.GetShotsFired() > 1 &&  PlayerNumber < 64 && PlayerNumber >= 0 && EntityList.GetTeam(PlayerNumber) != NewPlayer.GetTeam() && EntityList.IsDead(PlayerNumber) != true)
			{
				int TempPlayerNumber = NewPlayer.GetCrosshairId();
				if (TempPlayerNumber < 64 && TempPlayerNumber >= 0 && EntityList.GetTeam(TempPlayerNumber) != NewPlayer.GetTeam() && EntityList.IsDead(TempPlayerNumber) != true)
				{
					PlayerNumber = TempPlayerNumber;
				}
				float PlayerPos[3];
				float EnemyPos[3];
				float AimAngle[3];
				float CurrentAngle[3];
				NewPlayer.GetPosition(PlayerPos);
				EntityList.GetBonePosition(PlayerNumber, EnemyPos);
				VelocityComp(PlayerNumber, EnemyPos);
				calcang(PlayerPos, EnemyPos, AimAngle);
				AngleNormalize(AimAngle);
				NewPlayer.GetAngles(CurrentAngle);
				AngleNormalize(CurrentAngle);
				SmoothAngleSet(AimAngle, CurrentAngle);
				Sleep(1);
			}

			while (GetAsyncKeyState(ForceAimVkeyCode) < 0 && PlayerNumber < 64 && PlayerNumber >= 0 && EntityList.GetTeam(PlayerNumber) != NewPlayer.GetTeam() && EntityList.IsDead(PlayerNumber) != true)
			{
				int TempPlayerNumber = NewPlayer.GetCrosshairId();
				if (TempPlayerNumber < 64 && TempPlayerNumber >= 0 && EntityList.GetTeam(TempPlayerNumber) != NewPlayer.GetTeam() && EntityList.IsDead(TempPlayerNumber) != true)
				{
					PlayerNumber = TempPlayerNumber;
				}
				float PlayerPos[3];
				float EnemyPos[3];
				float AimAngle[3];
				float CurrentAngle[3];
				NewPlayer.GetPosition(PlayerPos);
				EntityList.GetBonePosition(PlayerNumber, EnemyPos);
				VelocityComp(PlayerNumber, EnemyPos);
				calcang(PlayerPos, EnemyPos, AimAngle);
				AngleNormalize(AimAngle);
				NewPlayer.GetAngles(CurrentAngle);
				AngleNormalize(CurrentAngle);
				SmoothAngleSet(AimAngle, CurrentAngle);
				Sleep(1);
			}

		}
	}
}


DWORD WINAPI TB(LPVOID params)
{
	while (!GetAsyncKeyState(PanicVkeyCode))
	{
		Sleep(1);

		if (GetAsyncKeyState(PanicVkeyCode))
		{
			ExitThread(0);
		}
		while (trigEnabled) {
			int PlayerNumber = NewPlayer.GetCrosshairId();
			if (PlayerNumber < 64 && PlayerNumber >= 0 && EntityList.GetTeam(PlayerNumber) != NewPlayer.GetTeam() && EntityList.IsDead(PlayerNumber) != true)
			{
				Click();
			}
			else
			{
				Sleep(1);
			}
		}
	}
}

int whichKeyIsPressed() {
	while (true) {
		for (int i = 1; i < 255; i++) {
			if (GetAsyncKeyState(i) & 0x8000) {
				while (GetAsyncKeyState(i) & 0x8000) {
					Sleep(50);
				}
				return i;
			}
		}
		Sleep(10);
	}
}



void ReadData(Player* p) {
	p->team = mem.Read<int>(p->dwBase + offEntityTeam);
}

int main() {
	std::cout << "Carl's Syge Shit\n\n";
	std::cout << "...";
	while (!mem.Attach("csgo.exe")) {
		std::cout << ".";
		Sleep(500);
	}
	modClient = mem.GetModule("client.dll");
	DwClient = modClient.dwBase;

	modEngine = mem.GetModule("engine.dll");
	DwEngine = modEngine.dwBase;

	Sleep(30);

	std::cout << "Hotkeys: \n";

	std::cout << "Hold Aimlock: ";
	ForceAimVkeyCode = whichKeyIsPressed();
	std::cout << ForceAimVkeyCode << "\n";

	std::cout << "Toggle Trigger: ";
	TrigVkeyCode = whichKeyIsPressed();
	std::cout << TrigVkeyCode << "\n";

	std::cout << "Panic Key: ";
	PanicVkeyCode = whichKeyIsPressed();
	std::cout << PanicVkeyCode << "\n";


	std::cout << "\n";

	CreateThread(0, 0x1000, &AB, 0, 0, 0);
	CreateThread(0, 0x1001, &TB, 0, 0, 0);

	Player me;
	Player players[64];

	while (!GetAsyncKeyState(PanicVkeyCode)) {

		if (GetAsyncKeyState(TrigVkeyCode) & 0x8000) {
			while (GetAsyncKeyState(TrigVkeyCode) & 0x8000) {
				Sleep(50);
			}
			trigEnabled = !trigEnabled;
			std::cout << "Trigger is now ";
			if (trigEnabled) {
				std::cout << "enabled\n";
			}
			else {
				std::cout << "disabled\n";
			}
		}

		if (glowEnabled) {
			me.dwBase = mem.Read<DWORD>(DwClient + offLocalPlayer);
			ReadData(&me);
			for (int i = 1; i < 64; i++) {
				players[i].dwBase = mem.Read<DWORD>(DwClient + offEntityList + i * 0x10);
				ReadData(&players[i]);
			}

			DWORD pointerGlow = mem.Read<DWORD>(DwClient + offGlow);
			int objectCount = mem.Read<int>(DwClient + offGlow + 0x4);
			if (pointerGlow != NULL) {
				for (int i = 0; i < objectCount; i++) {


					DWORD mObj = pointerGlow + i * sizeof(GlowObjectDefinition_t);
					GlowObjectDefinition_t glowObj = mem.ReadNew<GlowObjectDefinition_t>(mObj);


					if (glowObj.pEntity != NULL) {
						int f_i = -1;
						for (int j = 1; j < 64; j++) {

							if (glowObj.pEntity == players[j].dwBase) {
								if (players[j].team != me.team) {
									int r = 0, g = 255, b = 0;
									mem.WriteNew<float>(mObj + 0x4, r / 255);
									mem.WriteNew<float>(mObj + 0x8, g / 255);
									mem.WriteNew<float>(mObj + 0xC, b / 255);
									mem.WriteNew<float>(mObj + 0x10, 1.0f);
									mem.WriteNew<bool>(mObj + 0x24, true);
									mem.WriteNew<bool>(mObj + 0x25, false);

								}
								//if (players[j].team == me.team) {
								//	r = 0;
								//	b = 255;
								//}

							}
						}
					}
				}
			}
		}

		if (radarEnabled) {
			me.dwBase = mem.Read<DWORD>(DwClient + offLocalPlayer);
			ReadData(&me);
			for (int i = 1; i < 64; i++) {
				players[i].dwBase = mem.Read<DWORD>(DwClient + offEntityList + i * 0x10);
				ReadData(&players[i]);
			}

			DWORD pointerGlow = mem.Read<DWORD>(DwClient + offGlow);
			int objectCount = mem.Read<int>(DwClient + offGlow + 0x4);
			if (pointerGlow != NULL) {
				for (int i = 0; i < objectCount; i++) {

					DWORD mObj = pointerGlow + i * sizeof(GlowObjectDefinition_t);
					GlowObjectDefinition_t glowObj = mem.ReadNew<GlowObjectDefinition_t>(mObj);

					if (glowObj.pEntity != NULL) {
						int f_i = -1;
						for (int j = 1; j < 64; j++) {
							if (glowObj.pEntity == players[j].dwBase) {
								if (players[j].team != me.team) {
									mem.WriteNew<int>(players[j].dwBase + dwSpotted, 1);
								}
							}
						}
					}
				}
			}
		}

	}

	return 0;
}