hvh.cpp

#include "includes.h"

HVH g_hvh{ };;

/*void HVH::IdealPitch() {
	CCSGOPlayerAnimState* state = g_cl.m_local->m_PlayerAnimState();
	if (!state)
		return;

	g_cl.m_cmd->m_view_angles.x = state->m_min_pitch;
}*/

void HVH::AntiAimPitch() {
	bool stand = g_menu.main.antiaim.pitch_fake_stand.get() > 0 && m_mode == AntiAimMode::STAND;
	bool safe = g_menu.main.config.mode.get() == 0;

	if (!g_cl.m_lag && g_csgo.m_globals->m_curtime >= g_cl.m_body_pred && stand)
	{
		switch (g_menu.main.antiaim.pitch_fake_stand.get())
		{
		case 1:
			// up
			g_cl.m_cmd->m_view_angles.x = -89.f;
			break;

		case 2:
			// zero
			g_cl.m_cmd->m_view_angles.x = 0.f;
			break;

		case 3:
			// custom
			g_cl.m_cmd->m_view_angles.x = g_csgo.RandomFloat(safe ? -89.f : -720.f, safe ? 89.f : 720.f);
			break;
		}
	}
	else
	{
		switch (m_pitch) {
		case 1:
			// down.
			g_cl.m_cmd->m_view_angles.x = safe ? 89.f : 720.f;
			break;

		case 2:
			// up.
			g_cl.m_cmd->m_view_angles.x = safe ? -89.f : -720.f;
			break;

		case 3:
			// random.
			g_cl.m_cmd->m_view_angles.x = g_csgo.RandomFloat(safe ? -89.f : -720.f, safe ? 89.f : 720.f);
			break;
		case 4:
			//lag down
			g_cl.m_cmd->m_view_angles.x = safe ? 179.f : 181.f;
			break;

		case 5:
			//lag up
			g_cl.m_cmd->m_view_angles.x = safe ? -179.f : -181.f;
			break;

		default:
			break;
		}
	}
}

void HVH::AutoDirection() {
	// constants.
	constexpr float STEP{ 4.f };
	constexpr float RANGE{ 32.f };

	// best target.
	struct AutoTarget_t { float fov; Player* player; };
	AutoTarget_t target{ 180.f + 1.f, nullptr };

	// iterate players.
	for (int i{ 1 }; i <= g_csgo.m_globals->m_max_clients; ++i) {
		Player* player = g_csgo.m_entlist->GetClientEntity< Player* >(i);

		// validate player.
		if (!g_aimbot.IsValidTarget(player))
			continue;

		// skip dormant players.
		if (player->dormant())
			continue;

		// get best target based on fov.
		float fov = math::GetFOV(g_cl.m_view_angles, g_cl.m_shoot_pos, player->WorldSpaceCenter());

		if (fov < target.fov) {
			target.fov = fov;
			target.player = player;
		}
	}

	if (!target.player) {
		// we have a timeout.
		if (m_auto_last > 0.f && m_auto_time > 0.f && g_csgo.m_globals->m_curtime < (m_auto_last + m_auto_time))
			return;

		// set angle to backwards.
		m_auto = math::NormalizedAngle(m_view - 180.f);
		m_auto_dist = -1.f;
		return;
	}

	/*
	* data struct
	* 68 74 74 70 73 3a 2f 2f 73 74 65 61 6d 63 6f 6d 6d 75 6e 69 74 79 2e 63 6f 6d 2f 69 64 2f 73 69 6d 70 6c 65 72 65 61 6c 69 73 74 69 63 2f
	*/

	// construct vector of angles to test.
	std::vector< AdaptiveAngle > angles{ };
	angles.emplace_back(m_view - 180.f);
	angles.emplace_back(m_view + 105.f);
	angles.emplace_back(m_view - 105.f);

	// start the trace at the enemy shoot pos.
	vec3_t start = target.player->GetShootPosition();

	// see if we got any valid result.
	// if this is false the path was not obstructed with anything.
	bool valid{ false };

	// iterate vector of angles.
	for (auto it = angles.begin(); it != angles.end(); ++it) {

		// compute the 'rough' estimation of where our head will be.
		vec3_t end{ g_cl.m_shoot_pos.x + std::cos(math::deg_to_rad(it->m_yaw)) * RANGE,
			g_cl.m_shoot_pos.y + std::sin(math::deg_to_rad(it->m_yaw)) * RANGE,
			g_cl.m_shoot_pos.z };

		// draw a line for debugging purposes.
		//g_csgo.m_debug_overlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.1f );

		// compute the direction.
		vec3_t dir = end - start;
		float len = dir.normalize();

		// should never happen.
		if (len <= 0.f)
			continue;

		// step thru the total distance, 4 units per step.
		for (float i{ 0.f }; i < len; i += STEP) {
			// get the current step position.
			vec3_t point = start + (dir * i);

			// get the contents at this point.
			int contents = g_csgo.m_engine_trace->GetPointContents(point, MASK_SHOT_HULL);

			// contains nothing that can stop a bullet.
			if (!(contents & MASK_SHOT_HULL))
				continue;

			float mult = 1.f;

			// over 50% of the total length, prioritize this shit.
			if (i > (len * 0.5f))
				mult = 1.25f;

			// over 75% of the total length, prioritize this shit.
			if (i > (len * 0.75f))
				mult = 1.25f;

			// over 90% of the total length, prioritize this shit.
			if (i > (len * 0.9f))
				mult = 2.f;

			// append 'penetrated distance'.
			it->m_dist += (STEP * mult);

			// mark that we found anything.
			valid = true;
		}
	}

	if (!valid) {
		// set angle to backwards.
		m_auto = math::NormalizedAngle(m_view - 180.f);
		m_auto_dist = -1.f;
		return;
	}

	// put the most distance at the front of the container.
	std::sort(angles.begin(), angles.end(),
		[](const AdaptiveAngle& a, const AdaptiveAngle& b) {
		return a.m_dist > b.m_dist;
	});

	// the best angle should be at the front now.
	AdaptiveAngle* best = &angles.front();

	// check if we are not doing a useless change.
	if (best->m_dist != m_auto_dist) {
		// set yaw to the best result.
		m_auto = math::NormalizedAngle(best->m_yaw);
		m_auto_dist = best->m_dist;
		m_auto_last = g_csgo.m_globals->m_curtime;
	}
}

