Aimbot / Recoil Control / Triggerbot

#include "AimBot.h"
#include "Process.h"
#include "Entity.h"
#include "MyWindow.h"
CAimBot* AimBot = new CAimBot;
//char *AimBonesNames[4] = { "Head", "Neck", "Chest", "Stomach"};
//_OnceXOR("Head"), _OnceXOR("Neck"), _OnceXOR("Chest"), _OnceXOR("Stomach")
CAimBot::CAimBot()
{
}


CAimBot::~CAimBot()
{
}


int CAimBot::AimBonesTable[4] = { 10, 5, 4, 2 };

int CAimBot::SleepTime = 10;
int CAimBot::HotKey = 0x06;//0x2;
int CAimBot::FOV = 5;//15;
int CAimBot::TargetID = -1;
int CAimBot::LastTarget = -1;
int CAimBot::PredictMovment = 17;
int CAimBot::AimBoneID = 10;
int CAimBot::AimBoneIndex = 0;

Bones CAimBot::AimBone;
float CAimBot::DistanceFromCrosshair = 99999;
float CAimBot::Distance = 99999;
float CAimBot::ClosestDistance = 99999;
float CAimBot::m_Ingamesensitivity = 2.0;
float CAimBot::RadiusX = 0;
float CAimBot::RadiusY = 0;
float CAimBot::Radius = 0;
float CAimBot::m_XMultiplayer = 2.0;
float CAimBot::m_YMultiplayer = 2.0;
float CAimBot::BustSpeed = 1.0;
float CAimBot::Pixels = 0;
float CAimBot::Smooth = 1.0;
float CAimBot::StopAimingAtDistance = 0;

float CAimBot::Imprecise = 0;
float CAimBot::ImpreciseX = 0;
float CAimBot::ImpreciseY = 0;
float CAimBot::LastImpreciseX = 0;
float CAimBot::LastImpreciseY = 0;
clock_t CAimBot::flTargetTime;
clock_t CAimBot::LastRandomMove;
float CAimBot::MaxRandTime = 100;
float CAimBot::AdditionalTime = 20;
float CAimBot::RandomMultiplier = 1.5;
float CAimBot::RandomX = 1.5;
float CAimBot::RandomY = 1.5;
bool CAimBot::bRandomMoves = false;
bool CAimBot::StopRandomMovesWhenShooting = true;

bool CAimBot::Active = false;
bool CAimBot::AimOnClosestToPlayer = false;
bool CAimBot::AimOnClosestToCrosshair = true;
bool CAimBot::LockOnTarget = false;
bool CAimBot::DrawFOV = true;//false;
bool CAimBot::bRage = false;//true;
bool CAimBot::DontLockNext = false;
bool CAimBot::FocusOnlySpotted = false;

Vector3D CAimBot::AimPosition;
Vector3D CAimBot::Diffrnce;

clock_t CAimBot::AimbotStartTime = 0;
int CAimBot::StopAimbotAfterXMS = 0;
//bool CAimBot::StopAimbotAfterXMS;



Color CAimBot::FovColor = Color((float)120 / (float)255, (float)0 / (float)255, (float)125 / (float)255, (float)0 / (float)255);


void CAimBot::DropTarget()
{
	TargetID = -1;
	ClosestDistance = Distance = 99999;
	DistanceFromCrosshair = 99999;
}

void CAimBot::GetBestTarget()
{
	//if (TargetID == -1)
	//{
	AimBoneID = AimBonesTable[AimBoneIndex];
	for (int i = 0; i < GlobalVariables::MaxPlayers; i++)
	{
		if (!Entity[i].Valid)
			continue;

		if (!Entity[i].ValidBones)
			continue;

		if (FocusOnlySpotted)
		{
			if (Entity[i].Spotted == false)
				continue;
		}

		if (Entity[i].Team == LocalPlayer->Team)
			continue;
		if (Entity[i].IsLocalPlayer == true)
			continue;

		if (!Entity[i].Bone[AimBoneID].IsOnScreen)
			continue;

		DistanceFromCrosshair = Get3dDistance(Vector3D{ Entity[i].Bone[AimBoneID].PositionOnScreen.x, Entity[i].Bone[AimBoneID].PositionOnScreen.y, 0 }, Vector3D{ (float)(CMyWindow::Width / 2), (float)(CMyWindow::Height / 2), 0 });
		if (AimOnClosestToCrosshair)
			Distance = DistanceFromCrosshair;
		else
			Distance = Entity[i].Distance;

		if (DistanceFromCrosshair <= Radius)
		{
			if (Distance < ClosestDistance)
			{
				ClosestDistance = Distance;
				TargetID = i;
			}
		}

	}
	//}
}

