Skocz do zawartości
Cheaty do CS2 - CSH External VIP Project

Szukam jakiegoś dobrego resolvera

hollywoood
# CSH External VIP Project

Masz dosyć problemów z czynnikiem zaufania w CS2 lub notorycznymi banami?

Sprawdź CSH External VIP Project.


Więcej informacji  

Rekomendowane odpowiedzi

MrPejs Współtwórca treści

MrPejs Forumowa Wielkanoc 2024 Jedenaście lat służby Halloween 2023 Brązowa litera Dziesięć lat służby

Opublikowano
Opublikowano

Ten od pycache podobno daje rade.

 

Backtrack.h

 

 

#pragma once
 
struct CTickRecord;
 
struct CValidTick {
	explicit operator CTickRecord() const;
 
	explicit operator bool() const noexcept {
		return m_flSimulationTime > 0.f;
	}
 
	float m_flPitch = 0.f;
	float m_flYaw = 0.f;
	float m_flSimulationTime = 0.f;
	CBaseEntity* m_pEntity = nullptr;
};
 
struct CTickRecord {
	CTickRecord() {}
	CTickRecord(CBaseEntity* ent) {
		m_flLowerBodyYawTarget = ent->GetLowerBodyYawTarget();
		m_angEyeAngles = ent->GetEyeAngles();
		m_flCycle = ent->GetCycle();
		m_flSimulationTime = ent->GetSimulationTime();
		m_nSequence = ent->GetSequence();
		m_vecOrigin = ent->GetOrigin();
		m_vecVelocity = ent->GetVelocity();
		m_flPoseParameter = ent->GetPoseParameters();
		m_angAbsAngles = ent->GetAbsAngles();
		m_vecAbsOrigin = ent->GetAbsOrigin();
		tickcount = 0;
	}
 
	explicit operator bool() const noexcept {
		return m_flSimulationTime > 0.f;
	}
 
	bool operator>(const CTickRecord& others) {
		return (m_flSimulationTime > others.m_flSimulationTime);
	}
	bool operator>=(const CTickRecord& others) {
		return (m_flSimulationTime >= others.m_flSimulationTime);
	}
	bool operator<(const CTickRecord& others) {
		return (m_flSimulationTime < others.m_flSimulationTime);
	}
	bool operator<=(const CTickRecord& others) {
		return (m_flSimulationTime <= others.m_flSimulationTime);
	}
	bool operator==(const CTickRecord& others) {
		return (m_flSimulationTime == others.m_flSimulationTime);
	}
 
	float m_flLowerBodyYawTarget = 0.f;
	QAngle m_angEyeAngles = QAngle(0, 0, 0);
	float m_flCycle = 0.f;
	float m_flSimulationTime = 0.f;
	int m_nSequence = 0;
	Vector m_vecOrigin = Vector(0, 0, 0);
	Vector m_vecAbsOrigin = Vector(0, 0, 0);
	Vector m_vecVelocity = Vector(0, 0, 0);
	std::array<float, 24> m_flPoseParameter = {};
	QAngle m_angAbsAngles = QAngle(0, 0, 0);
	CValidTick validtick;
	int tickcount = 0;
};
 
inline CValidTick::operator CTickRecord() const{
	CTickRecord rec(m_pEntity);
	rec.m_angEyeAngles.x = this->m_flPitch;
	rec.m_angEyeAngles.y = this->m_flYaw;
	rec.m_flSimulationTime = this->m_flSimulationTime;
	return rec;
} 

 

 

 

Resolver.h

 

 

#pragma once
 
enum class ResolveMode : int {
	OFF = 0,
	FORCE,
	DELTA,
	STEADY,
	TICKMODULO,
	ALL
};
 
class CResolveInfo {
	friend class CResolver;
protected:
	std::deque<CTickRecord> m_sRecords;
	bool	m_bEnemyShot; //priority
	bool	m_bLowerBodyYawChanged;
	bool	m_bBacktrackThisTick;
};
 
#define Resolver CResolver::GetInstance()
 
