#include "CAutoWall.h"

//returninfo c_autowall::autowall(Vector start, Vector end, CBaseEntity* from_ent, CBaseEntity* to_ent, int hitgroup) {
//	returninfo rt;
//
//	fbdata bullet;
//	bullet.start = start;
//	bullet.end = end;
//	bullet.pos = start;
//	bullet.thickness = 0.f;
//	bullet.walls = 4;
//
//	Utilities->Math_AngleVectors(Utilities->Math_CalcAngle(start, end), bullet.dir);
//
//	auto flt_player = CTraceFilterOneEntity();
//	flt_player.pEntity = to_ent;
//
//	auto flt_self = CTraceFilter();
//	flt_self.pSkip1 = from_ent;
//
//	if (to_ent)
//		bullet.filter = &flt_player;
//	else
//		bullet.filter = &flt_self;
//
//	auto wep = from_ent->GetActiveWeapon();
//	if (!wep)
//		return rt;
//
//	auto inf = wep->get_full_info();
//	if (!inf)
//		return rt;
//
//	end = start + bullet.dir * (wep->is_knife() ? 45.f : inf->range);
//	bullet.damage = inf->damage;
//
//	while (bullet.damage > 0 && bullet.walls > 0) {
//		rt.walls = bullet.walls;
//
//		Ray_t ray;
//		ray.Init(bullet.pos, end);
//
//		CTraceFilter filter;
//		filter.pSkip1 = from_ent;
//
//		Interfaces::Trace->TraceRay(ray, MASK_SHOT | CONTENTS_GRATE, &filter, &bullet.trace);
//		this->clip_trace_to_player(bullet.pos, bullet.pos + bullet.dir * 40.f, to_ent, MASK_SHOT | CONTENTS_GRATE, bullet.filter, &bullet.trace);
//
//		bullet.damage *= powf(inf->range_modifier, (bullet.trace.end - start).Length() / 500.f);
//
//		if (bullet.trace.fraction == 1.f) {
//			if (to_ent && hitgroup != -1) {
//				this->scale_damage(to_ent, inf, hitgroup, bullet.damage);
//
//				rt.damage = bullet.damage;
//				rt.hitgroup = hitgroup;
//				rt.end = bullet.trace.end;
//				rt.ent = to_ent;
//			}
//			else {
//				rt.damage = bullet.damage;
//				rt.hitgroup = -1;
//				rt.end = bullet.trace.end;
//				rt.ent = nullptr;
//			}
//		}
//
//		if (bullet.trace.hitGroup > 0 && bullet.trace.hitGroup <= 7) {
//			if (to_ent && bullet.trace.m_pEnt != to_ent ||
//				bullet.trace.m_pEnt->GetTeam() == from_ent->GetTeam()) {
//				rt.damage = -1;
//
//				return rt;
//			}
//
//			if (hitgroup != -1)
//				scale_damage(bullet.trace.m_pEnt, inf, hitgroup, bullet.damage);
//			else
//				scale_damage(bullet.trace.m_pEnt, inf, bullet.trace.hitGroup, bullet.damage);
//
//			rt.damage = bullet.damage;
//			rt.hitgroup = bullet.trace.hitGroup;
//			rt.end = bullet.trace.end;
//			rt.ent = bullet.trace.m_pEnt;
//
//			break;
//		}
//
//		if (!this->handle_bullet_penetration(inf, bullet))
//			break;
//
//		rt.did_penetrate_wall = true;
//	}
//
//	rt.walls = bullet.walls;
//	return rt;
//}
 // new



void c_autowall::scale_damage(CBaseEntity * ent, CSWeaponInfo * inf, int& hitgroup, float& damage) {
	auto armor_value = ent->GetArmor();
	auto is_armored = false;

	if (hitgroup == HITGROUP_HEAD)
		is_armored = ent->HasHelmet();
	else
		is_armored = armor_value > 0;

	switch (hitgroup) {
	case HITGROUP_HEAD:
		damage *= 4.f;
		break;
	case HITGROUP_STOMACH:
		damage *= 1.25f;
		break;
	case HITGROUP_LEFTLEG:
	case HITGROUP_RIGHTLEG:
		damage *= 0.75f;
		break;
	default:
		break;
	}

	if (is_armored) {
		float bonus_value = 1.f, armor_bonus_ratio = 0.5f, armor_ratio = inf->armor_ratio / 2.f;

		if (ent->HasHeavyArmor()) {
			armor_bonus_ratio = 0.33f;
			armor_ratio *= 0.5f;
			bonus_value = 0.33f;
		}

		auto new_damage = damage * armor_ratio;

		if (ent->HasHeavyArmor())
			new_damage *= 0.85f;

		if (((damage - (damage * armor_ratio)) * (bonus_value * armor_bonus_ratio)) > armor_value)
			new_damage = damage - (armor_value / armor_bonus_ratio);

		damage = new_damage;

		float v47 = 1.f, ArmorBonusRatio = 0.5f, ArmorRatio = inf->armor_ratio * 0.5f;

		auto NewDamage = damage * ArmorRatio;

		if (((damage - (damage * ArmorRatio)) * (v47 * ArmorBonusRatio)) > armor_value)
			NewDamage = damage - (damage / ArmorBonusRatio);

		damage = NewDamage;
	}
}

