OutdatedPP Subtle-aimbot & Triggerbot - PolyHack - Auto Updating

#include "stdafx.h"

[junk_enable /]
[enc_string_enable /]

#pragma region HackBack

#pragma region decl

#pragma region group1//these change with updates

DWORD DwEntityList = 0x049ED1B4;
DWORD DwEnginePointer = 0x00559434;
DWORD DwLocalPlayer = 0x00A4B98C;
DWORD DwViewAngle = 0x4CE0;
#pragma endregion 

#pragma region group2//these normally don't
const DWORD DwCrosshairId = 0x2400;
const DWORD DwVecViewOrigin = 0x104;
const DWORD DwVecOrigin = 0x134;
const DWORD DwVecPunch = 0x13E8;
const DWORD DwTeamNumber = 0xF0;
const DWORD DwShotsFired = 0x1D60;
const DWORD DwFlags = 0x100;
const DWORD DwBoneMatrix = 0xA78;
const DWORD DwEntitySize = 0x10;
const DWORD DwHealth = 0xFC;
const DWORD DwLifeState = 0x25B;
const DWORD DwVecVelocity = 0x110;
#pragma endregion

#pragma region group3//other shit
HANDLE TargetProcess;
DWORD DwClient;
DWORD DwEngine;
bool KILLAPP = false;
bool Thread1Paused = false;
bool TRIG = true;
bool AIM = true;
string aimval = "ON";
string trigval = "ON";
float PitchMinPunch = 2.f;
float PitchMaxPunch = 2.f;
float YawMinPunch = 2.f;
float YawMaxPunch = 2.f;
int TargetBone = 2;
float smoothamount = 20.f;
DWORD TrigVkeyCode = 4;
DWORD AimVkeyCode = 1;
#pragma endregion

#pragma endregion

[junk_disable /]
[enc_string_disable /]
struct PModule {
	DWORD dwBase, dwSize;
};

[junk_enable /]
[enc_string_enable /]

PModule modEngine, modClient;

struct //ghetto memory class
{
	template <typename ReadType> ReadType R(DWORD Address, bool isarray = false, int elementcount = 1, ReadType SrcData = 0)
	{
		if (!isarray)
		{
			ReadType Data;
			ReadProcessMemory(TargetProcess, (LPVOID)(Address), &Data, sizeof(ReadType), 0);
			return Data;
		}
		else if (isarray)
		{
			ReadProcessMemory(TargetProcess, (LPVOID)(Address), (ReadType*)SrcData, sizeof(ReadType)* elementcount, 0);
			return NULL;
		}
	}
	template<typename WriteType> WriteType W(DWORD Address, WriteType Data, bool isarray = false, int elementcount = 1)
	{
		if (!isarray)
		{
			WriteProcessMemory(TargetProcess, (LPVOID)(Address), &Data, sizeof(WriteType)* elementcount, 0);
			return Data;
		}
		else if (isarray)
		{
			WriteProcessMemory(TargetProcess, (LPVOID)(Address), (WriteType*)Data, sizeof(WriteType)* elementcount, 0);
			return NULL;
		}
	}

	bool DataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask) {
		for (; *pszMask; ++pszMask, ++pData, ++pMask) {
			if (*pszMask == 'x' && *pData != *pMask) {
				return false;
			}
		}

		return (*pszMask == NULL);
	}

	DWORD FindPattern(DWORD start, DWORD size, const char* sig, const char* mask) {
		BYTE* data = new BYTE[size];

		unsigned long bytesRead;

		if (!ReadProcessMemory(TargetProcess, (LPVOID)start, data, size, &bytesRead)) {
			return NULL;
		}

		for (DWORD i = 0; i < size; i++) {
			if (DataCompare((const BYTE*)(data + i), (const BYTE*)sig, mask)) {
				return start + i;
			}
		}

		return NULL;
	}

	DWORD FindPatternArr(DWORD start, DWORD size, const char* mask, int count, ...) {
		char* sig = new char[count + 1];
		va_list ap;
		va_start(ap, count);
		for (int i = 0; i < count; i++) {
			char read = va_arg(ap, char);
			sig[i] = read;
		}
		va_end(ap);
		sig[count] = '\0';

		return FindPattern(start, size, sig, mask);
	}
}Mem;

PModule GetModuleHandleByName(char* ModuleName, DWORD ProcID)
{
	HANDLE module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ProcID);
	MODULEENTRY32 mEntry;
	mEntry.dwSize = sizeof(mEntry);

	do {
		if (!strcmp(mEntry.szModule, (LPSTR)ModuleName)) {
			CloseHandle(module);

			PModule mod;
			mod.dwBase = (DWORD)mEntry.modBaseAddr;
			mod.dwSize = mEntry.modBaseSize;
			return mod;
		}
	} while (Module32Next(module, &mEntry));

	CloseHandle(module);

	PModule mode = { 0, 0 };
	return mode;
}