class CResolver {
	friend class CLagcompensation;
	friend class CBacktracking;
 
	IMPLEMENT_SINGLETON(CResolver);
 
public:
	void StoreVars(CBaseEntity* Entity);
	void StoreVars(CBaseEntity* Entity, QAngle ang, float lby, float simtime, float tick);
 
	void Resolve(CBaseEntity* ent);
 
	bool& LowerBodyYawChanged(CBaseEntity* ent);
	bool& BacktrackThisTick(CBaseEntity* ent);
	
private:
	CTickRecord GetShotRecord(CBaseEntity*);
	bool HasStaticRealAngle(int index, float tolerance = 15.f);
	bool HasStaticRealAngle(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	bool HasStaticYawDifference(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	bool HasSteadyDifference(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	int GetDifferentDeltas(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	int GetDifferentLBYs(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	float GetLBYByComparingTicks(const std::deque<CTickRecord>& l);
	float GetDeltaByComparingTicks(const std::deque<CTickRecord>& l);
	bool DeltaKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance = 15.f);
	bool LBYKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance = 15.f);
	bool IsEntityMoving(CBaseEntity* ent);
 
private:
	std::array<CResolveInfo, 32> m_arrInfos;
};
 
 
 
const inline float GetDelta(float a, float  {
	return abs(M::ClampYaw(a - );
}
 
const inline float LBYDelta(const CTickRecord& v) {
	return v.m_angEyeAngles.y - v.m_flLowerBodyYawTarget;
}
 
const inline bool IsDifferent(float a, float b, float tolerance = 10.f) {
	return (GetDelta(a,  > tolerance);
} 

 

 

 

Resolver.cpp

 

 

include "Refund.h"
 
void CResolver::Resolve(CBaseEntity* ent) {
	auto cur = m_arrInfos.at(ent->GetIndex()).m_sRecords;
	if (cur.size() < 2)
		return;
	if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::OFF))
		return;
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::FORCE)) {
		ent->m_angEyeAngles().y = cur.front().m_flLowerBodyYawTarget;
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::DELTA)) {
		ent->m_angEyeAngles().y = LBYDelta(cur.front());
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::STEADY)) {
		if (cur.size() <= 1)
			return;
		float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
		float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
		float ntickdif = static_cast<float>(G::UserCmd->tick_count - cur.front().tickcount);
		ent->m_angEyeAngles().y = (lbydif / tickdif) * ntickdif;
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::TICKMODULO)) {
		ent->m_angEyeAngles().y = ent->GetEyeAngles().y - GetDeltaByComparingTicks(cur);
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::ALL)) {
		if (Backtracking->CanBacktrackShot(GetShotRecord(ent)))
			m_arrInfos.at(ent->entindex()).m_sRecords.erase(std::remove(m_arrInfos.at(ent->entindex()).m_sRecords.begin(), m_arrInfos.at(ent->entindex()).m_sRecords.end(), GetShotRecord(ent)), m_arrInfos.at(ent->entindex()).m_sRecords.end());
		else if (IsEntityMoving(ent))
			ent->m_angEyeAngles().y = ent->GetLowerBodyYawTarget();
		else if (HasStaticRealAngle(cur))
			ent->m_angEyeAngles().y = (cur.front().m_flLowerBodyYawTarget) + (M::RandomFloat(0.f, 1.f) > 0.5f ? 10 : -10);
		else if (HasStaticYawDifference(cur))
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y - (cur.front().m_angEyeAngles.y - cur.front().m_flLowerBodyYawTarget);
		else if (HasSteadyDifference(cur)) {
			float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
			float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
			float ntickdif = static_cast<float>(G::UserCmd->tick_count - cur.front().tickcount);
			ent->m_angEyeAngles().y = (lbydif / tickdif) * ntickdif;
		}
		else if (DeltaKeepsChanging(cur))
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y - GetDeltaByComparingTicks(cur);
		else if (LBYKeepsChanging(cur))
			ent->m_angEyeAngles().y = GetLBYByComparingTicks(cur);
		else
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y + 180;
	}
}
 
 
bool& CResolver::LowerBodyYawChanged(CBaseEntity* ent) {
	return m_arrInfos.at(ent->GetIndex()).m_bLowerBodyYawChanged;
}
 