void CAimBot::CheckFov()
{
	/*
	float fov = 0.0f, mag = 0.0f, dot = 0.0f;
	QAngle ang, aim;
	gUtil.calcAngles(source, dest, ang);
	makeVector(angle, aim);
	makeVector(ang, ang);
	mag = sqrt(aim[0] * aim[0] + aim[1] * aim[1] + aim[2] * aim[2]);
	dot = aim[0] * ang[0] + aim[1] * ang[1] + aim[2] * ang[2];
	fov = acos(dot / (mag * mag)) * 57.2957914;
	return fov;
	*/
}

void CAimBot::Rage()
{
	Vector3D TempAimpos = AimPosition;

	TempAimpos.x /= Pixels*(-1.0);
	TempAimpos.y /= Pixels;

	if (TempAimpos.x > 1 || TempAimpos.x < -1)
		AimPosition.x = TempAimpos.x;
	else
		AimPosition.x /= -0.22;

	if (TempAimpos.y > 1 || TempAimpos.y < -1)
		AimPosition.y = TempAimpos.y;
	else
		AimPosition.y /= 0.22;

	if (AimPosition.x > -120 && AimPosition.x  < 120 && AimPosition.y > -120 && AimPosition.y < 120)
	{
		MouseMove(AimPosition.y, AimPosition.x);
	}
}

void CAimBot::Custom()
{
	DistanceFromCrosshair = Get3dDistance(Vector3D{ Entity[TargetID].Bone[AimBoneID].PositionOnScreen.x, Entity[TargetID].Bone[AimBoneID].PositionOnScreen.y, 0 }, Vector3D{ (float)(CMyWindow::Width / 2), (float)(CMyWindow::Height / 2), 0 });
	if (DistanceFromCrosshair  < StopAimingAtDistance)
		return;

	if (AimPosition.x > Smooth)
		AimPosition.x = 0 + Smooth;
	else if (AimPosition.x < -Smooth)
		AimPosition.x = 0 - Smooth;

	if (AimPosition.y > Smooth)
		AimPosition.y = 0 + Smooth;
	else if (AimPosition.y < -Smooth)
		AimPosition.y = 0 - Smooth;

	if (bRandomMoves)
		RandomMoves();

	AimPosition.x /= Pixels*(-1.0);
	AimPosition.y /= Pixels;

	MouseMove(AimPosition.y, AimPosition.x);
}


float randMToN(float M, float N)
{
	return M + (rand() / (RAND_MAX / (N - M)));
}

void CAimBot::RandomMoves()
{
	if (StopRandomMovesWhenShooting)
	{
		if (Process->ReadMemory<int>(GlobalVariables::ClientAddress + Offsets::AttackAddres) == 5)
			return;
	}

	if (LastRandomMove + randMToN(0, MaxRandTime) + AdditionalTime < clock())
	{
		float Deviation1 = randMToN(-RandomMultiplier, RandomMultiplier);
		float Devation2 = randMToN(-RandomX, RandomX);
		float Devation3 = randMToN(-RandomY, RandomY);
		switch (rand() % 2)
		{
		case 0:
			ImpreciseX = Deviation1 * cos(Devation2);
			ImpreciseY = Deviation1 * sin(Devation3);
			break;
		case 1:
			ImpreciseX = Deviation1 * sin(Devation2);
			ImpreciseY = Deviation1 * cos(Devation3);
			break;

		}
		LastRandomMove = clock();
	}

	AimPosition.x += ImpreciseX;
	AimPosition.y += ImpreciseY;

}