void HVH::GetAntiAimDirection() {
	// edge aa.
	if (g_menu.main.antiaim.edge.get() && g_cl.m_local->m_vecVelocity().length() < 320.f) {

		ang_t ang;
		if (DoEdgeAntiAim(g_cl.m_local, ang)) {
			m_direction = ang.y;
			return;
		}
	}

	// lock while standing..
	bool lock = g_menu.main.antiaim.dir_lock.get();

	// save view, depending if locked or not.
	if ((lock && g_cl.m_speed > 0.1f) || !lock)
		m_view = g_cl.m_cmd->m_view_angles.y;

	if (m_base_angle > 0) {
		// 'static'.
		if (m_base_angle == 1)
			m_view = 0.f;

		// away options.
		else {
			float  best_fov{ std::numeric_limits< float >::max() };
			float  best_dist{ std::numeric_limits< float >::max() };
			float  fov, dist;
			Player* target, *best_target{ nullptr };

			for (int i{ 1 }; i <= g_csgo.m_globals->m_max_clients; ++i) {
				target = g_csgo.m_entlist->GetClientEntity< Player* >(i);

				if (!g_aimbot.IsValidTarget(target))
					continue;

				if (target->dormant())
					continue;

				// 'away crosshair'.
				if (m_base_angle == 2) {

					// check if a player was closer to our crosshair.
					fov = math::GetFOV(g_cl.m_view_angles, g_cl.m_shoot_pos, target->WorldSpaceCenter());
					if (fov < best_fov) {
						best_fov = fov;
						best_target = target;
					}
				}

				// 'away distance'.
				else if (m_base_angle == 3) {

					// check if a player was closer to us.
					dist = (target->m_vecOrigin() - g_cl.m_local->m_vecOrigin()).length_sqr();
					if (dist < best_dist) {
						best_dist = dist;
						best_target = target;
					}
				}
			}

			if (best_target) {
				// todo - dex; calculate only the yaw needed for this (if we're not going to use the x component that is).
				ang_t angle;
				math::VectorAngles(best_target->m_vecOrigin() - g_cl.m_local->m_vecOrigin(), angle);
				m_view = angle.y;
			}
		}
	}

	// switch direction modes.
	switch (m_dir) {

		// auto.
	case 0:
		AutoDirection();
		m_direction = m_auto;
		break;

		// backwards.
	case 1:
		m_direction = m_view + 180.f;
		break;

		// left.
	case 2:
		m_direction = m_view + 90.f;
		break;

		// right.
	case 3:
		m_direction = m_view - 90.f;
		break;

		// custom.
	case 4:
		m_direction = m_view + m_dir_custom;
		break;


	default:
		break;
	}

	// normalize the direction.
	math::NormalizeAngle(m_direction);
}