void CResolver::StoreVars(CBaseEntity* ent) {
	if (m_arrInfos.at(ent->GetIndex()).m_sRecords.size() >= static_cast<size_t>(Config->GetValue<int>("Resolver", "Ticks")))
		m_arrInfos.at(ent->GetIndex()).m_sRecords.pop_back();
	m_arrInfos.at(ent->GetIndex()).m_sRecords.push_front(CTickRecord(ent));
}
 
void CResolver::StoreVars(CBaseEntity* ent, QAngle ang, float lby, float simtime, float tick) {
	if (m_arrInfos.at(ent->GetIndex()).m_sRecords.size() >= static_cast<size_t>(Config->GetValue<int>("Resolver", "Ticks")))
		m_arrInfos.at(ent->GetIndex()).m_sRecords.pop_back();
	m_arrInfos.at(ent->GetIndex()).m_sRecords.push_front(CTickRecord(ent));
}
 
bool& CResolver::BacktrackThisTick(CBaseEntity* ent) {
	return m_arrInfos.at(ent->GetIndex()).m_bBacktrackThisTick;
}
 
CTickRecord CResolver::GetShotRecord(CBaseEntity* ent) {
	for (auto cur : m_arrInfos[ent->entindex()].m_sRecords) {
		if (cur.validtick)
			return CTickRecord(cur);
	}
	return CTickRecord();
}
 
bool CResolver::HasStaticRealAngle(const std::deque<CTickRecord>& l, float tolerance) {
	auto minmax = std::minmax_element(std::begin(l), std::end(l), [](const CTickRecord& t1, const CTickRecord& t2) { return t1.m_flLowerBodyYawTarget < t2.m_flLowerBodyYawTarget; });
	return (fabs(minmax.first->m_flLowerBodyYawTarget - minmax.second->m_flLowerBodyYawTarget) <= tolerance);
}
 
bool CResolver::HasStaticRealAngle(int index, float tolerance) {
	return HasStaticRealAngle(m_arrInfos[index].m_sRecords, tolerance);
}
 
bool CResolver::HasStaticYawDifference(const std::deque<CTickRecord>& l, float tolerance) {
	for (auto i = l.begin(); i < l.end() - 1;) {
		if (GetDelta(LBYDelta(*i), LBYDelta(*++i)) > tolerance)
			return false;
	}
	return true;
}
 
bool CResolver::HasSteadyDifference(const std::deque<CTickRecord>& l, float tolerance) {
	size_t misses = 0;
	for (size_t i = 0; i < l.size() - 1; i++) {
		float tickdif = static_cast<float>(l.at(i).m_flSimulationTime - l.at(i + 1).tickcount);
		float lbydif = GetDelta(l.at(i).m_flLowerBodyYawTarget, l.at(i + 1).m_flLowerBodyYawTarget);
		float ntickdif = static_cast<float>(G::UserCmd->tick_count - l.at(i).tickcount);
		if (((lbydif / tickdif) * ntickdif) > tolerance) misses++;
	}
	return (misses <= (l.size() / 3));
}
 
int CResolver::GetDifferentDeltas(const std::deque<CTickRecord>& l, float tolerance) {
	std::vector<float> vec;
	for (auto var : l) {
		float curdelta = LBYDelta(var);
		bool add = true;
		for (auto fl : vec) {
			if (!IsDifferent(curdelta, fl, tolerance))
				add = false;
		}
		if (add)
			vec.push_back(curdelta);
	}
	return vec.size();
}
 