HANDLE GetProcessHandleByName(char* ProcessName)
{
	PROCESSENTRY32 ENTRY;
	ENTRY.dwSize = sizeof(PROCESSENTRY32);
	HANDLE HSNAP = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
	if (Process32First(HSNAP, &ENTRY) == TRUE)
	{
		if (!strcmp(ENTRY.szExeFile, ProcessName))
		{
			HANDLE HPROC = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ENTRY.th32ProcessID);
			return HPROC;
		}
		else
		{
			while (Process32Next(HSNAP, &ENTRY) == TRUE)
			{
				if (!strcmp(ENTRY.szExeFile, ProcessName))
				{
					HANDLE HPROC = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ENTRY.th32ProcessID);
					return HPROC;
				}
			}
			return 0;
		}
	}
	CloseHandle(HSNAP);
}

#pragma endregion

struct
{

	DWORD GetBaseEntity(int PlayerNumber)
	{
		return Mem.R<DWORD>(DwClient + DwEntityList + (DwEntitySize * PlayerNumber));
	}

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

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

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

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

}EntityList;

struct
{

	DWORD GetPlayerBase()
	{
		return Mem.R<DWORD>(DwClient + DwLocalPlayer);
	}

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

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

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

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

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

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

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

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

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

}Player;

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];
	Player.GetPunch(MyPunch);
	float pitchreduction = RandomXdistrib(RandomGen);
	float yawreduction = RandomYdistrib(RandomGen);
	float delta[3] = { (src[0] - dst[0]), (src[1] - dst[1]), ((src[2] + Player.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);
	Player.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);
	Player.GetVelocity(MyVelocity);
	EnemyPos[0] = EnemyPos[0] + (EnemyVelocity[0] / 100.f) * (40.f / smoothamount); //not sure why 40 works. I tried a lot of different values and 40 seems to scale perfectly
	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)
{
	cout << "$ Aimbot/Triggerbot thread is running..." << endl;
	while (true)
	{
		Sleep(1);
		if (KILLAPP)
		{
			cout << "$ Ending thread..." << endl;
			ExitThread(0);
		}
		if (AIM || TRIG)
		{
			Thread1Paused = false;
			if (AIM)
			{
				int PlayerNumber = Player.GetCrosshairId();
				while (GetAsyncKeyState(AimVkeyCode) < 0 && Player.GetShotsFired() > 1 && PlayerNumber < 64 && PlayerNumber >= 0 && EntityList.GetTeam(PlayerNumber) != Player.GetTeam() && EntityList.IsDead(PlayerNumber) != true)
				{
					int TempPlayerNumber = Player.GetCrosshairId();
					if (TempPlayerNumber < 64 && TempPlayerNumber >= 0 && EntityList.GetTeam(TempPlayerNumber) != Player.GetTeam() && EntityList.IsDead(TempPlayerNumber) != true)
					{
						PlayerNumber = TempPlayerNumber;
					}
					float PlayerPos[3];
					float EnemyPos[3];
					float AimAngle[3];
					float CurrentAngle[3];
					Player.GetPosition(PlayerPos);
					EntityList.GetBonePosition(PlayerNumber, EnemyPos);
					VelocityComp(PlayerNumber, EnemyPos);
					calcang(PlayerPos, EnemyPos, AimAngle);
					AngleNormalize(AimAngle);
					Player.GetAngles(CurrentAngle);
					AngleNormalize(CurrentAngle);
					SmoothAngleSet(AimAngle, CurrentAngle);
					Sleep(1);
				}
			}
			if (TRIG)
			{
				if (GetAsyncKeyState(TrigVkeyCode) < 0 && TrigVkeyCode != 1)
				{
					int PlayerNumber = Player.GetCrosshairId();
					if (PlayerNumber < 64 && PlayerNumber >= 0 && EntityList.GetTeam(PlayerNumber) != Player.GetTeam() && EntityList.IsDead(PlayerNumber) != true)
					{
						Click();
					}
					else
					{
						Sleep(1);
					}
				}
			}
		}
		else
		{
			Thread1Paused = true;
			Sleep(500);
		}
	}
}