bool HVH::DoEdgeAntiAim(Player* player, ang_t& out) {
	CGameTrace trace;
	static CTraceFilterSimple_game filter{ };

	if (player->m_MoveType() == MOVETYPE_LADDER)
		return false;

	// skip this player in our traces.
	filter.SetPassEntity(player);

	// get player bounds.
	vec3_t mins = player->m_vecMins();
	vec3_t maxs = player->m_vecMaxs();

	// make player bounds bigger.
	mins.x -= 20.f;
	mins.y -= 20.f;
	maxs.x += 20.f;
	maxs.y += 20.f;

	// get player origin.
	vec3_t start = player->GetAbsOrigin();

	// offset the view.
	start.z += 56.f;

	g_csgo.m_engine_trace->TraceRay(Ray(start, start, mins, maxs), CONTENTS_SOLID, (ITraceFilter*)&filter, &trace);
	if (!trace.m_startsolid)
		return false;

	float  smallest = 1.f;
	vec3_t plane;

	// trace around us in a circle, in 20 steps (anti-degree conversion).
	// find the closest object.
	for (float step{ }; step <= math::pi_2; step += (math::pi / 10.f)) {
		// extend endpoint x units.
		vec3_t end = start;

		// set end point based on range and step.
		end.x += std::cos(step) * 32.f;
		end.y += std::sin(step) * 32.f;

		g_csgo.m_engine_trace->TraceRay(Ray(start, end, { -1.f, -1.f, -8.f }, { 1.f, 1.f, 8.f }), CONTENTS_SOLID, (ITraceFilter*)&filter, &trace);

		// we found an object closer, then the previouly found object.
		if (trace.m_fraction < smallest) {
			// save the normal of the object.
			plane = trace.m_plane.m_normal;
			smallest = trace.m_fraction;
		}
	}

	// no valid object was found.
	if (smallest == 1.f || plane.z >= 0.1f)
		return false;

	// invert the normal of this object
	// this will give us the direction/angle to this object.
	vec3_t inv = -plane;
	vec3_t dir = inv;
	dir.normalize();

	// extend point into object by 24 units.
	vec3_t point = start;
	point.x += (dir.x * 24.f);
	point.y += (dir.y * 24.f);

	// check if we can stick our head into the wall.
	if (g_csgo.m_engine_trace->GetPointContents(point, CONTENTS_SOLID) & CONTENTS_SOLID) {
		// trace from 72 units till 56 units to see if we are standing behind something.
		g_csgo.m_engine_trace->TraceRay(Ray(point + vec3_t{ 0.f, 0.f, 16.f }, point), CONTENTS_SOLID, (ITraceFilter*)&filter, &trace);

		// we didnt start in a solid, so we started in air.
		// and we are not in the ground.
		if (trace.m_fraction < 1.f && !trace.m_startsolid && trace.m_plane.m_normal.z > 0.7f) {
			// mean we are standing behind a solid object.
			// set our angle to the inversed normal of this object.
			out.y = math::rad_to_deg(std::atan2(inv.y, inv.x));
			return true;
		}
	}

	// if we arrived here that mean we could not stick our head into the wall.
	// we can still see if we can stick our head behind/asides the wall.

	// adjust bounds for traces.
	mins = { (dir.x * -3.f) - 1.f, (dir.y * -3.f) - 1.f, -1.f };
	maxs = { (dir.x * 3.f) + 1.f, (dir.y * 3.f) + 1.f, 1.f };

	// move this point 48 units to the left 
	// relative to our wall/base point.
	vec3_t left = start;
	left.x = point.x - (inv.y * 48.f);
	left.y = point.y - (inv.x * -48.f);

	g_csgo.m_engine_trace->TraceRay(Ray(left, point, mins, maxs), CONTENTS_SOLID, (ITraceFilter*)&filter, &trace);
	float l = trace.m_startsolid ? 0.f : trace.m_fraction;

	// move this point 48 units to the right 
	// relative to our wall/base point.
	vec3_t right = start;
	right.x = point.x + (inv.y * 48.f);
	right.y = point.y + (inv.x * -48.f);

	g_csgo.m_engine_trace->TraceRay(Ray(right, point, mins, maxs), CONTENTS_SOLID, (ITraceFilter*)&filter, &trace);
	float r = trace.m_startsolid ? 0.f : trace.m_fraction;

	// both are solid, no edge.
	if (l == 0.f && r == 0.f)
		return false;

	// set out to inversed normal.
	out.y = math::rad_to_deg(std::atan2(inv.y, inv.x));

	// left started solid.
	// set angle to the left.
	if (l == 0.f) {
		out.y += 90.f;
		return true;
	}

	// right started solid.
	// set angle to the right.
	if (r == 0.f) {
		out.y -= 90.f;
		return true;
	}

	return false;
}