float GetHitgroupDamageMult(int iHitGroup)
{
	switch (iHitGroup)
	{
	case HITGROUP_HEAD:
		return 4.f;
	case HITGROUP_STOMACH:
		return 1.25f;
	case HITGROUP_LEFTLEG:
	case HITGROUP_RIGHTLEG:
		return 0.75f;
	}

	return 1.0f;
}

void ScaleDamage(int hitgroup, CBaseEntity* enemy, float weapon_armor_ratio, float& current_damage)
{
	current_damage *= GetHitgroupDamageMult(hitgroup);

	if (enemy->GetArmor > 0.0f && hitgroup < HITGROUP_LEFTLEG)
	{
		if (hitgroup == HITGROUP_HEAD && !enemy->HasHelmet())
			return;

		float armorscaled = (weapon_armor_ratio * 0.5f) * current_damage;
		if ((current_damage - armorscaled) * 0.5f > enemy->GetArmor())
			armorscaled = current_damage - (enemy->GetArmor() * 2.0f);
		current_damage = armorscaled;
	}
}

void TraceLine(Vector& vecAbsStart, Vector& vecAbsEnd, unsigned int mask, CBaseEntity* ignore, CTrace* ptr)
{
	CTraceFilter filter(ignore);
	Interfaces::Trace->TraceRay(Ray_t(vecAbsStart, vecAbsEnd), mask, &filter, ptr);
}


bool TraceToExitalt(Vector& end, CTrace& tr, Vector start, Vector vEnd, CTrace* trace)
{
	typedef bool(__fastcall * TraceToExitFn)(Vector&, CTrace&, float, float, float, float, float, float, CTrace*);
	static TraceToExitFn oTraceToExit = (TraceToExitFn)Utilities->Memory_PatternScan("client_panorama.dll", "55 8B EC 83 EC 30 F3 0F 10 75");

	if (!oTraceToExit)
		return false;

	return oTraceToExit(end, tr, start.x, start.y, start.z, vEnd.x, vEnd.y, vEnd.z, trace);
}


bool c_autowall::handle_bullet_penetration(CSWeaponInfo* wpn_data, FireBulletData& data, bool extracheck = false, Vector point = Vector(0, 0, 0), CBaseEntity* pEnt = nullptr)
{
	surfacedata_t* enter_surface_data = g_pSurfaceData->GetSurfaceData(data.enter_trace.surface.surfaceProps);
	int enter_material = enter_surface_data->game.material;
	float enter_surf_penetration_mod = enter_surface_data->game.flPenetrationModifier;
	data.trace_length += data.enter_trace.flFraction * data.trace_length_remaining;
	data.current_damage *= pow(wpn_data->range_modifier, (data.trace_length * 0.002));
	if ((data.trace_length > 3000.f) || (enter_surf_penetration_mod < 0.1f))
		data.penetrate_count = 0;
	if (data.penetrate_count <= 0)
		return false;
	Vector dummy;
	CTrace trace_exit;
	if (!TraceToExitalt(dummy, data.enter_trace, data.enter_trace.TraceRay, data.direction, &trace_exit))
		return false;
	surfacedata_t * exit_surface_data = g_pSurfaceData->GetSurfaceData(trace_exit.surface.surfaceProps);
	int exit_material = exit_surface_data->game.material;
	float exit_surf_penetration_mod = exit_surface_data->game.flPenetrationModifier;
	float final_damage_modifier = 0.16f;
	float combined_penetration_modifier = 0.0f;
	if (((data.enter_trace.contents & contents_grate) != 0) || (enter_material == 89) || (enter_material == 71))
	{
		combined_penetration_modifier = 3.0f;
		final_damage_modifier = 0.05f;
	}
	else
		combined_penetration_modifier = (enter_surf_penetration_mod + exit_surf_penetration_mod) * 0.5f;
	if (enter_material == exit_material)
	{
		if (exit_material == 87 || exit_material == 85)combined_penetration_modifier = 3.0f;
		else if (exit_material == 76)combined_penetration_modifier = 2.0f;
	}
	float v34 = fmaxf(0.f, 1.0f / combined_penetration_modifier);
	float v35 = (data.current_damage * final_damage_modifier) + v34 * 3.0f * fmaxf(0.0f, (3.0f / wpn_data->penetration) * 1.25f);
	float thickness = VectorLength(trace_exit.TraceRay - data.enter_trace.TraceRay);
	if (extracheck)
		if (!c_autowall::get().VectortoVectorVisible(trace_exit.TraceRay, point, pEnt))
			return false;
	thickness *= thickness;
	thickness *= v34;
	thickness /= 24.0f;
	float lost_damage = fmaxf(0.0f, v35 + thickness);
	if (lost_damage > data.current_damage)
		return false;
	if (lost_damage >= 0.0f)
		data.current_damage -= lost_damage;
	if (data.current_damage < 1.0f)
		return false;
	data.src = trace_exit.TraceRay; // .end #1 possible missunderstand by kert (xd)
	data.penetrate_count--;

	return true;
}