int CResolver::GetDifferentLBYs(const std::deque<CTickRecord>& l, float tolerance) {
	std::vector<float> vec;
	for (auto var : l) {
		float curyaw = var.m_flLowerBodyYawTarget;
		bool add = true;
		for (auto fl : vec) {
			if (!IsDifferent(curyaw, fl, tolerance))
				add = false;
		}
		if (add)
			vec.push_back(curyaw);
	}
	return vec.size();
}
 
float CResolver::GetLBYByComparingTicks(const std::deque<CTickRecord>& l) {
	int modulo = Config->GetValue<int>("Resolver", "Modulo");
	int difangles = GetDifferentLBYs(l);
	int inc = modulo * difangles;
	for (auto var : l) {
		for (int lasttick = var.tickcount; lasttick < G::UserCmd->tick_count; lasttick += inc) {
			if (lasttick == G::UserCmd->tick_count)
				return var.m_flLowerBodyYawTarget;
		}
	}
	return 0.f;
}
 
float CResolver::GetDeltaByComparingTicks(const std::deque<CTickRecord>& l) {
	int modulo = Config->GetValue<int>("Resolver", "Modulo");
	int difangles = GetDifferentDeltas(l);
	int inc = modulo * difangles;
	for (auto var : l) {
		for (int lasttick = var.tickcount; lasttick < G::UserCmd->tick_count; lasttick += inc) {
			if (lasttick == G::UserCmd->tick_count)
				return LBYDelta(var);
		}
	}
	return 0.f;
}
 
bool CResolver::DeltaKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance) {
	return (GetDifferentDeltas(cur) > (int) cur.size() / 2);
}
 
bool CResolver::LBYKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance) {
	return (GetDifferentLBYs(cur, tolerance) > (int)cur.size() / 2);
}
 
bool CResolver::IsEntityMoving(CBaseEntity* ent) {
	return (ent->GetVelocity().Length2D() > 0.1f && ent->GetFlags() & FL_ONGROUND);
} 

 

 

1

3194a766ee8487b51965c9491714eba73c04b1f7

Contact:

https://steamcommunity.com/profiles/76561198872411924/

https://steamcommunity.com/id/mrpejs

Odnośnik do komentarza
hollywoood Początkujący

hollywoood Rok służby Dwa lata służby Trzy lata służby Cztery lata służby

Opublikowano
  • Autor
Opublikowano

Ten od pycache podobno daje rade.

 

Backtrack.h

 

 

#pragma once
 
struct CTickRecord;
 
struct CValidTick {
	explicit operator CTickRecord() const;
 
	explicit operator bool() const noexcept {
		return m_flSimulationTime > 0.f;
	}
 
	float m_flPitch = 0.f;
	float m_flYaw = 0.f;
	float m_flSimulationTime = 0.f;
	CBaseEntity* m_pEntity = nullptr;
};
 
struct CTickRecord {
	CTickRecord() {}
	CTickRecord(CBaseEntity* ent) {
		m_flLowerBodyYawTarget = ent->GetLowerBodyYawTarget();
		m_angEyeAngles = ent->GetEyeAngles();
		m_flCycle = ent->GetCycle();
		m_flSimulationTime = ent->GetSimulationTime();
		m_nSequence = ent->GetSequence();
		m_vecOrigin = ent->GetOrigin();
		m_vecVelocity = ent->GetVelocity();
		m_flPoseParameter = ent->GetPoseParameters();
		m_angAbsAngles = ent->GetAbsAngles();
		m_vecAbsOrigin = ent->GetAbsOrigin();
		tickcount = 0;
	}
 
	explicit operator bool() const noexcept {
		return m_flSimulationTime > 0.f;
	}
 
	bool operator>(const CTickRecord& others) {
		return (m_flSimulationTime > others.m_flSimulationTime);
	}
	bool operator>=(const CTickRecord& others) {
		return (m_flSimulationTime >= others.m_flSimulationTime);
	}
	bool operator<(const CTickRecord& others) {
		return (m_flSimulationTime < others.m_flSimulationTime);
	}
	bool operator<=(const CTickRecord& others) {
		return (m_flSimulationTime <= others.m_flSimulationTime);
	}
	bool operator==(const CTickRecord& others) {
		return (m_flSimulationTime == others.m_flSimulationTime);
	}
 