void Init()
{
	cout << "$ Waiting for process..." << endl;
	TargetProcess = NULL;
	while (!TargetProcess)
	{
		cout << ".";
		TargetProcess = GetProcessHandleByName("csgo.exe");
		Sleep(500);
	}
	cout << endl;
	cout << "$ Getting Client handle..." << endl;
	DwClient = NULL;
	while (!DwClient)
	{
		cout << ".";
		modClient = GetModuleHandleByName("client.dll", GetProcessId(TargetProcess));
		DwClient = modClient.dwBase;
		Sleep(500);
	}
	cout << endl;
	cout << "$ Getting Engine handle..." << endl;
	DwEngine = NULL;
	while (!DwEngine)
	{
		cout << ".";
		modEngine = GetModuleHandleByName("engine.dll", GetProcessId(TargetProcess));
		DwEngine = modEngine.dwBase;
		Sleep(500);
	}
	cout << endl;

	cout << "$ Getting Local Player offset..." << endl;
	DwLocalPlayer = 0x0;
	while (!DwLocalPlayer) {
		cout << ".";
		DWORD lpStart = Mem.FindPatternArr(modClient.dwBase, modClient.dwSize, "xxx????xx????xxxxx?", 19, 0x8D, 0x34, 0x85, 0x0, 0x0, 0x0, 0x0, 0x89, 0x15, 0x0, 0x0, 0x0, 0x0, 0x8B, 0x41, 0x8, 0x8B, 0x48, 0x0);
		DWORD lpP1 = Mem.R<DWORD>(lpStart + 3);
		BYTE lpP2 = Mem.R<BYTE>(lpStart + 18);
		DwLocalPlayer = (lpP1 + lpP2) - modClient.dwBase;
	}
	std::cout << endl;

	cout << "$ Getting Entity List offset..." << endl;
	DwEntityList = 0x0;
	while (!DwEntityList) {
		cout << ".";
		DWORD elStart = Mem.FindPatternArr(modClient.dwBase, modClient.dwSize, "x????xx?xxx", 11, 0x5, 0x0, 0x0, 0x0, 0x0, 0xC1, 0xE9, 0x0, 0x39, 0x48, 0x4);
		DWORD elP1 = Mem.R<DWORD>(elStart + 1);
		BYTE elP2 = Mem.R<BYTE>(elStart + 7);
		DwEntityList = (elP1 + elP2) - modClient.dwBase;
	}
	std::cout << endl;

	cout << "$ Getting Engine Pointer and SetViewAngle offset..." << endl;
	DwEnginePointer = 0x0;
	while (!DwEnginePointer) {
		cout << ".";
		DWORD epStart = Mem.FindPatternArr(modEngine.dwBase, modEngine.dwSize, "xxxxxxxx????xxxxxxxxxx????xxxx????xxx", 37, 0xF3, 0x0F, 0x5C, 0xC1, 0xF3, 0x0F, 0x10, 0x15, 0x0, 0x0, 0x0, 0x0, 0x0F, 0x2F, 0xD0, 0x76, 0x04, 0xF3, 0x0F, 0x58, 0xC1, 0xA1, 0x0, 0x0, 0x0, 0x0, 0xF3, 0x0F, 0x11, 0x80, 0x0, 0x0, 0x0, 0x0, 0xD9, 0x46, 0x04);
		DwEnginePointer = Mem.R<DWORD>(epStart + 22) - modEngine.dwBase;
		DwViewAngle = Mem.R<DWORD>(epStart + 30);
	}
	std::cout << endl;

	cout << "$ Done." << endl;
}

void PrintIntro() {
	cout << "$ ---Puddin' Poppin's CS:GO subtle-aimbot & triggerbot--- ~ENJOY!" << endl;
	cout << "$ ---               Modified by Merccy                ---" << endl << endl;
}

void PrintInstructions() {
	cout << "$ Instructions:" << endl << "$ CRTL+F10 to reload hack" << endl << "$ CTRL+F8 to close" << endl << "$ CTRL+NUMPAD0 to manually set options" << endl << "$ CTRL+NUMPAD1 to toggle subtle-aimbot" << endl << "$ CTRL+NUMPAD2 to toggle triggerbot" << endl << "$ CTRL+NUMPAD3 to print current settings" << endl << "$ CTRL+NUMPAD4 to clear the console" << endl;
}