/*

clock_t CAimBot::AimbotStartTime;
clock_t CAimBot::StopAimbotAfter;
bool CAimBot::StopAimbotAfterXMS;
*/
DWORD WINAPI CAimBot::Run()
{
	while (!GlobalVariables::ExitCheat)
	{
		Sleep(SleepTime);

		if (!Active)
			continue;

		Radius = FOV *(CMyWindow::Height / 90);

		if (HotKey != 0)
		{
			if (!GetAsyncKeyState(HotKey))
			{
				DropTarget();
				AimbotStartTime = 0;
				continue;
			}
			else if(AimbotStartTime == 0)
			{
				AimbotStartTime = clock();
			}
		}
		
		if (StopAimbotAfterXMS != 0 && AimbotStartTime != 0)
		{
			if (AimbotStartTime + StopAimbotAfterXMS < clock())
			{
				//AimbotStartTime = 0;
				continue;
			}
		}
		

		if (DontLockNext == false)
			DropTarget();


		GetBestTarget();
		if (TargetID < 0 || TargetID > GlobalVariables::MaxPlayers)
			continue;
		if (!Entity[TargetID].Valid)
			continue;

		if (TargetID != -1)
		{
			Vector3D BonePred = Entity[TargetID].Bone[AimBoneID].PositionInGame;
			BonePred.x += Entity[TargetID].Velocity.x / PredictMovment;
			BonePred.y += Entity[TargetID].Velocity.y / PredictMovment;
			BonePred.z += Entity[TargetID].Velocity.z / PredictMovment;

			BonePred.z += 1.5;

			CalcAngle(LocalPlayer->EyePos, BonePred, AimPosition);

			if (AimPosition.x < -360 || AimPosition.x > 360)
				continue;

			if (AimPosition.y < -360 || AimPosition.y > 360)
				continue;
			
			AimPosition.x -= m_XMultiplayer*LocalPlayer->Punch.x;
			AimPosition.y -= m_YMultiplayer*LocalPlayer->Punch.y;
			AimPosition.x = LocalPlayer->vViewAngle.x - AimPosition.x;
			AimPosition.y = LocalPlayer->vViewAngle.y - AimPosition.y;

			if (AimPosition.y < -180.0f)
				AimPosition.y += 360.0f;
			if (AimPosition.y > 180.0f)
				AimPosition.y -= 360.0f;

			if (AimPosition.x < -90.0f)
				AimPosition.x += 180.0f;
			if (AimPosition.x > 90.0f)
				AimPosition.x -= 180.0f;

			m_Ingamesensitivity = Process->ReadMemory<float>(GlobalVariables::ClientAddress + Offsets::SensivityAddress);
			Pixels = ((0.22 * m_Ingamesensitivity * 1) / BustSpeed);

			if (bRage)
				Rage();
			else
				Custom();


		}
	}
	ExitThread(0);
}

#pragma once
#include "Math.h"
#include "Drawings.h"
extern char *AimBonesNames[4];
class CAimBot
{
public:

	static int SleepTime;
	static int HotKey;
	static int TargetID;
	static int LastTarget;
	static int FOV;
	static int PredictMovment;

	static int AimBonesTable[4];
	static int AimBoneID;
	static int AimBoneIndex;

	static clock_t AimbotStartTime;
	static int StopAimbotAfterXMS;
	//static bool StopAimbotAfterXMS;

	static float LastImpreciseY;
	static clock_t flTargetTime;
	static clock_t LastRandomMove;
	static float MaxRandTime;

	static Bones AimBone;
	static float Distance;
	static float DistanceFromCrosshair;
	static float ClosestDistance;
	static float m_Ingamesensitivity;
	static float RadiusX;
	static float RadiusY;
	static float Radius;
	static float m_XMultiplayer;
	static float m_YMultiplayer;
	static float BustSpeed;
	static float Pixels;
	static float Smooth;
	static float StopAimingAtDistance;

	static float Imprecise;
	static float ImpreciseX;
	static float ImpreciseY;
	static float LastImpreciseX;
	static float AdditionalTime;
	static float RandomMultiplier;
	static float RandomX;
	static float RandomY;
	static bool bRandomMoves;
	static bool StopRandomMovesWhenShooting;


	static bool Active;
	static bool IsAiming;
	static bool AimOnClosestToPlayer;
	static bool AimOnClosestToCrosshair;
	static bool LockOnTarget;
	static bool DrawFOV;
	static bool bRage;
	static bool DontLockNext;
	static bool FocusOnlySpotted;


	static Vector3D AimPosition;
	static Vector3D Diffrnce;

	static void GetBestTarget();
	static void DropTarget();
	static void Rage();
	static void Custom();
	static void CheckFov();
	static void RandomMoves();
	static DWORD WINAPI Run();

	static Color FovColor;

