static void CalculateAngles(Vector& vecOrigin, Vector& vecOther, Vector &vecAngles)
{
	Vector delta = { (vecOrigin.x - vecOther.x), (vecOrigin.y - vecOther.y), (vecOrigin.z - vecOther.z) };
	float hyp = sqrtf(delta.x * delta.x + delta.y * delta.y);

	vecAngles.x = (float)(atan(delta.z / hyp) * (float)(180.f / M_PI));
	vecAngles.y = (float)(atan(delta.y / delta.x) * (float)(180.f / M_PI));
	vecAngles.z = (float)0.0f;

	if (delta.x >= 0.0)
		vecAngles.y += 180.0f;
}

static Vector BonePos(DWORD EntityBase, int iTargetBone)
{
	DWORD BoneBase = mem.ReadMemory<DWORD>(EntityBase + BoneMatrixOffset);
	Vector vBone;
	vBone.x = mem.ReadMemory<float>(BoneBase + 0x30 * iTargetBone + 0x0C);
	vBone.y = mem.ReadMemory<float>(BoneBase + 0x30 * iTargetBone + 0x1C);
	vBone.z = mem.ReadMemory<float>(BoneBase + 0x30 * iTargetBone + 0x2C);
	return vBone;
}

static void MakeVector(Vector& vecAngle, Vector& out)
{
	float pitch = float(vecAngle.x * M_PI / 180);
	float tmp = float(cos(pitch));
	float yaw = float(vecAngle.y * M_PI / 180);

	out.x = (float)(-tmp * -cos(yaw));
	out.y = (float)(sin(yaw)*tmp);
	out.z = (float)(-sin(pitch));
}


static float GetFov(Vector& vecAngle, Vector& vecOrigin, Vector& vecOther)
{
	Vector ang, aim;
	double fov;
	CalculateAngles(vecOrigin, vecOther, ang);
	MakeVector(vecAngle, aim);
	MakeVector(ang, ang);

	float mag_s = sqrt((aim.x * aim.x) + (aim.y * aim.y) + (aim.z * aim.z));
	float mag_d = sqrt((aim.x * aim.x) + (aim.y * aim.y) + (aim.z * aim.z));

	float u_dot_v = aim.x * ang.x + aim.y * ang.y + aim.z * ang.z;
	fov = acos(u_dot_v / (mag_s*mag_d)) * (180.0f / M_PI);

	return (float)fov;
}

static int ClosestEnemyToCrosshair(float& FOV, Vector& Position)
{
	int index;
	for (int i = 0; i < 64; i++)
	{
		DWORD PlayerBase = NULL;
		GetInfo::GetPlayerBase(&PlayerBase);

		DWORD EntityBase = mem.ReadMemory<DWORD>(dwClient + EntityList + (i * 0x10));
		if (EntityBase == PlayerBase)
			continue;

		bool IsDormant = mem.ReadMemory<bool>(EntityBase + DormantOffset);
		if (IsDormant)
			continue;

		int EntityTeam = mem.ReadMemory<int>(EntityBase + Team);

		int LocalTeam = mem.ReadMemory<int>(PlayerBase + Team);
		if (EntityTeam == LocalTeam)
			continue;

		bool EntityLifeState= mem.ReadMemory<int>(EntityBase + LifeState);
		if (EntityLifeState != true)
			continue;

		DWORD EngineBase;
		GetInfo::GetEngineBase(&EngineBase);
		Vector CurrentViewAngles = mem.ReadMemory<Vector>(EngineBase + ViewAngleOffset);
		Vector Bone = BonePos(EntityBase, 11);
		float Distance = GetFov(CurrentViewAngles, Position, Bone);
		if (Distance < iFOV)
		{
			iFOV = Distance;
			index = i;
		}
	}
	return index;
}

static DWORD WINAPI AimbotThread(LPVOID PARAMS)
{

	while (1)
	{
		if(GetAsyncKeyState(0x01))
		{
			Vector Position;
			int EntityIndex = ClosestEnemyToCrosshair(iFOV, Position);
			DWORD PlayerBase = NULL;
			GetInfo::GetPlayerBase(&PlayerBase);
			Vector vecOrigin = mem.ReadMemory<Vector>(PlayerBase + VecOrigin);
			Vector vecView = mem.ReadMemory<Vector>(PlayerBase + VecViewOffset);
			Position.x = vecOrigin.x + vecView.x;
			Position.y = vecOrigin.y + vecView.y;
			Position.z = vecOrigin.z + vecView.z;


			Vector vPunch = mem.ReadMemory<Vector>(PlayerBase + VectorPunch);
			Vector AimAngles;

			DWORD EntityBase = mem.ReadMemory<DWORD>(dwClient + EntityList + (EntityIndex * 0x10));
			Vector Bone = BonePos(EntityBase, 11);

			CalculateAngles(Position, Bone, AimAngles);
			AimAngles.x = AimAngles.x - vPunch.x * 2.f;
			AimAngles.y = AimAngles.y - vPunch.y * 2.f;
			AimAngles = NormalizeAngles(AimAngles);
			if (AimAngles.x == 0 && AimAngles.y == 0)
				continue;
			DWORD EngineBase;
			GetInfo::GetEngineBase(&EngineBase);
			mem.WriteMemory<Vector>(EngineBase + ViewAngleOffset, AimAngles);
		}
		Sleep(1);
	}
	return 0;
}