	float m_flLowerBodyYawTarget = 0.f;
	QAngle m_angEyeAngles = QAngle(0, 0, 0);
	float m_flCycle = 0.f;
	float m_flSimulationTime = 0.f;
	int m_nSequence = 0;
	Vector m_vecOrigin = Vector(0, 0, 0);
	Vector m_vecAbsOrigin = Vector(0, 0, 0);
	Vector m_vecVelocity = Vector(0, 0, 0);
	std::array<float, 24> m_flPoseParameter = {};
	QAngle m_angAbsAngles = QAngle(0, 0, 0);
	CValidTick validtick;
	int tickcount = 0;
};
 
inline CValidTick::operator CTickRecord() const{
	CTickRecord rec(m_pEntity);
	rec.m_angEyeAngles.x = this->m_flPitch;
	rec.m_angEyeAngles.y = this->m_flYaw;
	rec.m_flSimulationTime = this->m_flSimulationTime;
	return rec;
} 

 

 

 

Resolver.h

 

 

#pragma once
 
enum class ResolveMode : int {
	OFF = 0,
	FORCE,
	DELTA,
	STEADY,
	TICKMODULO,
	ALL
};
 
class CResolveInfo {
	friend class CResolver;
protected:
	std::deque<CTickRecord> m_sRecords;
	bool	m_bEnemyShot; //priority
	bool	m_bLowerBodyYawChanged;
	bool	m_bBacktrackThisTick;
};
 
#define Resolver CResolver::GetInstance()
 
class CResolver {
	friend class CLagcompensation;
	friend class CBacktracking;
 
	IMPLEMENT_SINGLETON(CResolver);
 
public:
	void StoreVars(CBaseEntity* Entity);
	void StoreVars(CBaseEntity* Entity, QAngle ang, float lby, float simtime, float tick);
 
	void Resolve(CBaseEntity* ent);
 
	bool& LowerBodyYawChanged(CBaseEntity* ent);
	bool& BacktrackThisTick(CBaseEntity* ent);
	
private:
	CTickRecord GetShotRecord(CBaseEntity*);
	bool HasStaticRealAngle(int index, float tolerance = 15.f);
	bool HasStaticRealAngle(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	bool HasStaticYawDifference(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	bool HasSteadyDifference(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	int GetDifferentDeltas(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	int GetDifferentLBYs(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	float GetLBYByComparingTicks(const std::deque<CTickRecord>& l);
	float GetDeltaByComparingTicks(const std::deque<CTickRecord>& l);
	bool DeltaKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance = 15.f);
	bool LBYKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance = 15.f);
	bool IsEntityMoving(CBaseEntity* ent);
 
private:
	std::array<CResolveInfo, 32> m_arrInfos;
};
 
 
 
const inline float GetDelta(float a, float  {
	return abs(M::ClampYaw(a - );
}
 
const inline float LBYDelta(const CTickRecord& v) {
	return v.m_angEyeAngles.y - v.m_flLowerBodyYawTarget;
}
 
const inline bool IsDifferent(float a, float b, float tolerance = 10.f) {
	return (GetDelta(a,  > tolerance);
} 

 

 

 

Resolver.cpp

 

 

include "Refund.h"
 
void CResolver::Resolve(CBaseEntity* ent) {
	auto cur = m_arrInfos.at(ent->GetIndex()).m_sRecords;
	if (cur.size() < 2)
		return;
	if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::OFF))
		return;
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::FORCE)) {
		ent->m_angEyeAngles().y = cur.front().m_flLowerBodyYawTarget;
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::DELTA)) {
		ent->m_angEyeAngles().y = LBYDelta(cur.front());
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::STEADY)) {
		if (cur.size() <= 1)
			return;
		float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
		float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
		float ntickdif = static_cast<float>(G::UserCmd->tick_count - cur.front().tickcount);
		ent->m_angEyeAngles().y = (lbydif / tickdif) * ntickdif;
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::TICKMODULO)) {
		ent->m_angEyeAngles().y = ent->GetEyeAngles().y - GetDeltaByComparingTicks(cur);
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::ALL)) {
		if (Backtracking->CanBacktrackShot(GetShotRecord(ent)))
			m_arrInfos.at(ent->entindex()).m_sRecords.erase(std::remove(m_arrInfos.at(ent->entindex()).m_sRecords.begin(), m_arrInfos.at(ent->entindex()).m_sRecords.end(), GetShotRecord(ent)), m_arrInfos.at(ent->entindex()).m_sRecords.end());
		else if (IsEntityMoving(ent))
			ent->m_angEyeAngles().y = ent->GetLowerBodyYawTarget();
		else if (HasStaticRealAngle(cur))
			ent->m_angEyeAngles().y = (cur.front().m_flLowerBodyYawTarget) + (M::RandomFloat(0.f, 1.f) > 0.5f ? 10 : -10);
		else if (HasStaticYawDifference(cur))
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y - (cur.front().m_angEyeAngles.y - cur.front().m_flLowerBodyYawTarget);
		else if (HasSteadyDifference(cur)) {
			float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
			float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
			float ntickdif = static_cast<float>(G::UserCmd->tick_count - cur.front().tickcount);
			ent->m_angEyeAngles().y = (lbydif / tickdif) * ntickdif;
		}
		else if (DeltaKeepsChanging(cur))
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y - GetDeltaByComparingTicks(cur);
		else if (LBYKeepsChanging(cur))
			ent->m_angEyeAngles().y = GetLBYByComparingTicks(cur);
		else
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y + 180;
	}
}
 
 
bool& CResolver::LowerBodyYawChanged(CBaseEntity* ent) {
	return m_arrInfos.at(ent->GetIndex()).m_bLowerBodyYawChanged;
}
 
