Resolver.h

#pragma once

namespace sdk
{
	class CUserCmd;
	class CBaseEntity;
	class CBaseWeapon;
}

struct Info
{
	Info() {}

	SDK::CAnimationLayer backup_layer, prev_layer;
	Vector last_lby, inverse, inverse_right, inverse_left, lby, back, left, right, backtrack;
	float stored_simtime, last_move_time, pre_anim_lby;
	int last_ammo;
	bool breaking_lby, reset_state, could_be_faking;
	std::vector<float> unresolved_yaw, lby_deltas;

	bool lby_changed;
	bool could_be_slowmo;
	bool is_moving;
	bool is_dormant;
	bool is_last_moving_lby_valid;
	bool is_standing;
	bool is_fakewalking;
	bool is_jumping;
	bool is_crouching;
	bool lby_updated;
	bool using_fake_angles;
	float last_moving_lby;
	float stored_lby;
	float next_lby_update_time;
	float can_predict;
	int stored_missed;
};


class CResolver
{
public:
	Info player_info[65];
	void record(SDK::CBaseEntity * entity, float new_yaw);
	bool AntiFreestanding(SDK::CBaseEntity * entity, float & yaw);
	int GetResolveTypeIndex(unsigned short resolve_type);
	std::string TranslateResolveRecord(unsigned short resolve_type);
	CColor GetResolveColor(unsigned short resolve_type);
	void ResolveYawBruteforce(SDK::CBaseEntity * entity);
	bool breaking_lby(SDK::CBaseEntity * entity);
	float ResolvePitch(SDK::CBaseEntity * pPlayer, float org_pitch);
	void resolve(SDK::CBaseEntity* entity);
	bool playerStoppedMoving(SDK::CBaseEntity * entity);
	void resolve2(SDK::CBaseEntity* entity);
	struct ResolverData
	{
		//ints
		int right_damage = 0, left_damage = 0;
		int stored_missed;
		int missed;
		int shotaimangles;
		//ints

		//floats
		float lastlbystand;
		float right_fraction = 0.f, left_fraction = 0.f;
		float last_moving_lby;
		float stored_lby;
		float next_lby_update;
		float lby1, nextlbyup;
		float lastmovinglby;
		float flick;
		float lastlby;
		//floats

		//bools
		bool is_moving;
		bool is_jumping;
		bool is_crouching;
		bool using_fake_angles;
		bool bfakeangle, bfakewalk, playerhurtcalled, weaponfirecalled;
		bool lbywasupdated;
		//bools

		//vectors
		SDK::CAnimationLayer anim_layers[15];
		//vectors


	} pResolverData[64];


	void ProcessSnapShots();

	bool IsFakewalking2(SDK::CBaseEntity * player);


public:
	/// resolve types, they're "flags" so to speak since a player can have more than 1 resolve type at once
	/// if angles overlap
	static const unsigned int RESOLVE_TYPE_NUM = 8;
	static const unsigned short RESOLVE_TYPE_OVERRIDE = 0b00000001,
		RESOLVE_TYPE_NO_FAKE = 0b00000010,
		RESOLVE_TYPE_LBY = 0b00000100,
		RESOLVE_TYPE_LBY_UPDATE = 0b00001000,
		RESOLVE_TYPE_PREDICTED_LBY_UPDATE = 0b00010000,
		RESOLVE_TYPE_LAST_MOVING_LBY = 0b00100000,
		RESOLVE_TYPE_NOT_BREAKING_LBY = 0b01000000,
		RESOLVE_TYPE_BRUTEFORCE = 0b10000000,
		RESOLVE_TYPE_LAST_MOVING_LBY_DELTA = 0b100000000,
		RESOLVE_TYPE_ANTI_FREESTANDING = 0b1000000000;

public:
	/// a struct holding info the resolver needs, updated every frame for every player
	class PlayerResolveRecord
	{
	public:
		PlayerResolveRecord()
		{
			resolve_type = 0;
			shots_missed_moving_lby = 0;
			shots_missed_moving_lby_delta = 0;

			last_balance_adjust_trigger_time = 0.f;
			last_moving_lby_delta = 0.f;
			last_time_moving = 0.f;
			last_time_down_pitch = 0.f;
			next_predicted_lby_update = 0.f;

			has_fake = false;
			is_dormant = false, is_last_moving_lby_delta_valid = false;
			is_last_moving_lby_valid = false, is_fakewalking = false;
			is_balance_adjust_triggered = false, is_balance_adjust_playing = false;
			did_lby_flick = false, did_predicted_lby_flick = false;

			for (int i = 0; i < RESOLVE_TYPE_NUM; i++)
			{
				shots_hit[i] = 0;
				shots_fired[i] = 0;
			}
		}

	public:
		struct AntiFreestandingRecord
		{
			int right_damage = 0, left_damage = 0;
			float right_fraction = 0.f, left_fraction = 0.f;
		};

	public:
		SDK::CAnimationLayer anim_layers[15];
		AntiFreestandingRecord anti_freestanding_record;

		Vector resolved_angles, networked_angles;
		Vector velocity, origin;