int main()
{
	PrintIntro();
	system("pause");
	cout << endl << endl;
	Init();
	CreateThread(0, 0x1000, &AB, 0, 0, 0);
	Sleep(1000);
	PrintInstructions();
	cout << "$ AIM: " << aimval << " | TRIG: " << trigval << endl << endl;
	while (true)
	{
		if (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_F8) < 0)
		{
			while (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_F8) < 0)
			{
				Sleep(100);
			}
			KILLAPP = true;
			if (KILLAPP)
			{
				cout << "$ Ending Main thread..." << endl;
				ExitThread(0);
			}
		}

		if (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD3) < 0)
		{
			while (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD3) < 0)
			{
				Sleep(100);
			}
			cout << "$ Current settings: " << endl << "$ Smoothing factor (float) = " << smoothamount << endl << "$ Minimum RCS pitch compensation scale (float) = " << PitchMinPunch << endl << "$ Maximum RCS pitch compensation scale (float) = " << PitchMaxPunch << endl << "$ Minimum RCS yaw compensation scale (float) = " << YawMinPunch << endl << "$ Maximum RCS yaw compensation scale (float) = " << YawMaxPunch << endl << "$ Bone number to target(int) = " << TargetBone << endl << "$ Virtual-Key code of button to use for aimbot (int) = " << AimVkeyCode << endl << "$ Virtual-Key code of button to use for triggerbot (int) = " << TrigVkeyCode << endl << "$ Done." << endl;
		}

		if (GetAsyncKeyState(VK_CONTROL) & 0x8000 && GetAsyncKeyState(VK_NUMPAD4) & 0x8000) {
			while (GetAsyncKeyState(VK_CONTROL) & 0x8000 && GetAsyncKeyState(VK_NUMPAD4) & 0x8000) {
				Sleep(100);
			}
			system("cls");
			PrintIntro();
			PrintInstructions();
			cout << "$ AIM: " << aimval << " | TRIG: " << trigval << endl << endl;
		}

		if (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_F10) < 0)
		{
			while (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_F10) < 0)
			{
				Sleep(100);
			}
			cout << "$ Reloading hack..." << endl;
			bool storedAIM = AIM;
			bool storedTRIG = TRIG;
			AIM = false;
			TRIG = false;
			cout << "$ Waiting for threads to enter paused state...";
			while (!Thread1Paused)
			{
				cout << ".";
				Sleep(500);
			}
			cout << endl << "$ Done." << endl;
			Init();
			cout << "$ Done. Threads should be restored." << endl;
			AIM = storedAIM;
			TRIG = storedTRIG;
		}

		if (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD0) < 0)
		{
			while (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD0) < 0)
			{
				Sleep(100);
			}
			cout << "$ Options manual reset started..." << endl;
			bool storedAIM = AIM;
			bool storedTRIG = TRIG;
			AIM = false;
			TRIG = false;
			cout << "$ Waiting for threads to enter paused state..." << endl;
			while (!Thread1Paused)
			{
				cout << ".";
				Sleep(500);
			}
			cout << endl << "$ Done." << endl;
			cout << "$ Options: " << endl;
			cout << "$ Smoothing factor (float) = ";
			cin.sync();
			float tempSmoothWriteCount;
			if (cin >> tempSmoothWriteCount)
			{
				smoothamount = tempSmoothWriteCount;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Minimum RCS pitch compensation scale (float) = ";
			cin.sync();
			float tempPitchMinPunch;
			if (cin >> tempPitchMinPunch)
			{
				PitchMinPunch = tempPitchMinPunch;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Maximum RCS pitch compensation scale (float) = ";
			cin.sync();
			float tempPitchMaxPunch;
			if (cin >> tempPitchMaxPunch)
			{
				PitchMaxPunch = tempPitchMaxPunch;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Minimum RCS yaw compensation scale (float) = ";
			cin.sync();
			float tempYawMinPunch;
			if (cin >> tempYawMinPunch)
			{
				YawMinPunch = tempYawMinPunch;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Maximum RCS yaw compensation scale (float) = ";
			cin.sync();
			float tempYawMaxPunch;
			if (cin >> tempYawMaxPunch)
			{
				YawMaxPunch = tempYawMaxPunch;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Bone number to target(int) = ";
			cin.sync();
			int tempboneid;
			if (cin >> tempboneid)
			{
				TargetBone = tempboneid;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Virtual-Key code of button to use for aimbot (int) = ";
			cin.sync();
			int tempaimkey;
			if (cin >> tempaimkey)
			{
				AimVkeyCode = tempaimkey;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Virtual-Key code of button to use for triggerbot (int) = ";
			cin.sync();
			int temptrigkey;
			if (cin >> temptrigkey)
			{
				TrigVkeyCode = temptrigkey;
			}
			else
			{
				cout << "$ Invalid Value. Keeping default..." << endl;
				cin.clear();
				cin.ignore(10000, '\n');
			}
			cout << "$ Done. Threads should be restored." << endl;
			AIM = storedAIM;
			TRIG = storedTRIG;
		}
		if (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD1) < 0)
		{
			while (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD1) < 0)
			{
				Sleep(100);
			}
			if (AIM)
			{
				AIM = false;
			}
			else
			{
				AIM = true;
			}
			if (AIM)
			{
				aimval = "ON";
			}
			else
			{
				aimval = "OFF";
			}
			cout << "$ AIM: " << aimval << " | TRIG: " << trigval << endl;
		}
		if (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD2) < 0)
		{
			while (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_NUMPAD2) < 0)
			{
				Sleep(100);
			}
			if (TRIG)
			{
				TRIG = false;
			}
			else
			{
				TRIG = true;
			}
			if (TRIG)
			{
				trigval = "ON";
			}
			else
			{
				trigval = "OFF";
			}
			cout << "$ AIM: " << aimval << " | TRIG: " << trigval << endl;
		}
		Sleep(25);
	}
	return 0;
}