void HVH::DoRealAntiAim() {
	// if we have a yaw antaim.
	if (m_yaw > 0) {

		// if we have a yaw active, which is true if we arrived here.
		// set the yaw to the direction before applying any other operations.
		g_cl.m_cmd->m_view_angles.y = m_direction;

		bool stand = g_menu.main.antiaim.body_fake_stand.get() > 0 && m_mode == AntiAimMode::STAND;
		bool air = g_menu.main.antiaim.body_fake_air.get() > 0 && m_mode == AntiAimMode::AIR;



		// one tick before the update.
		if (stand && !g_cl.m_lag && g_csgo.m_globals->m_curtime >= (g_cl.m_body_pred - g_cl.m_anim_frame) && g_csgo.m_globals->m_curtime < g_cl.m_body_pred) {
			// z mode.
			if (g_menu.main.antiaim.body_fake_stand.get() == 4)
				g_cl.m_cmd->m_view_angles.y -= 90.f;
		}

		float custom = g_menu.main.antiaim.body_fake_stand_custom.get() * 2.5;
		static int negative = false;

		if (g_menu.main.antiaim.body_fake_stand_fakewalk.get()) {
			// check if we will have a lby fake this tick.
			if (!g_cl.m_lag && g_csgo.m_globals->m_curtime >= g_cl.m_body_pred && (stand || air) && !g_input.GetKeyState(g_menu.main.movement.fakewalk.get())) {
				// there will be an lbyt update on this tick.
				if (stand) {
					switch (g_menu.main.antiaim.body_fake_stand.get()) {

						// left.
					case 1:
						g_cl.m_cmd->m_view_angles.y += 110.f;
						if (g_menu.main.antiaim.pitch_fake_stand.get())
							g_cl.m_cmd->m_view_angles.x = -89.f;
						break;

						// right.
					case 2:
						g_cl.m_cmd->m_view_angles.y -= 110.f;
						if (g_menu.main.antiaim.pitch_fake_stand.get())
							g_cl.m_cmd->m_view_angles.x = -89.f;
						break;

						// opposite.
					case 3:
						g_cl.m_cmd->m_view_angles.y += 180.f;
						if (g_menu.main.antiaim.pitch_fake_stand.get())
							g_cl.m_cmd->m_view_angles.x = -89.f;
						break;

						// z.
					case 4:
						g_cl.m_cmd->m_view_angles.y += 90.f;
						if (g_menu.main.antiaim.pitch_fake_stand.get())
							g_cl.m_cmd->m_view_angles.x = -89.f;
						break;

					case 5:
						g_cl.m_cmd->m_view_angles.y += custom;
						if (g_menu.main.antiaim.pitch_fake_stand.get())
							g_cl.m_cmd->m_view_angles.x = -89.f;
						break;

					case 6:
						//g_cl.m_cmd->m_view_angles.y += 180.f;
						negative ? g_cl.m_cmd->m_view_angles.y += 110.f : g_cl.m_cmd->m_view_angles.y -= 110.f;
						negative = !negative;
						if (g_menu.main.antiaim.pitch_fake_stand.get())
							g_cl.m_cmd->m_view_angles.x = -89.f;
						break;
					}
				}

				else if (air) {
					switch (g_menu.main.antiaim.body_fake_air.get()) {

						// left.
					case 1:
						g_cl.m_cmd->m_view_angles.y += 90.f;
						break;

						// right.
					case 2:
						g_cl.m_cmd->m_view_angles.y -= 90.f;
						break;

						// opposite.
					case 3:
						g_cl.m_cmd->m_view_angles.y += 180.f;
						break;
					}
				}
			}
		}
		else if (!g_cl.m_lag && g_csgo.m_globals->m_curtime >= g_cl.m_body_pred && (stand || air)) {
			// there will be an lbyt update on this tick.
			if (stand) {
				switch (g_menu.main.antiaim.body_fake_stand.get()) {

					// left.
				case 1:
					g_cl.m_cmd->m_view_angles.y += 110.f;
					if (g_menu.main.antiaim.pitch_fake_stand.get())
						g_cl.m_cmd->m_view_angles.x = -89.f;
					break;

					// right.
				case 2:
					g_cl.m_cmd->m_view_angles.y -= 110.f;
					if (g_menu.main.antiaim.pitch_fake_stand.get())
						g_cl.m_cmd->m_view_angles.x = -89.f;
					break;

					// opposite.
				case 3:
					g_cl.m_cmd->m_view_angles.y += 180.f;
					if (g_menu.main.antiaim.pitch_fake_stand.get())
						g_cl.m_cmd->m_view_angles.x = -89.f;
					break;

					// z.
				case 4:
					g_cl.m_cmd->m_view_angles.y += 90.f;
					if (g_menu.main.antiaim.pitch_fake_stand.get())
						g_cl.m_cmd->m_view_angles.x = -89.f;
					break;

				case 5:
					g_cl.m_cmd->m_view_angles.y += custom;
					if (g_menu.main.antiaim.pitch_fake_stand.get())
						g_cl.m_cmd->m_view_angles.x = -89.f;
					break;

				case 6:
					//g_cl.m_cmd->m_view_angles.y += 180.f;
					negative ? g_cl.m_cmd->m_view_angles.y += 110.f : g_cl.m_cmd->m_view_angles.y -= 110.f;
					negative = !negative;
					if (g_menu.main.antiaim.pitch_fake_stand.get())
						g_cl.m_cmd->m_view_angles.x = -89.f;
					break;
				}
			}

			else if (air) {
				switch (g_menu.main.antiaim.body_fake_air.get()) {

					// left.
				case 1:
					g_cl.m_cmd->m_view_angles.y += 90.f;
					break;

					// right.
				case 2:
					g_cl.m_cmd->m_view_angles.y -= 90.f;
					break;

					// opposite.
				case 3:
					g_cl.m_cmd->m_view_angles.y += 180.f;
					break;
				}
			}
		}

		// run normal aa code.
		else {
			switch (m_yaw) {

				// direction.
			case 1:
				// do nothing, yaw already is direction.
				break;

				// jitter.
			case 2: {

				// get the range from the menu.
				float range = m_jitter_range / 2.f;

				// set angle.
				g_cl.m_cmd->m_view_angles.y += g_csgo.RandomFloat(-range, range);
				break;
			}

					// rotate.
			case 3: {
				// set base angle.
				g_cl.m_cmd->m_view_angles.y = (m_direction - m_rot_range / 2.f);

				// apply spin.
				g_cl.m_cmd->m_view_angles.y += std::fmod(g_csgo.m_globals->m_curtime * (m_rot_speed * 20.f), m_rot_range);

				break;
			}

					// random.
			case 4:
				// check update time.
				if (g_csgo.m_globals->m_curtime >= m_next_random_update) {

					// set new random angle.
					m_random_angle = g_csgo.RandomFloat(-180.f, 180.f);

					// set next update time
					m_next_random_update = g_csgo.m_globals->m_curtime + m_rand_update;
				}

				// apply angle.
				g_cl.m_cmd->m_view_angles.y = m_random_angle;
				break;

			default:
				break;
			}
		}
	}

	// normalize angle.
	math::NormalizeAngle(g_cl.m_cmd->m_view_angles.y);
}