void c_autowall::clip_trace_to_player(const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask, ITraceFilter* filter, CTrace* tr) // sig is most likely out of date
{
	static DWORD dwAddress = Utilities->Memory_PatternScan("client_panorama.dll", "\x53\x8B\xDC\x83\xEC\x08\x83\xE4\xF0\x83\xC4\x04\x55\x8B\x6B\x04\x89\x6C\x24\x04\x8B\xEC\x81\xEC\x00\x00\x00\x00\x8B\x43\x10"); // (BYTE*)

	if (!dwAddress)
		return;

	_asm
	{
		MOV		EAX, filter
		LEA		ECX, tr
		PUSH	ECX
		PUSH	EAX
		PUSH	mask
		LEA		EDX, vecAbsEnd
		LEA		ECX, vecAbsStart
		CALL	dwAddress
		ADD		ESP, 0xC
	}
}

bool SimulateFireBullet(CBaseEntity* local, CBaseWeapon* weapon, FireBulletData& data)
{
	data.penetrate_count = 4;
	data.trace_length = 0.0f;
	auto wpn_data = weapon->get_full_info;// GetCSWpnData
	data.current_damage = (float)wpn_data->damage;
	while ((data.penetrate_count > 0) && (data.current_damage >= 1.0f))
	{
		data.trace_length_remaining = wpn_data->range - data.trace_length;
		Vector End_Point = data.src + data.direction * data.trace_length_remaining;
		TraceLine(data.src, End_Point, 0x4600400B, local, &data.enter_trace);
		c_autowall::clip_trace_to_player(data.src, End_Point * 40.f, 0x4600400B, &data.filter, &data.enter_trace);
		if (data.enter_trace.flFraction == 1.0f)
			break;
		if ((data.enter_trace.hitGroup <= 7) && (data.enter_trace.hitGroup > 0) && (local->GetTeam() != data.enter_trace.m_pEnt->GetTeam()))
		{
			data.trace_length += data.enter_trace.flFraction * data.trace_length_remaining;
			data.current_damage *= pow(wpn_data->range_modifier, data.trace_length * 0.002);
			ScaleDamage(data.enter_trace.hitGroup, data.enter_trace.m_pEnt, wpn_data->armor_ratio, data.current_damage);
			return true;
		}
		if (!handle_bullet_penetration(wpn_data, data))
			break;
	}
	return false;
}

float c_autowall::Damage(const Vector& point)
{
	auto data = FireBulletData(g::pLocalEntity->GetEyePosition(), g::pLocalEntity);

	Vector angles;
	angles = Utilities->Math_CalcAngle(data.src, point);
	Utilities->Math_AngleVectors(angles, &data.direction);
	&Vector::NormalizeAngles(data.direction);

	if (SimulateFireBullet(g::pLocalEntity, g::pLocalEntity->GetActiveWeapon(), data))
		return data.current_damage;

	return 0.f;
}