	CAimBot();
	~CAimBot();
};
extern CAimBot* AimBot;

#include "RecoilControl.h"
#include "AimBot.h"
#include "Entity.h"
#include "Process.h"
CRecoilControl* RecoilControl = new CRecoilControl;

CRecoilControl::CRecoilControl()
{
}


CRecoilControl::~CRecoilControl()
{
}

bool CRecoilControl::Active = false;
int CRecoilControl::ShootingState = false;
int CRecoilControl::SleepTime = 2;
Vector3D CRecoilControl::vDelta = Vector3D{ 0, 0, 0 };
Vector3D CRecoilControl::vPunch = Vector3D{ 0, 0, 0 };
Vector3D CRecoilControl::vPrevPunch = Vector3D{ 0, 0, 0 };
float CRecoilControl::m_Yaw = 0.022;
float CRecoilControl::m_Ingamesensitivity = 2.0;
float CRecoilControl::m_Windowssensitivity = 1;
float CRecoilControl::m_XMultiplayer = 1.6;
float CRecoilControl::m_YMultiplayer = 1.8;
int CRecoilControl::RecoilDrawType = 0;
float CRecoilControl::RecoilDrawResolution = 4;

int CRecoilControl::HotKey = VK_F4;
clock_t CRecoilControl::LastKeyPress = 0;

DWORD WINAPI CRecoilControl::Run()
{
	while (true)
	{
		Sleep(SleepTime);
		if (CAimBot::Active && (GetAsyncKeyState(CAimBot::HotKey) || CAimBot::HotKey == 0))
			continue;

		if (GetAsyncKeyState(HotKey) && LastKeyPress + 250 < clock())
		{
			Active = !Active;
			LastKeyPress = clock();
		}


		if (Active && LocalPlayer->Address != NULL)
		{
			vPunch = LocalPlayer->ReadPunch();
			ShootingState = Process->ReadMemory<int>(GlobalVariables::ClientAddress + Offsets::AttackAddres);
			if (ShootingState == 4)
			{
				vDelta = Vector3D{ 0, 0, 0 };
				vPrevPunch = vPunch;
			}
			else
			{
				m_Ingamesensitivity = Process->ReadMemory<float>(GlobalVariables::ClientAddress + Offsets::SensivityAddress);
				vDelta.x = ((LocalPlayer->Punch.x - vPrevPunch.x)*m_YMultiplayer) / (m_Yaw * m_Ingamesensitivity * GlobalVariables::MouseMultiplyer)*(-1.0);
				vDelta.y = ((LocalPlayer->Punch.y - vPrevPunch.y)*m_XMultiplayer) / (m_Yaw * m_Ingamesensitivity * GlobalVariables::MouseMultiplyer);
				vPrevPunch = LocalPlayer->Punch;

				MouseMove(vDelta.y, vDelta.x);
			}
		}

	}
	return 0x0;
}

#pragma once
#include "Globals.h"
#include "Math.h"

class CRecoilControl
{
public:
	static clock_t RefreshRate;
	static clock_t LastRefersh;

	static int SleepTime;
	static int ShootingState;

	static bool Active;

	static Vector3D vDelta;
	static Vector3D vPunch;
	static Vector3D vPrevPunch;
	static float m_Yaw;
	static float m_Ingamesensitivity;
	static float m_Windowssensitivity;
	static float m_XMultiplayer;
	static float m_YMultiplayer;

	static int RecoilDrawType;
	static float RecoilDrawResolution;

	static DWORD WINAPI Run();

	static int HotKey;
	static clock_t LastKeyPress;

	CRecoilControl();
	~CRecoilControl();
	//SwapLines0
};

extern CRecoilControl* RecoilControl;

#include "TriggerBot.h"
#include "Process.h"
#include "Entity.h"

CTriggerBot TriggerBot;

CTriggerBot::CTriggerBot()
{
}


CTriggerBot::~CTriggerBot()
{
}
bool CTriggerBot::Active = false;
bool CTriggerBot::OnHotKey = false;
bool CTriggerBot::ShootOnHitBox = false;
bool CTriggerBot::Shoot = false;
bool CTriggerBot::SniperMode = false;

float CTriggerBot::MaxPunch = 2;
int CTriggerBot::HotKey = 2;
int CTriggerBot::SleepTime = 2;
int CTriggerBot::DelayTime = 0;
int CTriggerBot::ShootingTime = 0;;
int CTriggerBot::BreakTime = 0;;

