C++ Some shitty resolver idfk

[masondev]

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

#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));//
}

 

[Emilia]

looks a lot like zeus code to me lol

 

[train67]

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

#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));//
}

Код из Antario и толку от него никакого так фикс анимации нету а тупо перенаправление отрисовки и то кривое

 

[IClientState]

Код из Antario и толку от него никакого так фикс анимации нету а тупо перенаправление отрисовки и то кривое

да, тут есть полезное чем у тебя щас за все время..

 

[pastingisgood]

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

#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));//
}

hmmmm okaaay... lets test it!