lucretia.cc
-
Автор темы
- #1
sorry if it's already posted here, not mine. will make it /del if you tell me where it's posted :)
don't use site translate or code will be messy
don't use site translate or code will be messy
C++:
#include "xyu.h"
#include "joparesolve.h"
#include "backtrackjopa.h"
#include "ragejopafix.h"
#include "jopafix.h"
std::string ResolverMode[65];
std::string ResolverMode_freestand[65];
std::string DidShot[65];
int last_ticks[65];
int IBasePlayer::GetChokedPackets() {
auto ticks = TIME_TO_TICKS(GetSimulationTime() - GetOldSimulationTime());
if (ticks == 0 && last_ticks[GetIndex()] > 0) {
return last_ticks[GetIndex()] - 1;
}
else {
last_ticks[GetIndex()] = ticks;
return ticks;
}
}
float ApproachAngle(float target, float value, float speed)
{
target = (target * 182.04445f) * 0.0054931641f;
value = (value * 182.04445f) * 0.0054931641f;
float delta = target - value;
// Speed is assumed to be positive
if (speed < 0)
speed = -speed;
if (delta < -180.0f)
delta += 360.0f;
else if (delta > 180.0f)
delta -= 360.0f;
if (delta > speed)
value += speed;
else if (delta < -speed)
value -= speed;
else
value = target;
return value;
}
void CResolver::UpdateAnimations(IBasePlayer* player)
{
auto AnimState = player->GetPlayerAnimState();
if (AnimState)
{
// backup..
const float curtime = interfaces.global_vars->curtime;
const float frametime = interfaces.global_vars->frametime;
interfaces.global_vars->frametime = interfaces.global_vars->interval_per_tick;
interfaces.global_vars->curtime = player->GetTickBase();
int backup_eflags = player->GetEFlags();
// SetLocalVelocity to update
player->GetEFlags() &= ~0x1000; // InvalidatePhysicsRecursive(VELOCITY_CHANGED); EFL_DIRTY_ABSVELOCITY = 0x1000
player->GetAbsOriginVec() = player->GetVelocity();
// check to invalid animations
if (AnimState->m_iLastClientSideAnimationUpdateFramecount == interfaces.global_vars->framecount)
AnimState->m_iLastClientSideAnimationUpdateFramecount = interfaces.global_vars->framecount - 1;
player->GetClientSideAnims() = true;
// updates local animations + poses + calculates new abs angle based on eyeangles and other stuff
player->UpdateClientSideAnimation();
player->GetClientSideAnims() = false;
// restore
player->GetEFlags() = backup_eflags;
interfaces.global_vars->curtime = curtime;
interfaces.global_vars->frametime = frametime;
player->InvalidateBoneCache();
player->SetupBones(nullptr, -1, 0x7FF00, interfaces.global_vars->curtime);
}
}
static auto GetSmoothedVelocity = [](float min_delta, Vector a, Vector b) {
Vector delta = a - b;
float delta_length = delta.Length();
if (delta_length <= min_delta) {
Vector result;
if (-min_delta <= delta_length) {
return a;
}
else {
float iradius = 1.0f / (delta_length + FLT_EPSILON);
return b - ((delta * iradius) * min_delta);
}
}
else {
float iradius = 1.0f / (delta_length + FLT_EPSILON);
return b + ((delta * iradius) * min_delta);
}
};
void CResolver::BruteForce(IBasePlayer* player) {
float m_flFakeGoalFeetYaw[65];
auto animState = player->GetPlayerAnimState();
auto& resolverInfo = resolver[player->EntIndex()];
// Rebuild setup velocity to receive flMinBodyYaw and flMaxBodyYaw
Vector velocity = player->GetAbsVelocity();
float spd = velocity.LengthSqr();
if (spd > std::powf(1.2f * 260.0f, 2.f)) {
Vector velocity_normalized = velocity.Normalize();
velocity = velocity_normalized * (1.2f * 260.0f);
}
float v25 = clamp(player->GetDuckAmount() + animState->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
float v26 = animState->m_fDuckAmount;
float v27 = csgo->client_state->iChokedCommands * 6.0f;
float v28;
// clamp
if ((v25 - v26) <= v27) {
if (-v27 <= (v25 - v26))
v28 = v25;
else
v28 = v26 - v27;
}
else {
v28 = v26 + v27;
}
float flDuckAmount = clamp(v28, 0.0f, 1.0f);
Vector animationVelocity = GetSmoothedVelocity(csgo->client_state->iChokedCommands * 2000.0f, velocity, player->GetVelocity());
float speed = std::fminf(animationVelocity.Length(), 260.0f);
auto weapon = player->GetWeapon();
float flMaxMovementSpeed = 260.0f;
if (weapon) {
flMaxMovementSpeed = std::fmaxf(weapon->GetCSWpnData()->flMaxPlayerSpeed, 0.001f); //speed to player XD..
}
float m_flGroundFraction = *(float*)(animState + 0x11C);
float flRunningSpeed = speed / (flMaxMovementSpeed * 0.520f);
float flDuckingSpeed = speed / (flMaxMovementSpeed * 0.340f);
flRunningSpeed = clamp(flRunningSpeed, 0.0f, 1.0f);
float flYawModifier = (((animState->m_flGoalFeetYaw * -0.3f) - 0.2f) * flRunningSpeed) + 1.0f;
if (flDuckAmount > 0.0f) {
float flDuckingSpeed = clamp(flDuckingSpeed, 0.0f, 1.0f);
flYawModifier += (flDuckAmount * flDuckingSpeed) * (0.5f - flYawModifier);
}
float flMinBodyYaw = std::fabsf(((float)(uintptr_t(animState) + 0x330)) * flYawModifier);
float flMaxBodyYaw = std::fabsf(((float)(uintptr_t(animState) + 0x334)) * flYawModifier);
float flEyeYaw = player->GetEyeAngles().y;
float flEyeDiff = std::remainderf(flEyeYaw - m_flFakeGoalFeetYaw[player->EntIndex()], 360.f);
if (flEyeDiff <= flMaxBodyYaw) {
if (flMinBodyYaw > flEyeDiff)
m_flFakeGoalFeetYaw[player->EntIndex()] = fabs(flMinBodyYaw) + flEyeYaw;
}
else {
m_flFakeGoalFeetYaw[player->EntIndex()] = flEyeYaw - fabs(flMaxBodyYaw);
}
m_flFakeGoalFeetYaw[player->EntIndex()] = std::remainderf(m_flFakeGoalFeetYaw[player->EntIndex()], 360.f);
if (speed > 0.1f || fabs(velocity.z) > 100.0f) {
m_flFakeGoalFeetYaw[player->EntIndex()] = ApproachAngle(
flEyeYaw,
m_flFakeGoalFeetYaw[player->EntIndex()],
((m_flGroundFraction * 20.0f) + 30.0f)
* csgo->client_state->iChokedCommands);
}
else {
m_flFakeGoalFeetYaw[player->EntIndex()] = ApproachAngle(
player->SetLowerBodyYaw(),
m_flFakeGoalFeetYaw[player->EntIndex()],
csgo->client_state->iChokedCommands * 100.0f);
}
float Left = flEyeYaw + flMinBodyYaw;
float Right = flEyeYaw + flMaxBodyYaw;
float resolveYaw;
switch (csgo->missedshots[player->EntIndex()] % 3) {
case 0: // brute left side
resolveYaw = Left;
break;
case 1: // brute fake side
resolveYaw = m_flFakeGoalFeetYaw[player->EntIndex()];
break;
case 2: // brute right side
resolveYaw = Right;
break;
default:
break;
}
}
void update_state(CCSGOPlayerAnimState* state, Vector angles) { //update stating ^^
using Fn = void(__vectorcall*)(void*, void*, float, float, float, void*);
static auto fn = *reinterpret_cast<Fn**>(csgo->Utils.FindPatternIDA(GetModuleHandleA("client.dll"), "55 8B EC 83 E4 F8 83 EC 18 56 57 8B F9 F3 0F 11 54 24"));
fn == (state, nullptr, 0.0f, angles[1], angles[0], nullptr);
}
void ResolverBackUpSystem(IBasePlayer* pEnt) {
if (!vars.ragebot.resolver)
return;
if (pEnt->GetTeam() == csgo->local()->GetTeam())
return;
const auto player_animation_state = pEnt->GetPlayerAnimState();
if (!player_animation_state)
return;
float m_flLastClientSideAnimationUpdateTimeDelta = fabs(player_animation_state->m_iLastClientSideAnimationUpdateFramecount - player_animation_state->m_flLastClientSideAnimationUpdateTime);
auto v48 = 0.f;
if (player_animation_state->m_flFeetSpeedForwardsOrSideWays >= 0.0f)
{
v48 = fminf(player_animation_state->m_flFeetSpeedForwardsOrSideWays, 1.0f);
}
else
{
v48 = 0.0f;
}
float v49 = ((player_animation_state->m_flStopToFullRunningFraction * -0.30000001) - 0.19999999) * v48;
float flYawModifier = v49 + 1.0;
if (player_animation_state->m_fDuckAmount > 0.0)
{
float v53 = 0.0f;
if (player_animation_state->m_flFeetSpeedUnknownForwardOrSideways >= 0.0)
{
v53 = fminf(player_animation_state->m_flFeetSpeedUnknownForwardOrSideways, 1.0);
}
else
{
v53 = 0.0f;
}
}
float flMaxYawModifier = player_animation_state->pad10[516] * flYawModifier;
float flMinYawModifier = player_animation_state->pad10[512] * flYawModifier;
float newFeetYaw = 0.f;
auto eyeYaw = player_animation_state->m_flEyeYaw;
auto lbyYaw = player_animation_state->m_flGoalFeetYaw;
float eye_feet_delta = fabs(eyeYaw - lbyYaw);
if (eye_feet_delta <= flMaxYawModifier)
{
if (flMinYawModifier > eye_feet_delta)
{
newFeetYaw = fabs(flMinYawModifier) + eyeYaw;
}
}
else
{
newFeetYaw = eyeYaw - fabs(flMaxYawModifier);
}
float v136 = fmod(newFeetYaw, 360.0);
if (v136 > 180.0)
{
v136 = v136 - 360.0;
}
if (v136 < 180.0)
{
v136 = v136 + 360.0;
}
player_animation_state->m_flGoalFeetYaw = v136;
}
void CResolver::FrameStage(ClientFrameStage_t stage)
{
if (!csgo->local() || !interfaces.engine->IsInGame())
return;
static bool wasDormant[65];
for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)
{
IBasePlayer* pPlayerEntity = interfaces.ent_list->GetClientEntity(i);
if (!pPlayerEntity
|| !pPlayerEntity->isAlive())
continue;
if (pPlayerEntity->IsDormant())
{
wasDormant[i] = true;
continue;
}
if (stage == FRAME_RENDER_START)
{
BruteForce(pPlayerEntity);
UpdateAnimations(pPlayerEntity);
//HandleHits(pPlayerEntity(); //no uncomment bitch
}
if (stage == FRAME_NET_UPDATE_END && pPlayerEntity != csgo->local())
{
auto VarMap = reinterpret_cast<uintptr_t>(pPlayerEntity) + 36;
auto VarMapSize = *reinterpret_cast<int*>(VarMap + 20);
for (auto index = 0; index < VarMapSize; index++)
*reinterpret_cast<uintptr_t*>(*reinterpret_cast<uintptr_t*>(VarMap) + index * 12) = 0;
}
wasDormant[i] = false;
}//
}
void HandleHits(IBasePlayer* pEnt)
{
if (!vars.ragebot.resolver)
return;
auto NetChannel = interfaces.engine->GetNetChannelInfo();
if (!NetChannel)
return;
static float predTime[65];
static bool init[65];
if (csgo->didShot[pEnt->EntIndex()])
{
if (init[pEnt->EntIndex()])
{
resolver->pitchHit[pEnt->EntIndex()] = pEnt->GetEyeAngles().x;
predTime[pEnt->EntIndex()] = interfaces.global_vars->curtime + NetChannel->GetAvgLatency(FLOW_INCOMING) + NetChannel->GetAvgLatency(FLOW_OUTGOING) + TICKS_TO_TIME(1) + TICKS_TO_TIME(interfaces.engine->GetNetChannel()->iChokedPackets);
init[pEnt->EntIndex()] = false;
}
if (interfaces.global_vars->curtime > predTime[pEnt->EntIndex()] && !csgo->hitshots[pEnt->EntIndex()])
{
csgo->missedshots[pEnt->EntIndex()] += 1;
csgo->didShot[pEnt->EntIndex()] = false;
}
else if (interfaces.global_vars->curtime <= predTime[pEnt->EntIndex()] && !csgo->hitshots[pEnt->EntIndex()])
csgo->didShot[pEnt->EntIndex()] = false;
}
else
init[pEnt->EntIndex()] = true;
csgo->hitshots[pEnt->EntIndex()] = false;
}
void CResolver::StoreAntifreestand()
{
if (!vars.ragebot.enable)
return;
if (!csgo->local()->isAlive())
return;
if (!csgo->local()->GetWeapon() || csgo->local()->GetWeapon())
return;
for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)
{
IBasePlayer* pPlayerEntity = interfaces.ent_list->GetClientEntity(i);
if (!pPlayerEntity
|| !pPlayerEntity->isAlive()
|| pPlayerEntity->IsDormant()
|| pPlayerEntity == csgo->local()
|| pPlayerEntity->GetTeam() == csgo->local()->GetTeam())
{
FreestandSide[i] = false;
continue;
}
if (abs(pPlayerEntity->GetVelocity().Length2D()) > 29.f)
FreestandSide[pPlayerEntity->EntIndex()] = false;
if (abs(pPlayerEntity->GetVelocity().Length2D()) <= 29.f && !FreestandSide[pPlayerEntity->EntIndex()])
{
bool Autowalled = false, HitSide1 = false, HitSide2 = false;
auto idx = pPlayerEntity->GetIndex();
float angToLocal = Math::CalculateAngle(csgo->local()->GetOrigin(), pPlayerEntity->GetOrigin()).y;
Vector ViewPoint = csgo->local()->GetOrigin() + Vector(0, 0, 90);
Vector2D Side1 = { (50 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };
Vector2D Side2 = { (50 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };
Vector2D Side3 = { (50 * sin(DEG2RAD(angToLocal))),(50 * cos(DEG2RAD(angToLocal))) };
Vector2D Side4 = { (50 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };
Vector Origin = pPlayerEntity->GetOrigin();
Vector2D OriginLeftRight[] = { Vector2D(Side1.x, Side1.y), Vector2D(Side2.x, Side2.y) };
Vector2D OriginLeftRightLocal[] = { Vector2D(Side3.x, Side3.y), Vector2D(Side4.x, Side4.y) };
for (int side = 0; side < 2; side++)
{
Vector OriginAutowall = { Origin.x + OriginLeftRight[side].x, Origin.y - OriginLeftRight[side].y , Origin.z + 90 };
Vector OriginAutowall2 = { ViewPoint.x + OriginLeftRightLocal[side].x, ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };
if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
{
if (side == 0)
{
HitSide1 = true;
FreestandSide[pPlayerEntity->EntIndex()] = 90;
}
else if (side == 1)
{
HitSide2 = true;
FreestandSide[pPlayerEntity->EntIndex()] = -90;
}
Autowalled = true;
}
else
{
for (int side222 = 0; side222 < 2; side222++)
{
Vector OriginAutowall222 = { Origin.x + OriginLeftRight[side222].x, Origin.y - OriginLeftRight[side222].y , Origin.z + 90 };
if (g_AutoWall.CanHitFloatingPoint(OriginAutowall222, OriginAutowall2))
{
if (side222 == 0)
{
HitSide1 = true;
FreestandSide[idx] = -1;
ResolverMode_freestand[idx] = " Left Alt ";
//FreestandAngle[pPlayerEntity->EntIndex()] = 90;
}
else if (side222 == 1)
{
HitSide2 = true;
FreestandSide[idx] = 1;
ResolverMode_freestand[idx] = " Right Alt ";
//FreestandAngle[pPlayerEntity->EntIndex()] = -90;
}
Autowalled = true;
}
}
}
}
if (Autowalled)
{
if (HitSide1 && HitSide2)
FreestandSide[pPlayerEntity->EntIndex()] = false;
else
FreestandSide[pPlayerEntity->EntIndex()] = true;
}
}
}
}
//cheat resolve to issue
void CResolver::Resolver(animation* record) //resolver method
{
static float resolver_last_sim_time[64] = {};
auto info = record->anim_state;
if (!info)
return;
if (!vars.ragebot.resolver)
return;
if (!info || !record->has_anim_state || record->player->GetPlayerInfo().fakeplayer || record->didshot)
return;
float simtime = record->player->GetSimulationTime();
if (simtime == record->player->GetOldSimulationTime()) // not updated yet // We should recieve first goalfeet from the server
return;
if (simtime == resolver_last_sim_time[record->player->EntIndex()]) // avoid to fix already fixed angle .. jitter fix .. // we fix only recieved server goal feet, not client sided.
return;
resolver_last_sim_time[record->player->EntIndex()] = simtime; // store last resolver update time
// RESOLVER PART //
float Left = record->anim_state->m_flEyeYaw - 70;
float Right = record->anim_state->m_flEyeYaw + 70;
float Middle = record->anim_state->m_flEyeYaw;
info->m_flCurrentTorsoYaw = record->anim_state->m_flGoalFeetYaw; // set default standart "backwards" // server goalfeet //
// main logic //
record->anim_state->m_flGoalFeetYaw = clamp(record->anim_state->m_flGoalFeetYaw, -360.0f, 360.0f);
float eye_feet_delta = Math::AngleDiff(record->anim_state->m_flEyeYaw, record->anim_state->m_flGoalFeetYaw);
if (eye_feet_delta <= 57)
{
if (-57 > eye_feet_delta)
record->anim_state->m_flGoalFeetYaw = Middle; // LBY based desync fix
else if (eye_feet_delta == 0.f) // no desync || real on side with fake middle angle.
{
const auto slow_walk = record->anim_state->m_flFeetYawRate >= 0.01f && record->anim_state->m_flFeetYawRate <= 0.8f;
if (slow_walk) // if player is able to use desync //
{
if (record->anim_state->m_flGoalFeetYaw != record->anim_state->m_flCurrentFeetYaw) // set previos server goal feet angle -> REAL Choked Angle //
record->anim_state->m_flGoalFeetYaw = record->anim_state->m_flCurrentFeetYaw;
}
}
}
else
{
record->anim_state->m_flGoalFeetYaw = Middle; // LBY based desync fix
}
info->m_flCurrentTorsoYaw = record->anim_state->m_flGoalFeetYaw; // set the new angle //
record->anim_state->m_flGoalFeetYaw = Math::NormalizeYaw(info->m_flCurrentTorsoYaw); // normalize angle //
record->player->GetPlayerAnimState()->m_flGoalFeetYaw = record->anim_state->m_flGoalFeetYaw;
}
void store_deltas(animation* record)
{
CCSGOPlayerAnimState animstate_backup;
memcpy(&animstate_backup, record->player->GetPlayerAnimState(), 0x344);
//const auto abs_origin = m_player->get_abs_origin();
const auto poses = record->player->m_flPoseParameter();
const auto backup_angles = record->player->GetEyeAngles();
const auto backup_velocity = record->player->GetVelocity();
const auto backup_origin = record->player->GetOrigin();
const auto backup_duckamt = record->player->GetDuckAmount();
const auto backup_simtime = record->player->GetSimulationTime();
const auto backup_flags = record->player->GetFlags();
auto m_records = interfaces.global_vars->curtime = record->player->GetTickBase();
CAnimationLayer* animlayers = record->layers;
//resolve_data->previous_rotation = backup_angles.y;
auto lag = interfaces.global_vars->curtime = record->player->GetTickBase();
if (lag <= 1)
{
{
std::memcpy(record->player->GetPlayerAnimState(), animlayers, 0x38 * 13);
//cheat::features::lagcomp.update_animations(record->player, (m_records.empty() ? nullptr : &m_records[0]), -1);
//memcpy(resolve_data->resolver_anim_layers[1], record->player->GetPlayerAnimState(), 0x38 * 13);
//std::memcpy(record->player->GetPlayerAnimState(), resolve_data->server_anim_layers, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
record->player->GetBoneArrayForWrite();
//record->player->setup_bones()
record->build_server_bones(record->player);
//memcpy(resolve_data->rightmx, m_player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * m_player->GetBoneCount());
//resolve_data->right_side = record->player->get_anim_state()->goal_feet_yaw;
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->rightrec);
record->player->m_flPoseParameter() = poses;
memcpy(record->player->GetPlayerAnimState(), &animstate_backup, 0x344);
//memcpy(record->player->GetPlayerAnimState(), resolve_data->server_anim_layers, 0x38 * 13);
record->player->GetVelocity() = backup_velocity;
record->player->GetOrigin() = backup_origin;
record->player->GetDuckAmount() = backup_duckamt;
record->player->GetSimulationTime() = backup_simtime;
record->player->GetEyeAngles() = backup_angles;
record->player->GetEFlags() = backup_flags;
record->player->GetAbsVelocity() = backup_velocity;
}
{
//cheat::features::lagcomp.update_animations(record->player, (m_records.empty() ? nullptr : &m_records[0]), 1);
//std::memcpy(->[2], record->player->get_animation_layers(), 0x38 * 13);
//td::memcpy(record->player->get_animation_layers(), resolve_data->server_anim_layers, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
//record->player->force_bone_rebuild();
//record->player->SetupBonesEx();
record->build_server_bones(record->player);
//memcpy(resolve_data->leftmx, m_player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * m_player->GetBoneCount());
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->leftrec);
//resolve_data->left_side = record->player->get_anim_state()->goal_feet_yaw;
record->player->m_flPoseParameter() = poses;
memcpy(record->player->GetPlayerAnimState(), &animstate_backup, 0x344);
memcpy(record->player->GetPlayerAnimState(), animlayers, 0x38 * 13);
record->player->GetVelocity() = backup_velocity;
record->player->GetOrigin() = backup_origin;
record->player->GetDuckAmount() = backup_duckamt;
record->player->GetSimulationTime() = backup_simtime;
record->player->GetEyeAngles() = backup_angles;
record->player->GetEFlags() = backup_flags;
record->player->GetAbsVelocity() = backup_velocity;
}
}
else
{
//cheat::features::lagcomp.update_animations(record->player, (m_records.empty() ? nullptr : &m_records[0]), 1);
auto v38 = Math::AngleDiff(record->player->GetEyeAngles().y, record->player->GetPlayerAnimState()->m_flGoalFeetYaw);
auto is_inverted = v38 < 0.0f;
if (is_inverted)
{
//std::memcpy(resolve_data->resolver_anim_layers[1], record->player->get_animation_layers(), 0x38 * 13);
//std::memcpy(record->player->get_animation_layers(), resolve_data->server_anim_layers, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
record->player->GetBoneArrayForWrite();
//record->player->SetupBonesEx();
record->build_server_bones(record->player);
//memcpy(resolve_data->rightmx, record->player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * record->player->GetBoneCount());
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->rightrec);
//resolve_data->right_side = record->player->get_animation_state()->abs_yaw;
}
else
{
//std::memcpy(resolve_data->resolver_anim_layers[2], record->player->get_animation_layers(), 0x38 * 13);
//std::memcpy(record->player->get_animation_layers(), resolve_data->server_anim_layers, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
record->player->GetBoneArrayForWrite();
//record->player->SetupBonesEx();
record->build_server_bones(record->player);
//memcpy(resolve_data->leftmx, record->player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * record->player->GetBoneCount());
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->leftrec);
//resolve_data->left_side = record->player->get_animation_state()->abs_yaw;
}
record->player->m_flPoseParameter() = poses;
memcpy(record->player->GetPlayerAnimState(), &animstate_backup, 0x344);
memcpy(record->player->GetPlayerAnimState(), animlayers, 0x38 * 13);
record->player->GetVelocity() = backup_velocity;
record->player->GetOrigin() = backup_origin;
record->player->GetDuckAmount() = backup_duckamt;
record->player->GetSimulationTime() = backup_simtime;
record->player->GetEyeAngles() = backup_angles;
record->player->GetEFlags() = backup_flags;
record->player->GetAbsVelocity() = backup_velocity;
{
std::memcpy(record->player->GetPlayerAnimState(), animlayers, 0x38 * 13);
//vars.ragebot.active_index(record->player, (m_records.empty() ? nullptr : &m_records[0]), -1);
if (is_inverted)
{
//std::memcpy(resolve_data->resolver_anim_layers[2], record->player->GetPlayerAnimState(), 0x38 * 13);
//std::memcpy(record->player->GetPlayerAnimState(), resolve_data->server_anim_layers, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
record->player->GetBoneArrayForWrite();
//record->player->SetupBonesEx();
record->build_server_bones(record->player);
//memcpy(resolve_data->leftmx, record->player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * record->player->GetBoneCount());
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->leftrec);
//resolve_data->left_side = record->player->get_animation_state()->abs_yaw;
}
else
{
//memcpy(resolver_value->resolver_anim_layers[1], record->player->(), 0x38 * 13);
//std::memcpy(record->player->GetPlayerAnimState(), resolve_data->server_anim_layers, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
record->player->GetReadableBones();
//record->player->SetupBonesEx();
record->build_server_bones(record->player);
//memcpy(resolve_data->rightmx, record->player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * record->player->GetBoneCount());
//resolve_data->right_side = record->player->get_animation_state()->abs_yaw;
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->rightrec);
}
record->player->m_flPoseParameter() = poses;
memcpy(record->player->GetPlayerAnimState(), &animstate_backup, 0x344);
memcpy(record->player->GetPlayerAnimState(), animlayers, 0x38 * 13);
record->player->GetVelocity() = backup_velocity;
record->player->GetOrigin() = backup_origin;
record->player->GetDuckAmount() = backup_duckamt;
record->player->GetSimulationTime() = backup_simtime;
record->player->GetEyeAngles() = backup_angles;
record->player->GetEFlags() = backup_flags;
record->player->GetAbsVelocity() = backup_velocity;
}
}
{
//cheat::features::lagcomp.update_animations(record->player, (m_records.empty() ? nullptr : &m_records[0]), 0);
//memcpy(resolve_data->resolver_anim_layers[0], record->player->get_animation_layers(), 0x38 * 13);
//std::memcpy(record->player->GetPlayerAnimState() record->player->GetPlayerAnimState, 0x38 * 13);
//m_player->set_abs_angles(QAngle(0, (*(float*)(uintptr_t(m_player->get_animation_state()) + 0x80)), 0));
record->player->GetReadableBones();
record->build_server_bones(record->player);
//record->player->SetupBonesEx();
//cheat::features::lagcomp.store_record_data(record->player, &resolve_data->norec);
//memcpy(resolve_data->nodesmx, record->player->m_CachedBoneData().Base(), sizeof(matrix3x4_t) * record->player->GetBoneCount());
//resolve_data->no_side = record->player->get_animation_state()->abs_yaw;
record->player->m_flPoseParameter() = poses;
memcpy(record->player->GetPlayerAnimState(), &animstate_backup, 0x344);
memcpy(record->player->GetPlayerAnimState(), animlayers, 0x38 * 13);
record->player->GetVelocity() = backup_velocity;
record->player->GetOrigin() = backup_origin;
record->player->GetDuckAmount() = backup_duckamt;
record->player->GetSimulationTime() = backup_simtime;
record->player->GetEyeAngles() = backup_angles;
record->player->GetEFlags() = backup_flags;
record->player->GetAbsVelocity() = backup_velocity;
}
}
bool resolve_by_onetap_resolver(animation* record)
{
//rebuild_store();
return false;
auto speed = record->player->GetVelocity().Length2D();
//if (record->player->GetFlags() & (record->player->GetFlags() & FL_ONGROUND && (record->player->GetFlags() & FL_ONGROUND
{
if (speed < 0.1f)
{
auto delta = Math::AngleDiff(record->player->GetEyeAngles().y, record->player->GetPlayerAnimState()->m_flGoalFeetYaw);
if (record->has_anim_state = true == 0.0f && record->has_anim_state == 0.0f) {
//lag_data->resolving_way = std::clamp((2 * (delta <= 0.f) - 1), -1, 1);// copysign(1, delta);
record->anim_time = true;
}
}
else if (!int(record->layers[12].m_flWeight * 1000.f))//(lag_data->server_anim_layers[6].m_flWeight * 1000.f) == (history_data->at(0).anim_layers[6].m_flWeight * 1000.f))
{
//2 = -1; 3 = 1; 1 = fake;
if (int(record->layers[6].m_flWeight * 1000.f) == int(record->layers[6].m_flWeight * 1000.f))
{
float delta1 = abs(record->layers[6].m_flPlaybackRate); //- record->layers[0][6].playback_rate);
float delta2 = abs(record->layers[6].m_flPlaybackRate); //- record->layers[1][6].playback_rate);
float delta3 = abs(record->layers[6].m_flPlaybackRate); //record->anim_state[2][6].playback_rate);
if (delta1 < delta3 || delta2 <= delta3 || (int)(float)(delta3 * 1000.0f)) {
if (delta1 >= delta2 && delta3 > delta2 && !(int)(float)(delta2 * 1000.0f))
{
//lag_data->resolving_method = 1;
//lag_data->resolving_way = 1;
record->has_anim_state = true;
record->resolver = true;
record->anim_time = interfaces.global_vars->realtime;
}
}
else
{
//lag_data->resolving_method = -1;
//record->resolving_way = -1;
record->has_anim_state = true;
record->resolver = true;
record->anim_time = interfaces.global_vars->realtime;
}
}
}
}
auto ResolvedYaw = Math::NormalizeYaw(record->player->GetEyeAngles().y + Math::NormalizeYaw(60.f)); //record->resolver));//(lag_data->resolving_method == 0 ? lag_data->no_side : (lag_data->resolving_method > 0 ? lag_data->left_side : lag_data->right_side));//
}