void CResolver::StoreVars(CBaseEntity* ent) {
	if (m_arrInfos.at(ent->GetIndex()).m_sRecords.size() >= static_cast<size_t>(Config->GetValue<int>("Resolver", "Ticks")))
		m_arrInfos.at(ent->GetIndex()).m_sRecords.pop_back();
	m_arrInfos.at(ent->GetIndex()).m_sRecords.push_front(CTickRecord(ent));
}
 
void CResolver::StoreVars(CBaseEntity* ent, QAngle ang, float lby, float simtime, float tick) {
	if (m_arrInfos.at(ent->GetIndex()).m_sRecords.size() >= static_cast<size_t>(Config->GetValue<int>("Resolver", "Ticks")))
		m_arrInfos.at(ent->GetIndex()).m_sRecords.pop_back();
	m_arrInfos.at(ent->GetIndex()).m_sRecords.push_front(CTickRecord(ent));
}
 
bool& CResolver::BacktrackThisTick(CBaseEntity* ent) {
	return m_arrInfos.at(ent->GetIndex()).m_bBacktrackThisTick;
}
 
CTickRecord CResolver::GetShotRecord(CBaseEntity* ent) {
	for (auto cur : m_arrInfos[ent->entindex()].m_sRecords) {
		if (cur.validtick)
			return CTickRecord(cur);
	}
	return CTickRecord();
}
 
bool CResolver::HasStaticRealAngle(const std::deque<CTickRecord>& l, float tolerance) {
	auto minmax = std::minmax_element(std::begin(l), std::end(l), [](const CTickRecord& t1, const CTickRecord& t2) { return t1.m_flLowerBodyYawTarget < t2.m_flLowerBodyYawTarget; });
	return (fabs(minmax.first->m_flLowerBodyYawTarget - minmax.second->m_flLowerBodyYawTarget) <= tolerance);
}
 
bool CResolver::HasStaticRealAngle(int index, float tolerance) {
	return HasStaticRealAngle(m_arrInfos[index].m_sRecords, tolerance);
}
 
