#pragma once
#include "..\..\includes.hpp"
#include "..\..\sdk\structs.hpp"
enum
{
MAIN,
NONE,
FIRST,
SECOND
};
enum resolver_type
{
ORIGINAL,
BRUTEFORCE,
LBY,
TRACE,
DIRECTIONAL
};
enum ADVANCED_ACTIVITY : int
{
ACTIVITY_NONE = 0,
ACTIVITY_JUMP,
ACTIVITY_LAND
};
enum resolver_side
{
RESOLVER_ORIGINAL,
RESOLVER_ZERO,
RESOLVER_FIRST,
RESOLVER_SECOND,
RESOLVER_LOW_FIRST,
RESOLVER_LOW_SECOND
};
enum ROTATE_MODE
{
ROTATE_SERVER,
ROTATE_LEFT,
ROTATE_CENTER,
ROTATE_RIGHT,
ROTATE_LOW_LEFT,
ROTATE_LOW_RIGHT
};
enum Effects_t : int
{
EF_BONEMERGE = 0x001,
EF_BRIGHTLIGHT = 0x002,
EF_DIMLIGHT = 0x004,
EF_NOINTERP = 0x008,
EF_NOSHADOW = 0x010,
EF_NODRAW = 0x020,
EF_NORECEIVESHADOW = 0x040,
EF_BONEMERGE_FASTCULL = 0x080,
EF_ITEM_BLINK = 0x100,
EF_PARENT_ANIMATES = 0x200,
EF_MAX_BITS = 10
};
enum AnimationLayer_t
{
ANIMATION_LAYER_AIMMATRIX = 0,
ANIMATION_LAYER_WEAPON_ACTION,
ANIMATION_LAYER_WEAPON_ACTION_RECROUCH,
ANIMATION_LAYER_ADJUST,
ANIMATION_LAYER_MOVEMENT_JUMP_OR_FALL,
ANIMATION_LAYER_MOVEMENT_LAND_OR_CLIMB,
ANIMATION_LAYER_MOVEMENT_MOVE,
ANIMATION_LAYER_MOVEMENT_STRAFECHANGE,
ANIMATION_LAYER_WHOLE_BODY,
ANIMATION_LAYER_FLASHED,
ANIMATION_LAYER_FLINCH,
ANIMATION_LAYER_ALIVELOOP,
ANIMATION_LAYER_LEAN,
ANIMATION_LAYER_COUNT
};
struct matrixes
{
matrix3x4_t main[MAXSTUDIOBONES];
matrix3x4_t zero[MAXSTUDIOBONES];
matrix3x4_t first[MAXSTUDIOBONES];
matrix3x4_t second[MAXSTUDIOBONES];
};
class adjust_data;
class C_LagRecord
{
public:
float_t m_SimulationTime = 0.0f;
float_t m_LowerBodyYaw = 0.0f;
float_t m_DuckAmount = 0.0f;
float_t m_BruteYaw = 0.0f;
int32_t m_UpdateDelay = 0;
int32_t m_RotationMode = ROTATE_SERVER;
int32_t m_Flags = 0;
int32_t m_AdjustTick = 0;
Vector m_EyeAngles = Vector(0, 0, 0);
Vector m_AbsAngles = Vector(0, 0, 0);
Vector m_Velocity = Vector(0, 0, 0);
Vector m_Origin = Vector(0, 0, 0);
Vector m_AbsOrigin = Vector(0, 0, 0);
Vector m_Mins = Vector(0, 0, 0);
Vector m_Maxs = Vector(0, 0, 0);
std::array < std::array < AnimationLayer, ANIMATION_LAYER_COUNT >, 6 > m_AnimationLayers = { };
std::array < std::array < matrix3x4_t, MAXSTUDIOBONES >, 4 > m_Matricies = { };
std::array < float_t, MAXSTUDIOPOSEPARAM > m_PoseParameters = { };
bool m_bIsShooting = false;
bool m_bAnimResolved = false;
bool m_bJumped = false;
};
typedef struct C_PlayerInfo
{
int64_t iSomething;
union
{
int64_t m_iSteamID64; //0x0008 - SteamID64
struct
{
int32_t m_iXuidLow;
int32_t m_iXuidHigh;
};
};
char m_strName[128];
int m_iUserId;
char m_strSteamID[20];
char pad_0x00A8[0x10];
unsigned long m_iSteamID;
char m_strFriendsName[128];
bool m_bIsFakePlayer;
bool m_bIsHLTV;
unsigned int m_aCustomFiles[4];
unsigned char m_bFilesDownloaded;
};
class resolver
{
player_t* player = nullptr;
adjust_data* player_record = nullptr;
bool side = false;
bool fake = false;
bool was_first_bruteforce = false;
bool was_second_bruteforce = false;
std::array < std::array < Vector, MAXSTUDIOBONES >, 65 > m_BoneOrigins;
std::array < std::array < matrix3x4_t, MAXSTUDIOBONES >, 65 > m_CachedMatrix = { };
std::array < C_LagRecord, 65 > m_PreviousRecord = { };
std::array < bool, 65 > m_LeftDormancy = { };
std::array < std::deque < C_LagRecord >, 65 > m_CachedPlayerRecords;
float lock_side = 0.0f;
float original_goal_feet_yaw = 0.0f;
float original_pitch = 0.0f;
public:
void initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch);
void reset();
void resolve_yaw();
void UpdatePlayerAnimations(player_t* pPlayer, C_LagRecord& LagRecord, C_LagRecord PreviousRecord, bool bHasPreviousRecord, int32_t iRotationMode);
bool GetCachedMatrix(player_t* pPlayer, matrix3x4_t* aMatrix);
void OnUpdateClientSideAnimation(player_t* pPlayer);
float resolve_pitch();
void animations(player_t* pPlayer, matrix3x4_t* aMatrix, bool bSafeMatrix);
virtual C_LagRecord GetPreviousRecord(int32_t iPlayerID) { return m_PreviousRecord[iPlayerID]; };
virtual bool HasLeftOutOfDormancy(int32_t iPlayerID) { return m_LeftDormancy[iPlayerID]; };
virtual void UnmarkAsDormant(int32_t iPlayerID) { m_LeftDormancy[iPlayerID] = false; };
AnimationLayer previous_layers[13];
resolver_side last_side = RESOLVER_ORIGINAL;
};
class adjust_data
{
public:
player_t* player;
int i;
AnimationLayer previous_layers[13];
AnimationLayer layers[13];
matrixes matrixes_data;
resolver_type type;
resolver_side side;
bool invalid;
bool immune;
bool dormant;
bool bot;
int flags;
int bone_count;
float simulation_time;
float duck_amount;
float lby;
Vector angles;
Vector abs_angles;
Vector velocity;
Vector origin;
Vector mins;
Vector maxs;
matrix3x4_t leftmatrixes[128] = {};
matrix3x4_t rightmatrixes[128] = {};
std::array<float, 24> left_poses = {};
std::array<float, 24> right_poses = {};
adjust_data()
{
reset();
}
void reset()
{
player = nullptr;
i = -1;
type = ORIGINAL;
side = RESOLVER_ORIGINAL;
invalid = false;
immune = false;
dormant = false;
bot = false;
flags = 0;
bone_count = 0;
simulation_time = 0.0f;
duck_amount = 0.0f;
lby = 0.0f;
angles.Zero();
abs_angles.Zero();
velocity.Zero();
origin.Zero();
mins.Zero();
maxs.Zero();
}
adjust_data(player_t* e, bool store = true)
{
type = ORIGINAL;
side = RESOLVER_ORIGINAL;
invalid = false;
store_data(e, store);
}
void store_data(player_t* e, bool store = true)
{
if (!e->is_alive())
return;
player = e;
i = player->EntIndex();
if (store)
{
memcpy(layers, e->get_animlayers(), e->animlayer_count() * sizeof(AnimationLayer));
memcpy(matrixes_data.main, player->m_CachedBoneData().Base(), player->m_CachedBoneData().Count() * sizeof(matrix3x4_t));
}
immune = player->m_bGunGameImmunity() || player->m_fFlags() & FL_FROZEN;
dormant = player->IsDormant();
bot = false;
flags = player->m_fFlags();
bone_count = player->m_CachedBoneData().Count();
simulation_time = player->m_flSimulationTime();
duck_amount = player->m_flDuckAmount();
lby = player->m_flLowerBodyYawTarget();
angles = player->m_angEyeAngles();
abs_angles = player->GetAbsAngles();
velocity = player->m_vecVelocity();
origin = player->m_vecOrigin();
mins = player->GetCollideable()->OBBMins();
maxs = player->GetCollideable()->OBBMaxs();
}
void adjust_player()
{
if (!valid(false))
return;
memcpy(player->get_animlayers(), layers, player->animlayer_count() * sizeof(AnimationLayer));
memcpy(player->m_CachedBoneData().Base(), matrixes_data.main, player->m_CachedBoneData().Count() * sizeof(matrix3x4_t));
player->m_fFlags() = flags;
player->m_CachedBoneData().m_Size = bone_count;
player->m_flSimulationTime() = simulation_time;
player->m_flDuckAmount() = duck_amount;
player->m_flLowerBodyYawTarget() = lby;
player->m_angEyeAngles() = angles;
player->set_abs_angles(abs_angles);
player->m_vecVelocity() = velocity;
player->m_vecOrigin() = origin;
player->set_abs_origin(origin);
player->GetCollideable()->OBBMins() = mins;
player->GetCollideable()->OBBMaxs() = maxs;
}
bool valid(bool extra_checks = true)
{
if (!this)
return false;
if (i > 0)
player = (player_t*)m_entitylist()->GetClientEntity(i);
if (!player)
return false;
if (player->m_lifeState() != LIFE_ALIVE)
return false;
if (immune)
return false;
if (dormant)
return false;
if (!extra_checks)
return true;
if (invalid)
return false;
auto net_channel_info = m_engine()->GetNetChannelInfo();
if (!net_channel_info)
return false;
static auto sv_maxunlag = m_cvar()->FindVar(crypt_str("sv_maxunlag"));
auto outgoing = net_channel_info->GetLatency(FLOW_OUTGOING);
auto incoming = net_channel_info->GetLatency(FLOW_INCOMING);
auto correct = math::clamp(outgoing + incoming + util::get_interpolation(), 0.0f, sv_maxunlag->GetFloat());
auto curtime = g_ctx.local()->is_alive() ? TICKS_TO_TIME(g_ctx.globals.fixed_tickbase) : m_globals()->m_curtime;
auto delta_time = correct - (curtime - simulation_time);
if (fabs(delta_time) > 0.2f)
return false;
auto extra_choke = 0;
if (g_ctx.globals.fakeducking)
extra_choke = 14 - m_clientstate()->iChokedCommands;
auto server_tickcount = extra_choke + m_globals()->m_tickcount + TIME_TO_TICKS(outgoing + incoming);
auto dead_time = (int)(TICKS_TO_TIME(server_tickcount) - sv_maxunlag->GetFloat());
if (simulation_time < (float)dead_time)
return false;
return true;
}
};
class optimized_adjust_data
{
public:
int i;
player_t* player;
float simulation_time;
float duck_amount;
Vector angles;
Vector origin;
optimized_adjust_data()
{
reset();
}
void reset()
{
i = 0;
player = nullptr;
simulation_time = 0.0f;
duck_amount = 0.0f;
angles.Zero();
origin.Zero();
}
};
class lagdata
{
c_baseplayeranimationstate* animstate;
public:
float side;
float realtime = animstate->m_flLastClientSideAnimationUpdateTime;
float resolving_way;
};
extern std::deque <adjust_data> player_records[65];
class lagcompensation : public singleton <lagcompensation>
{
public:
void fsn(ClientFrameStage_t stage);
void extrapolation(player_t* player, Vector& origin, Vector& velocity, int& flags, bool on_ground);
void upd_nw(player_t* m_pPlayer);
void extrapolate(player_t* player, Vector& origin, Vector& velocity, int& flags, bool wasonground);
bool valid(int i, player_t* e);
void update_player_animations(player_t* e);
resolver player_resolver[65];
bool is_dormant[65];
float previous_goal_feet_yaw[65];
};