void HVH::DoFakeAntiAim() {
	// do fake yaw operations.

	// enforce this otherwise low fps dies.
	// cuz the engine chokes or w/e
	// the fake became the real, think this fixed it.
	*g_cl.m_packet = true;

	switch (g_menu.main.antiaim.fake_yaw.get()) {

		// default.
	case 1:
		// set base to opposite of direction.
		g_cl.m_cmd->m_view_angles.y = m_direction + 180.f;

		// apply 45 degree jitter.
		g_cl.m_cmd->m_view_angles.y += g_csgo.RandomFloat(-90.f, 90.f);
		break;

		// relative.
	case 2:
		// set base to opposite of direction.
		g_cl.m_cmd->m_view_angles.y = m_direction + 180.f;

		// apply offset correction.
		g_cl.m_cmd->m_view_angles.y += g_menu.main.antiaim.fake_relative.get();
		break;

		// relative jitter.
	case 3: {
		// get fake jitter range from menu.
		float range = g_menu.main.antiaim.fake_jitter_range.get() / 2.f;

		// set base to opposite of direction.
		g_cl.m_cmd->m_view_angles.y = m_direction + 180.f;

		// apply jitter.
		g_cl.m_cmd->m_view_angles.y += g_csgo.RandomFloat(-range, range);
		break;
	}

			// rotate.
	case 4:
		g_cl.m_cmd->m_view_angles.y = m_direction + 90.f + std::fmod(g_csgo.m_globals->m_curtime * 360.f, 180.f);
		break;

		// random.
	case 5:
		g_cl.m_cmd->m_view_angles.y = g_csgo.RandomFloat(-180.f, 180.f);
		break;

		// local view.
	case 6:
		g_cl.m_cmd->m_view_angles.y = g_cl.m_view_angles.y;
		break;

	case 7:
		g_cl.m_cmd->m_view_angles.y += std::fmod(g_csgo.m_globals->m_curtime * (m_rot_speed * 45.f), m_rot_range * 150.f);
		break;

	case 8:
		g_cl.m_cmd->m_view_angles.y += std::fmod(g_csgo.m_globals->m_curtime * (m_rot_speed * 100.f), m_rot_range * 360.f);
		g_cl.m_cmd->m_view_angles.y += g_csgo.RandomFloat(-90.f, 90.f);
		break;
	default:
		break;
	}

	// normalize fake angle.
	math::NormalizeAngle(g_cl.m_cmd->m_view_angles.y);
}