		int shots_hit[RESOLVE_TYPE_NUM], shots_fired[RESOLVE_TYPE_NUM];
		int shots_missed_moving_lby, shots_missed_moving_lby_delta;
		unsigned short resolve_type;

		float lower_body_yaw;
		float last_moving_lby;
		float last_moving_lby_delta;
		float last_balance_adjust_trigger_time;
		float last_time_moving;
		float last_time_down_pitch;
		float next_predicted_lby_update;

		bool is_dormant;
		bool last_lby_update;
		bool is_last_moving_lby_valid;
		bool is_fakewalking;
		bool is_last_moving_lby_delta_valid;
		bool is_balance_adjust_triggered, is_balance_adjust_playing;
		bool did_lby_flick, did_predicted_lby_flick;
		bool has_fake;
	};
	struct STickRecord {

		bool operator==(STickRecord &other) {
			return other.m_flSimulationTime == m_flSimulationTime;
		}

		float m_flVelocity = 0.f;
		Vector m_vecVelocity = Vector(0, 0, 0);
		float m_flSimulationTime = 0.f;
		float m_flLowerBodyYawTarget = 0.f;
		//std::array<float, 24> m_flPoseParameter = {};
		float m_flCurTime = 0.f;
		int m_nFlags = 0;

		int m_iLayerCount = 0;
		SDK::CAnimationLayer animationLayer[15];
	};
	struct SResolveInfo
	{
		std::deque<STickRecord> arr_tickRecords;

		STickRecord curTickRecord;
		STickRecord prevtickrec;
		float_t m_flLowerBodyYawTarget;

		float m_flLastLbyTime = 0.f;

		float_t m_flLbyDelta;

		int32_t m_nCorrectedFakewalkIdxs;

		float_t m_flStandingTime;
		float_t m_flMovingLBY;
		bool m_bIsMoving;

		QAngle m_angDirectionFirstMoving = QAngle(0, 0, 0);
	};
	struct ResolveInfo
	{
		ResolveInfo()
		{
			m_bActive = false;

			m_flVelocity = 0.f;
			m_vecVelocity = Vector(0, 0, 0);
			m_angEyeAngles = QAngle(0, 0, 0);
			m_flSimulationTime = 0.f;
			m_flLowerBodyYawTarget = 0.f;

			m_angDirectionFirstMoving = QAngle(0, 0, 0);
			m_nCorrectedFakewalkIdx = 0;
		}

		void SaveRecord(SDK::CBaseEntity *player)
		{
			m_iLayerCount = player->GetNumAnimOverlays();
			for (int i = 0; i < m_iLayerCount; i++)
				animationLayer[i] = player->GetAnimOverlays()[i];
		}

		bool operator==(const ResolveInfo &other)
		{
			return other.m_flSimulationTime == m_flSimulationTime;
		}

		bool m_bActive;

		float_t m_flVelocity;
		Vector m_vecVelocity;
		QAngle m_angEyeAngles;
		float_t m_flSimulationTime;
		float_t m_flLowerBodyYawTarget;

		int32_t m_iLayerCount = 0;
		SDK::CAnimationLayer animationLayer[15];

		QAngle m_angDirectionFirstMoving;
		int32_t m_nCorrectedFakewalkIdx;

		int32_t m_nShotsMissed = 0;
	};
	/// a snapshot holding info about the moment you shot, used to count shots missed / hit
	struct ShotSnapshot
	{
		SDK::CBaseEntity* entity; /// person we shot at
		PlayerResolveRecord resolve_record; /// their resolve record when we shot

		float time; /// time when snapshot was created
		float first_processed_time; /// time when the shot was first processed
		bool was_shot_processed;
		int hitgroup_hit;
	};

private:
	PlayerResolveRecord player_resolve_records[64];
	std::vector<ShotSnapshot> shot_snapshots;
	std::vector<Vector> last_eye_positions;

public:
	PlayerResolveRecord & GetPlayerResolveInfo(SDK::CBaseEntity* entity)
	{
		return player_resolve_records[entity->GetIndex()];
	}

	void Nospread(SDK::CBaseEntity * entity);

	void UpdateResolveRecord(SDK::CBaseEntity * entity);

	//	std::string TranslateResolveRecord(unsigned short resolve_type);
	//	CColor GetResolveColor(unsigned short resolve_type);
	//int GetShotsMissed(SDK::CBaseEntity* entity, unsigned short resolve_type);

	bool IsResolved(const unsigned short& resolve_type)
	{
		if (resolve_type & RESOLVE_TYPE_NO_FAKE ||
			resolve_type & RESOLVE_TYPE_LBY_UPDATE ||
			resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE)
			return true;

		return false;
	}

	bool IsFakewalking(SDK::CBaseEntity* entity)
	{
		return player_resolve_records[entity->GetIndex()].is_fakewalking;
	}

	bool IsMovingOnGround(SDK::CBaseEntity* entity)
	{
		return player_resolve_records[entity->GetIndex()].velocity.Length2D() > 0.5f && entity->GetFlags() & FL_ONGROUND;
	}


	/// pushback a record onto the shot snapshot queue


	//void EventCallback(SDK::IGameEventManager game_event);

private:
	//	void ProcessSnapShots();


};

extern CResolver* resolver;