int CTriggerBot::Target = -1;
int CTriggerBot::LastTarget = -69;

int CTriggerBot::ExtraShootingTime = 0;
clock_t CTriggerBot::LastExtraShootingTime = 0;

clock_t CTriggerBot::LastTimeTargetUnderCrosshair = 0;

Bones Bone;
//SwapLines0
void CTriggerBot::ShootOnLoseTarget()
{
	if (Shoot && LastTimeTargetUnderCrosshair + ExtraShootingTime > clock())
	{
		MouseButton(MOUSEEVENTF_LEFTDOWN);
		Sleep(ShootingTime);
		MouseButton(MOUSEEVENTF_LEFTUP);
		Sleep(BreakTime);
	}
	else
	{
		Shoot = false;
	}
};


DWORD WINAPI CTriggerBot::Run()
{
	while (true)
	{
		Sleep(SleepTime);
		if (!Active)
			continue;

		if (OnHotKey)
		{
			if (!GetAsyncKeyState(HotKey))
				continue;
		}
		else
		{
			if (GetAsyncKeyState(0x1))
				continue;
		}

		if (LocalPlayer->Clip1 <= 0)
			continue;

		Target = Process->ReadMemory<int>(LocalPlayer->Address + 0x00002400) - 1;

		if (Target < 0)
		{
			LastTarget = -69;
			ShootOnLoseTarget();
			continue;
		}
		if (Target > GlobalVariables::MaxPlayers)
		{
			LastTarget = -69;
			ShootOnLoseTarget();
			continue;
		}

		if (Entity[Target].Team == LocalPlayer->Team)
		{
			LastTarget = -69;
			continue;
		}

		if (LocalPlayer->Punch.x >= MaxPunch || LocalPlayer->Punch.y >= MaxPunch)
			continue;

		if (LocalPlayer->Punch.x <= -MaxPunch || LocalPlayer->Punch.y <= -MaxPunch)
			continue;

		if (SniperMode)
		{
			if (LocalPlayer->WeaponID == 9 || LocalPlayer->WeaponID == 38 || LocalPlayer->WeaponID == 11 || LocalPlayer->WeaponID == 40)
			{
				if (LocalPlayer->Fov == 90)
					continue;
			}
		}

		if (ShootOnHitBox)
		{
			Vector3D Bone = Entity[Target].GetBoneFast(10);
			Vector3D BottomHitboxHead = Bone;
			BottomHitboxHead.x += -2.771300f;
			BottomHitboxHead.y += -2.878300f;
			BottomHitboxHead.z += -3.103000f;

			Vector3D TopHitboxHead = Bone;
			TopHitboxHead.x += 6.955000f;
			TopHitboxHead.y += 4.020300f;
			TopHitboxHead.z += 5.006700f;

			Vector3D ViewDirection = AngleToDirection(LocalPlayer->vViewAngle);
			if (!RayTrace->Trace(ViewDirection, BottomHitboxHead, TopHitboxHead))
				continue;
		}

		Sleep(DelayTime);

		MouseButton(MOUSEEVENTF_LEFTDOWN);
		Sleep(ShootingTime);
		MouseButton(MOUSEEVENTF_LEFTUP);

		Sleep(BreakTime);

		Shoot = true;

		LastTarget = Target;
		LastTimeTargetUnderCrosshair = clock();

	}
}

#pragma once
#include "Math.h"
#include "Globals.h"
#include "Entity.h"
#include "RayTrace.h"

class CTriggerBot
{
public:

	static bool Active;
	static bool OnHotKey;
	static bool ShootOnHitBox;
	static bool Shoot;
	static bool SniperMode;

	static float MaxPunch;

	static int HotKey;

	static int SleepTime;

	static int DelayTime;
	static clock_t LastDelayTime;

	static int ShootingTime;
	static clock_t LastShootingTime;

	static int BreakTime;
	static clock_t LastBreakTime;

	static int ExtraShootingTime;
	static clock_t LastExtraShootingTime;

	static clock_t LastTimeTargetUnderCrosshair;



	static int Target;
	static int LastTarget;

	static Bones Bone;

	static DWORD WINAPI Run();

	static void ShootOnLoseTarget();

	CTriggerBot();
	~CTriggerBot();

};
extern CTriggerBot TriggerBot;