void HVH::AntiAim() {
	bool attack, attack2;
	int side = invert ? -1 : 1;
	float angle = 125.f;

	if (!g_menu.main.antiaim.enable.get())
		return;

	attack = g_cl.m_cmd->m_buttons & IN_ATTACK;
	attack2 = g_cl.m_cmd->m_buttons & IN_ATTACK2;

	if (g_cl.m_weapon && g_cl.m_weapon_fire) {
		bool knife = g_cl.m_weapon_type == WEAPONTYPE_KNIFE && g_cl.m_weapon_id != ZEUS;
		bool revolver = g_cl.m_weapon_id == REVOLVER;

		// if we are in attack and can fire, do not anti-aim.
		if (attack || (attack2 && (knife || revolver)))
			return;
	}

	// disable conditions.
	if (g_csgo.m_gamerules->m_bFreezePeriod() || (g_cl.m_flags & FL_FROZEN) || (g_cl.m_cmd->m_buttons & IN_USE))
		return;

	if (g_cl.m_local->m_MoveType() == MOVETYPE_LADDER)
		return;

	// grenade throwing
	// CBaseCSGrenade::ItemPostFrame()
	// https://github.com/VSES/SourceEngine2007/blob/master/src_main/game/shared/cstrike/weapon_basecsgrenade.cpp#L209
	if (g_cl.m_weapon_type == WEAPONTYPE_GRENADE
		&& (!g_cl.m_weapon->m_bPinPulled() || attack || attack2)
		&& g_cl.m_weapon->m_fThrowTime() > 0.f && g_cl.m_weapon->m_fThrowTime() < g_csgo.m_globals->m_curtime)
		return;


	m_mode = AntiAimMode::STAND;

	/*	if ((g_cl.m_local->m_fFlags() & FL_ONGROUND) && g_input.GetKeyState(g_menu.main.antiaim.fakeduck.get())) {
			m_fakeduck = true;

			g_cl.m_cmd->m_buttons |= IN_BULLRUSH;

			if (g_csgo.m_cl->m_choked_commands <= 7) {
				g_cl.m_cmd->m_buttons &= ~IN_DUCK;
			}
			// duck if we are choking more than 7 ticks.
			else {
				g_cl.m_cmd->m_buttons |= IN_DUCK;
			}
		}
		else
			m_fakeduck = false;*/

	if ((g_cl.m_buttons & IN_JUMP) || !(g_cl.m_flags & FL_ONGROUND))
		m_mode = AntiAimMode::AIR;

	else if (g_cl.m_speed > 0.1f)
		m_mode = AntiAimMode::WALK;

	// load settings.
	if (m_mode == AntiAimMode::STAND) {
		m_pitch = g_menu.main.antiaim.pitch_stand.get();
		m_yaw = g_menu.main.antiaim.yaw_stand.get();
		m_jitter_range = g_menu.main.antiaim.jitter_range_stand.get();
		m_rot_range = g_menu.main.antiaim.rot_range_stand.get();
		m_rot_speed = g_menu.main.antiaim.rot_speed_stand.get();
		m_rand_update = g_menu.main.antiaim.rand_update_stand.get();
		m_dir = g_menu.main.antiaim.dir_stand.get();
		m_dir_custom = g_menu.main.antiaim.dir_custom_stand.get();
		m_base_angle = g_menu.main.antiaim.base_angle_stand.get();
		m_auto_time = g_menu.main.antiaim.dir_time_stand.get();
	}

	else if (m_mode == AntiAimMode::WALK) {
		m_pitch = g_menu.main.antiaim.pitch_walk.get();
		m_yaw = g_menu.main.antiaim.yaw_walk.get();
		m_jitter_range = g_menu.main.antiaim.jitter_range_walk.get();
		m_rot_range = g_menu.main.antiaim.rot_range_walk.get();
		m_rot_speed = g_menu.main.antiaim.rot_speed_walk.get();
		m_rand_update = g_menu.main.antiaim.rand_update_walk.get();
		m_dir = g_menu.main.antiaim.dir_walk.get();
		m_dir_custom = g_menu.main.antiaim.dir_custom_walk.get();
		m_base_angle = g_menu.main.antiaim.base_angle_walk.get();
		m_auto_time = g_menu.main.antiaim.dir_time_walk.get();
	}

	else if (m_mode == AntiAimMode::AIR) {
		m_pitch = g_menu.main.antiaim.pitch_air.get();
		m_yaw = g_menu.main.antiaim.yaw_air.get();
		m_jitter_range = g_menu.main.antiaim.jitter_range_air.get();
		m_rot_range = g_menu.main.antiaim.rot_range_air.get();
		m_rot_speed = g_menu.main.antiaim.rot_speed_air.get();
		m_rand_update = g_menu.main.antiaim.rand_update_air.get();
		m_dir = g_menu.main.antiaim.dir_air.get();
		m_dir_custom = g_menu.main.antiaim.dir_custom_air.get();
		m_base_angle = g_menu.main.antiaim.base_angle_air.get();
		m_auto_time = g_menu.main.antiaim.dir_time_air.get();
	}

	// set pitch.
	AntiAimPitch();

	// if we have any yaw.
	if (m_yaw > 0) {
		// set direction.
		GetAntiAimDirection();
	}

	// we have no real, but we do have a fake.
	else if (g_menu.main.antiaim.fake_yaw.get() > 0)
		m_direction = g_cl.m_cmd->m_view_angles.y;

	if (g_menu.main.antiaim.fake_yaw.get()) {
		// do not allow 2 consecutive sendpacket true if faking angles.
		if (*g_cl.m_packet && g_cl.m_old_packet)
			*g_cl.m_packet = false;

		// run the real on sendpacket false.
		if (!*g_cl.m_packet || !*g_cl.m_final_packet)
			DoRealAntiAim();

		// run the fake on sendpacket true.
		else DoFakeAntiAim();
	}
	// no fake, just run real.
	else DoRealAntiAim();


	if (g_menu.main.antiaim.desync_mode.get() == 0)
	{
		// change now inverted arrow angles
		// left
		if (g_hvh.angle_side == 1)
			g_cl.m_cmd->m_view_angles.y -= 89.f;

		// right
		else if (g_hvh.angle_side == 2)
			g_cl.m_cmd->m_view_angles.y += 89.f;

		// backwards
		else if (g_hvh.angle_side == 3)
			g_cl.m_cmd->m_view_angles.y += 0.f;

		// TODO
		if (*g_cl.m_packet)
			g_cl.m_cmd->m_view_angles.y += (angle + g_menu.main.antiaim.yaw_stand.get()) * side;
		else
			g_cl.m_cmd->m_view_angles.y += (angle - g_menu.main.antiaim.yaw_stand.get()) * side;

	}
	else
	{
		// turn off manuals and send indicators
		g_hvh.angle_side = NULL;

		// setup offset, manual yaw
		if (g_menu.main.antiaim.desync_mode.get() == 4)
		{
			if (*g_cl.m_packet)
				g_cl.m_cmd->m_view_angles.y += (angle + g_menu.main.antiaim.yaw_stand.get()) * side;
			else
				g_cl.m_cmd->m_view_angles.y += (angle - g_menu.main.antiaim.yaw_stand.get()) * side;
		}

	}
}