bool c_autowall::VectortoVectorVisible(Vector src, Vector point, CBaseEntity* pEnt)
{
	//mask_solid
	CTrace TraceInit;
	TraceInit.m_pEnt = NULL;
	CTraceFilter filter1(g::pLocalEntity);
	g_pTrace->TraceRay(Ray_t(src, point), MASK_SOLID, &filter1, &TraceInit);

	if (TraceInit.flFraction == 1.0f)
		return true;

	if (pEnt != nullptr && TraceInit.m_pEnt == pEnt)
		return true;

	return false;
}

bool c_autowall::CanHitFloatingPoint(const Vector& point, const Vector& source, CBaseEntity* pEnt) // ez
{
	if (!g::pLocalEntity)
		return false;

	FireBulletData data = FireBulletData(source, g::pLocalEntity);

	Vector angles = Utilities->Math_CalcAngle(data.src, point);
	g_Math.AngleVectors(angles, &data.direction);
	VectorNormalize(data.direction);

	CBaseWeapon* pWeapon = (CBaseWeapon*)g::pLocalEntity->GetActiveWeapon();

	if (!pWeapon)
		return false;

	data.penetrate_count = 1;
	data.trace_length = 0.0f;

	CSWeaponInfo* weaponData = pWeapon->get_full_info();

	if (!weaponData)
		return false;

	data.current_damage = (float)weaponData->damage;
	data.trace_length_remaining = weaponData->range - data.trace_length;
	Vector end = data.src + (data.direction * data.trace_length_remaining);
	TraceLine(data.src, end, MASK_SHOT | CONTENTS_HITBOX, G::LocalPlayer, &data.enter_trace);

	if (VectortoVectorVisible(data.src, point, pEnt) || HandleBulletPenetration(weaponData, data, true, point))
		return true;

	return false;
}


// end

//bool c_autowall::is_breakable(CBaseEntity * e) {
//	using func = bool(__fastcall*)(CBaseEntity*);
//	static auto fn = reinterpret_cast<func>(Utilities->Memory_PatternScan("client_panorama.dll", "55 8B EC 51 56 8B F1 85 F6 74 68 83 BE"));
//
//	if (!e || !e->GetIndex())
//		return false;
//
//	auto take_damage{ (char*)((uintptr_t)e + *(size_t*)((uintptr_t)fn + 38)) };
//	auto take_damage_backup{ *take_damage };
//
//	auto * cclass = Interfaces::Client->GetAllClasses();
//
//	if ((cclass->m_pNetworkName[1]) != 'F'
//		|| (cclass->m_pNetworkName[4]) != 'c'
//		|| (cclass->m_pNetworkName[5]) != 'B'
//		|| (cclass->m_pNetworkName[9]) != 'h')
//		* take_damage = 2;
//
//	bool breakable = fn(e);
//	*take_damage = take_damage_backup;
//
//	return breakable;
//}
//
//float c_autowall::get_point_damage(Vector point, CBaseEntity * e) {
//	return this->autowall(G::LocalPlayer->GetEyePosition(), point, G::LocalPlayer, e).damage;
//}




//float c_autowall::get_estimated_point_damage(Vector point) {
//	if (!G::LocalPlayer)
//		return -1.f;
//
//	fbdata bullet;
//	auto filter = CTraceFilter();
//	filter.pSkip1 = G::LocalPlayer;
//
//	bullet.filter = &filter;
//	bullet.start = G::LocalPlayer->GetEyePosition();
//	bullet.end = point;
//	bullet.pos = G::LocalPlayer->GetEyePosition();
//	Utilities->Math_AngleVectors(Utilities->Math_CalcAngle(bullet.start, point), bullet.dir);
//	bullet.trace.start = bullet.start;
//	bullet.trace.end = point;
//
//	auto wep = G::LocalPlayer->GetActiveWeapon();
//	if (!wep)
//		return -2.f;
//
//	bullet.walls = 1;
//	bullet.thickness = 0.f;
//
//	auto inf = wep->get_full_info();
//	if (!inf)
//		return -3.f;
//
//	bullet.damage = inf->damage;
//
//	Ray_t ray;
//	ray.Init(bullet.start, bullet.end);
//
//	Interfaces::Trace->TraceRay(ray, MASK_SHOT | CONTENTS_GRATE, &filter, &bullet.trace);
//
//	if (bullet.trace.fraction == 1.f)
//		return -4.f;
//
//	if (this->handle_bullet_penetration(inf, bullet))
//		return bullet.damage;
//
//	return -5.f;
//}