bool CResolver::HasStaticYawDifference(const std::deque<CTickRecord>& l, float tolerance) {
	for (auto i = l.begin(); i < l.end() - 1;) {
		if (GetDelta(LBYDelta(*i), LBYDelta(*++i)) > tolerance)
			return false;
	}
	return true;
}
 
bool CResolver::HasSteadyDifference(const std::deque<CTickRecord>& l, float tolerance) {
	size_t misses = 0;
	for (size_t i = 0; i < l.size() - 1; i++) {
		float tickdif = static_cast<float>(l.at(i).m_flSimulationTime - l.at(i + 1).tickcount);
		float lbydif = GetDelta(l.at(i).m_flLowerBodyYawTarget, l.at(i + 1).m_flLowerBodyYawTarget);
		float ntickdif = static_cast<float>(G::UserCmd->tick_count - l.at(i).tickcount);
		if (((lbydif / tickdif) * ntickdif) > tolerance) misses++;
	}
	return (misses <= (l.size() / 3));
}
 
int CResolver::GetDifferentDeltas(const std::deque<CTickRecord>& l, float tolerance) {
	std::vector<float> vec;
	for (auto var : l) {
		float curdelta = LBYDelta(var);
		bool add = true;
		for (auto fl : vec) {
			if (!IsDifferent(curdelta, fl, tolerance))
				add = false;
		}
		if (add)
			vec.push_back(curdelta);
	}
	return vec.size();
}
 
int CResolver::GetDifferentLBYs(const std::deque<CTickRecord>& l, float tolerance) {
	std::vector<float> vec;
	for (auto var : l) {
		float curyaw = var.m_flLowerBodyYawTarget;
		bool add = true;
		for (auto fl : vec) {
			if (!IsDifferent(curyaw, fl, tolerance))
				add = false;
		}
		if (add)
			vec.push_back(curyaw);
	}
	return vec.size();
}
 
float CResolver::GetLBYByComparingTicks(const std::deque<CTickRecord>& l) {
	int modulo = Config->GetValue<int>("Resolver", "Modulo");
	int difangles = GetDifferentLBYs(l);
	int inc = modulo * difangles;
	for (auto var : l) {
		for (int lasttick = var.tickcount; lasttick < G::UserCmd->tick_count; lasttick += inc) {
			if (lasttick == G::UserCmd->tick_count)
				return var.m_flLowerBodyYawTarget;
		}
	}
	return 0.f;
}
 
float CResolver::GetDeltaByComparingTicks(const std::deque<CTickRecord>& l) {
	int modulo = Config->GetValue<int>("Resolver", "Modulo");
	int difangles = GetDifferentDeltas(l);
	int inc = modulo * difangles;
	for (auto var : l) {
		for (int lasttick = var.tickcount; lasttick < G::UserCmd->tick_count; lasttick += inc) {
			if (lasttick == G::UserCmd->tick_count)
				return LBYDelta(var);
		}
	}
	return 0.f;
}
 
bool CResolver::DeltaKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance) {
	return (GetDifferentDeltas(cur) > (int) cur.size() / 2);
}
 
bool CResolver::LBYKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance) {
	return (GetDifferentLBYs(cur, tolerance) > (int)cur.size() / 2);
}
 
bool CResolver::IsEntityMoving(CBaseEntity* ent) {
	return (ent->GetVelocity().Length2D() > 0.1f && ent->GetFlags() & FL_ONGROUND);
} 

 

 

dzięki jutro ztestuje :P

Odnośnik do komentarza
Gość
Ten temat został zamknięty. Brak możliwości dodania odpowiedzi.
Tematy

  Tagi

 Społeczność
Zapoznaj się
 Pomoc
×
×
  • Dodaj nową pozycję...

Powiadomienie o plikach cookie

Umieściliśmy na Twoim urządzeniu pliki cookie, aby pomóc Ci usprawnić przeglądanie strony. Możesz dostosować ustawienia plików cookie, w przeciwnym wypadku zakładamy, że wyrażasz na to zgodę. Regulamin. Polityka prywatności