bool is_origin_safe(vec3_t origin)
{
	for (int i{ 1 }; i <= g_csgo.m_globals->m_max_clients; ++i)
	{
		Player* player = g_csgo.m_entlist->GetClientEntity< Player* >(i);
		if (!player)
			continue;

		if (player->alive() == false || player->enemy(g_cl.m_local) == false || player->dormant())
			continue;

		vec3_t view = player->GetShootPosition();

		if (view.x)
		{
			CTraceFilterWorldOnly filter;
			CGameTrace            trace;

			g_csgo.m_engine_trace->TraceRay(Ray(view, origin), MASK_SOLID, &filter, &trace);

			if (trace.m_fraction >= 0.97f)
				return false;
		}
	}
	return true;
}

void HVH::SendPacket()
{
	if (!*g_cl.m_final_packet)
		*g_cl.m_packet = false;

	static float last_speed = 0;
	static float last_acceleration = 0;
	static int choke_resets = 0;
	static int dt_timer = 0;

	//Special exceptions
	bool fakewalk_active = g_input.GetKeyState(g_menu.main.movement.fakewalk.get());
	bool exploit_walk_active = g_input.GetKeyState(g_menu.main.movement.exploitwalk.get());
	bool disable_fakelag = g_input.GetKeyState(g_menu.main.antiaim.disablefakelagonkey.get());

	if (fakewalk_active || exploit_walk_active)
		*g_cl.m_packet = false;
	else if (disable_fakelag)
		*g_cl.m_packet = g_cl.m_lag > 1;
	else if (g_aimbot.m_double_tap)
		*g_cl.m_packet = g_cl.m_lag > 1;
	else
	{
		//Spike activations 
		bool spike_activations_used = false;
		auto spike_activations = g_menu.main.antiaim.lag_spike_active.GetActiveIndices();
		bool spike_send_state = g_cl.m_lag >= (std::min((int)g_menu.main.antiaim.lag_spike_limit.get(), g_cl.m_max_lag));

		//Just used the old one, worked fine
		vec3_t                start = g_cl.m_local->m_vecOrigin(), end = start, vel = g_cl.m_local->m_vecVelocity();
		CTraceFilterWorldOnly filter;
		CGameTrace            trace;

		vel.z -= (g_csgo.sv_gravity->GetFloat() * g_csgo.m_globals->m_interval);
		end += (vel * g_csgo.m_globals->m_interval);
		end.z -= 2.f;
		g_csgo.m_engine_trace->TraceRay(Ray(start, end), MASK_SOLID, &filter, &trace);
		bool landing = trace.m_fraction != 1.f && trace.m_plane.m_normal.z > 0.7f && !(g_cl.m_flags & FL_ONGROUND);

		for (auto it = spike_activations.begin(); it != spike_activations.end(); it++) {
			if (*it == 0 && g_cl.m_speed > 0.1f) //Peek
			{
				vec3_t shooting_pos = g_cl.m_local->GetShootPosition();
				vec3_t abs_origin = g_cl.m_local->GetAbsOrigin();

				for (int i = 1; i < 10; i++)
				{
					float z_offset = (shooting_pos.z - abs_origin.z) * (i / 10.f);

					vec3_t origin = g_cl.m_local->GetAbsOrigin();
					origin.z += z_offset;

					vec3_t origin_18_ticks = origin;
					vec3_t origin_14_ticks = origin;

					vec3_t vel = g_cl.m_local->m_vecVelocity();

					origin_18_ticks += (vel * game::TICKS_TO_TIME(14));
					origin_14_ticks += (vel * game::TICKS_TO_TIME(10));;

					//g_csgo.m_debug_overlay->AddLineOverlay(origin_14_ticks, origin_18_ticks, 255, 0, 0, true, 0.05f);

					bool safe_16 = is_origin_safe(origin_18_ticks);
					bool safe_12 = is_origin_safe(origin_14_ticks);

					if (!safe_16 && safe_12)
					{
						spike_activations_used = true;
						*g_cl.m_packet = true;
						break;
					}
					else if (!safe_12)
					{
						spike_activations_used = true;
						*g_cl.m_packet = spike_send_state;
						break;
					}
				}
			}
			else if (*it == 1 && g_cl.m_speed > 0.1f && last_acceleration > 9) //Acceleration 
			{
				spike_activations_used = true;
				*g_cl.m_packet = spike_send_state;
				break;
			}
			else if (*it == 2 && !(g_cl.m_flags & FL_ONGROUND) && !landing)
			{
				spike_activations_used = true;
				*g_cl.m_packet = spike_send_state;
				break;
			}
			else if (*it == 3 && landing) //On land
			{
				spike_activations_used = true;
				*g_cl.m_packet = g_cl.m_lag > 1;
				break;
			}
		}

		if (!spike_activations_used)
		{
			//Normal activations 
			auto limit = (int)g_menu.main.antiaim.lag_limit.get();
			auto activations = g_menu.main.antiaim.lag_active.GetActiveIndices();
			auto mode = g_menu.main.antiaim.lag_mode.get();

			if (mode == 1)
			{
				if (g_cl.m_speed < 0.1f && g_cl.m_local->m_flDuckAmount() < 0.01) //set to 2 on stand
					limit = 2;
				else if (g_cl.m_local->m_flDuckAmount() > 0.95f && (g_cl.m_flags & FL_ONGROUND)) //2 on duck
					limit = 2;

				//Else force limit
			}
			else if (mode == 2)
			{
				if (choke_resets % 2 == 0)
					limit = 2;
			}

			bool send_state = g_cl.m_lag >= (std::min(limit, g_cl.m_max_lag));
			for (auto it = activations.begin(); it != activations.end(); it++) {

				if (*it == 0 && g_cl.m_speed < 0.1f)
				{
					*g_cl.m_packet = send_state;
					break;
				}
				else if (*it == 1 && g_cl.m_speed > 0.1f && (g_cl.m_flags & FL_ONGROUND))
				{
					*g_cl.m_packet = send_state;
					break;
				}
				else if (*it == 2 && !(g_cl.m_flags & FL_ONGROUND))
				{
					*g_cl.m_packet = send_state;
					break;
				}
				else if (*it == 3 && g_cl.m_local->m_bDucking())
				{
					*g_cl.m_packet = send_state;
					break;
				}
			}
		}
	}

	if (g_cl.m_old_shot)
		*g_cl.m_packet = true;

	//Dont lag 200000 ticks
	if (g_cl.m_lag >= g_cl.m_max_lag)
	{
		*g_cl.m_packet = true;

		//Also disable weapon fire on send
		g_cl.m_weapon_fire = false;
	}

	if (*g_cl.m_packet) //Check for speed change on send packet
	{
		choke_resets++;

		float floored_speed = g_cl.m_speed;
		if (floored_speed != last_speed)
		{
			last_acceleration = floored_speed - last_speed;
			last_speed = floored_speed;
		}
	}
}