Гайд Обновляем реслоьвер в самоваре в1

[allex]

дорова поцаны седня мы пихуем реслоьвер бамевара в ауувар

для начала я скажу что бы запастить это надо быть сверх разумом ибо скорее всего эта дичь крашит

int target = 0;
bool in_tp = false;
bool fake_walk = false;

int resolve_type[65];

int shots_fired[65];
int shots_hit[65];

int shots_missed[65];
float local_update;
float tick_to_back[65];
float lby_to_back[65];
bool backtrack_tick[65];

float lby_delta;
float update_time[65];

int hitmarker_time;

bool menu_hide;

int oldest_tick[65];
float compensate[65][12];
Vector backtrack_hitbox[65][20][12];
float backtrack_simtime[65][12];
bool using_fake_angles[65];
bool CResolver::IsFakingYaw(IClientEntity* entity)
{
    static float old_simtime[65];
    if (entity->GetSimTime() != old_simtime[entity->GetIndex()])
    {
        using_fake_angles[entity->GetIndex()] = entity->GetSimTime() - old_simtime[entity->GetIndex()] == m_pGlobals->interval_per_tick; entity->GetSimTime() - old_simtime[entity->GetIndex()] >= TICKS_TO_TIME(2);
        old_simtime[entity->GetIndex()] = entity->GetSimTime();
    }

    auto &info = player_info[entity->GetIndex()];

    if (!using_fake_angles[entity->GetIndex()])
    {
        if (backtrack_tick[entity->GetIndex()])
        {
            resolve_type[entity->GetIndex()] = 7;
            entity->SetEyeAngles(info.backtrack);
        }

        return true;
    }
}
enum CSGO_ACTS
{
    ACT_CSGO_DEFUSE = 958,
    ACT_CSGO_DEFUSE_WITH_KIT = 959,
    ACT_CSGO_FLASHBANG_REACTION = 960,
    ACT_CSGO_FIRE_PRIMARY = 961, // when shooting
    ACT_CSGO_FIRE_PRIMARY_OPT_1 = 962,
    ACT_CSGO_FIRE_PRIMARY_OPT_2 = 963,
    ACT_CSGO_FIRE_SECONDARY = 964, // shooting secondary
    ACT_CSGO_RELOAD = 967,
    ACT_CSGO_RELOAD_START = 968,
    ACT_CSGO_RELOAD_LOOP = 969,
    ACT_CSGO_RELOAD_END = 970,
    ACT_CSGO_PLANT_BOMB = 978,
    ACT_CSGO_IDLE_TURN_BALANCEADJUST = 979,
    ACT_CSGO_IDLE_ADJUST_STOPPEDMOVING = 980,
};
void CResolver::AddShotSnapshot(IClientEntity* entity, PlayerResolveRecord resolve_record)
{
    ShotSnapshot snapshot;

    snapshot.entity = entity;
    snapshot.time = UTILS::GetCurtime();
    snapshot.resolve_record = resolve_record;
    snapshot.first_processed_time = 0.f;
    snapshot.was_shot_processed = false;
    snapshot.hitgroup_hit = -1;

    shot_snapshots.push_back(snapshot);
}
void CResolver::UpdateResolveRecord(IClientEntity* entity)
{
    /// a copy of the previous record for comparisons and shit
    const auto previous_record = player_resolve_records[entity->GetIndex()];
    auto& record = player_resolve_records[entity->GetIndex()];

    record.resolved_angles = record.networked_angles;
    record.velocity = entity->GetVelocity();
    record.origin = entity->GetVecOrigin();
    record.lower_body_yaw = entity->GetLowerBodyYaw();
    record.is_dormant = entity->IsDormant();
    record.has_fake = IsFakingYaw(entity);
    record.resolve_type = 0;

    record.is_balance_adjust_triggered = false, record.is_balance_adjust_playing = false;
    for (int i = 0; i < 15; i++) /// go through each animation layer
    {
        record.anim_layers[i] = entity->GetAnimOverlay(i);

        /// balanceadjust act
        if (entity->GetSequenceActivity(record.anim_layers[i].m_nSequence) == CSGO_ACTS::ACT_CSGO_IDLE_TURN_BALANCEADJUST)
        {
            record.is_balance_adjust_playing = true;

            /// balance adjust is being triggered
            if (record.anim_layers[i].m_flWeight == 1 || record.anim_layers[i].m_flCycle > previous_record.anim_layers[i].m_flCycle)
                record.last_balance_adjust_trigger_time = UTILS::GetCurtime();
            if (fabs(UTILS::GetCurtime() - record.last_balance_adjust_trigger_time) < 0.5f)
                record.is_balance_adjust_triggered = true;
        }
    }

    if (record.is_dormant)
        record.next_predicted_lby_update = FLT_MAX;

    /// if lby updated
    if (record.lower_body_yaw != previous_record.lower_body_yaw && !record.is_dormant && !previous_record.is_dormant)
        record.did_lby_flick = true;

    /// fakewalk
    const bool is_moving_on_ground = record.velocity.Length2D() > 0.34f && entity->GetFlags() & FL_ONGROUND;
    if (is_moving_on_ground && record.is_balance_adjust_triggered)
        record.is_fakewalking = true;
    else
        record.is_fakewalking = false;

    /// last moving lby, using a high velocity check ***just in case*** of fakewalkers
    if (is_moving_on_ground && !record.is_fakewalking && record.velocity.Length2D() > 1.f && !record.is_dormant)
    {
        record.is_last_moving_lby_valid = true;
        record.is_last_moving_lby_delta_valid = false;
        record.shots_missed_moving_lby = 0;
        record.shots_missed_moving_lby_delta = 0;
        record.last_moving_lby = record.lower_body_yaw + 45;
        record.last_time_moving = UTILS::GetCurtime();
    }

    /// just came out of dormancy
    if (!record.is_dormant && previous_record.is_dormant)
    {
        /// if moved more than 32 units
        if ((record.origin - previous_record.origin).Length2D() > 16.f)
            record.is_last_moving_lby_valid = false;
    }

    /// get last moving lby delta
    if (!record.is_last_moving_lby_delta_valid && record.is_last_moving_lby_valid && record.velocity.Length2D() < 20 && fabs(UTILS::GetCurtime() - record.last_time_moving) < 1.0)
    {
        /// if lby updated
        if (record.lower_body_yaw != previous_record.lower_body_yaw)
        {
            record.last_moving_lby_delta = game::math.NormalizeYaw(record.last_moving_lby - record.lower_body_yaw);
            record.is_last_moving_lby_delta_valid = true;
        }
    }

    if (game::math.NormalizePitch(record.networked_angles.x) > 5.f)
        record.last_time_down_pitch = UTILS::GetCurtime();
}
float CResolver::ResolveYawOverride(IClientEntity* entity)
{
    auto local_player = game::localdata.localplayer();
    if (!local_player)
        return FLT_MAX;

    if (resolverconfig.bResolverOverride && GetAsyncKeyState(resolverconfig.iResolverOverrideKey)) {
        return FLT_MAX;

        Vector viewangles;
        m_pEngine->GetViewAngles(viewangles);

        const float at_target_yaw = game::math.CalcAnglevector(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
        if (fabs(game::math.NormalizeYaw(viewangles.y - at_target_yaw)) > 10.f)
            return FLT_MAX;

        return game::math.GetLBYRotatedYaw(entity->GetLowerBodyYaw(), (game::math.NormalizeYaw(viewangles.y - at_target_yaw) > 0) ? at_target_yaw + 90.f : at_target_yaw - 90.f);
    }
}
bool CResolver::IsYawSideways(IClientEntity* entity, float yaw)
{
    auto local_player = game::localdata.localplayer();
    if (!local_player)
        return false;

    const auto at_target_yaw = game::math.CalcAnglevector(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
    const float delta = fabs(game::math.NormalizeYaw(at_target_yaw - yaw));

    return delta > 20.f && delta < 160.f;
}
bool CResolver::AntiFreestanding(IClientEntity* entity, float& yaw)
{
    const auto freestanding_record = player_resolve_records[entity->GetIndex()].anti_freestanding_record;

    auto local_player = game::localdata.localplayer();
    if (!local_player)
        return false;

    if (freestanding_record.left_damage >= 20 && freestanding_record.right_damage >= 20)
        return false;

    const float at_target_yaw = game::math.CalcAnglevector(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
    if (freestanding_record.left_damage <= 0 && freestanding_record.right_damage <= 0)
    {
        if (freestanding_record.right_fraction < freestanding_record.left_fraction)
            yaw = at_target_yaw + 125.f;
        else
            yaw = at_target_yaw - 73.f;
    }
    else
    {
        if (freestanding_record.left_damage > freestanding_record.right_damage)
            yaw = at_target_yaw + 130.f;
        else
            yaw = at_target_yaw - 49.f;
    }

    return true;
}
void CResolver::ResolveYaw(IClientEntity* entity)
{
    auto& resolve_record = player_resolve_records[entity->GetIndex()];

    if (resolve_record.did_lby_flick)
    {
        resolve_record.resolved_angles.y = resolve_record.lower_body_yaw;
        resolve_record.resolve_type |= RESOLVE_TYPE_LBY_UPDATE;
    }
    else if (resolve_record.did_predicted_lby_flick)
    {
        resolve_record.resolved_angles.y = resolve_record.last_moving_lby + resolve_record.last_moving_lby_delta;
        resolve_record.resolve_type |= RESOLVE_TYPE_PREDICTED_LBY_UPDATE;
    }
    else
    {
        const float override_yaw = ResolveYawOverride(entity);
        if (override_yaw != FLT_MAX)
        {
            resolve_record.resolved_angles.y = override_yaw;
            resolve_record.resolve_type |= RESOLVE_TYPE_OVERRIDE;
        }
        else if (IsMovingOnGround(entity)) /// moving
        {
            resolve_record.resolved_angles.y = resolve_record.last_moving_lby;
            resolve_record.resolve_type |= RESOLVE_TYPE_LBY;
        }
        else if (resolve_record.is_last_moving_lby_valid && resolve_record.shots_missed_moving_lby < 1 && IsYawSideways(entity, resolve_record.last_moving_lby)) /// last moving lby if sideways prioritizes over antiurine
        {
            resolve_record.resolved_angles.y = resolve_record.last_moving_lby;
            resolve_record.resolve_type |= RESOLVE_TYPE_LAST_MOVING_LBY;
        }
        else if (AntiFreestanding(entity, resolve_record.resolved_angles.y))
        {
            resolve_record.resolve_type |= RESOLVE_TYPE_ANTI_FREESTANDING;
        }
        else if (resolve_record.is_last_moving_lby_valid && resolve_record.shots_missed_moving_lby < 1) /// last moving lby
        {
            resolve_record.resolved_angles.y = resolve_record.last_moving_lby;
            resolve_record.resolve_type |= RESOLVE_TYPE_LAST_MOVING_LBY;
        }
        else /// bruteforce as last resort
            ResolveYawBruteforce(entity);


    }

}
int CResolver::GetResolveTypeIndex(unsigned short resolve_type)
{
    /// gonna have to use lorge if statements cuz fuck you
    if (resolve_type & RESOLVE_TYPE_OVERRIDE)
        return 0;
    else if (resolve_type & RESOLVE_TYPE_NO_FAKE)
        return 1;
    else if (resolve_type & RESOLVE_TYPE_LBY)
        return 2;
    else if (resolve_type & RESOLVE_TYPE_LBY_UPDATE)
        return 3;
    else if (resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE)
        return 4;
    else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
        return 5;
    else if (resolve_type & RESOLVE_TYPE_NOT_BREAKING_LBY)
        return 6;
    else if (resolve_type & RESOLVE_TYPE_BRUTEFORCE)
        return 7;
    else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
        return 8;
    else if (resolve_type & RESOLVE_TYPE_ANTI_FREESTANDING)
        return 9;

    return 0;
}
void CResolver::ResolveYawBruteforce(IClientEntity* entity)
{
    auto local_player = game::localdata.localplayer();
    if (!local_player)
        return;

    auto& resolve_record = player_resolve_records[entity->GetIndex()];
    resolve_record.resolve_type |= RESOLVE_TYPE_BRUTEFORCE;

    const float at_target_yaw = game::math.CalcAnglevector(entity->GetVecOrigin(), local_player->GetVecOrigin()).y;

    const int shots_missed = resolve_record.shots_fired[GetResolveTypeIndex(resolve_record.resolve_type)] -
        resolve_record.shots_hit[GetResolveTypeIndex(resolve_record.resolve_type)];
    switch (shots_missed % 3)
    {
    case 0:
        resolve_record.resolved_angles.y = game::math.GetLBYRotatedYaw(entity->GetLowerBodyYaw(), at_target_yaw + 60.f);
        break;
    case 1:
        resolve_record.resolved_angles.y = at_target_yaw + 140.f;
        break;
    case 2:
        resolve_record.resolved_angles.y = at_target_yaw - 75.f;
        break;
    }
}
void CResolver::DoFSN()
{

    auto local_player = game::localdata.localplayer();
    if (!local_player || local_player->GetHealth() <= 0)
        return;

    for (int i = 0; i < m_pGlobals->maxClients; i++)
    {
        auto entity = m_pEntityList->GetClientEntity(i);
        if (!entity || entity->GetHealth() <= 0 || entity->GetTeamNum() == local_player->GetTeamNum() || !entity->IsAlive())
            continue;

        UpdateResolveRecord(entity);

        /// make sure to do dormant check AFTER calling UpdateResolveRecord()
        if (entity->IsDormant())
            continue;

        ResolveYaw(entity);
        ResolvePitch(entity);

        const auto resolve_record = player_resolve_records[i];
        entity->GetEyeAngles(resolve_record.resolved_angles);
    }
}





void CResolver::ResolvePitch(IClientEntity* entity)
{
    auto& resolve_record = player_resolve_records[entity->GetIndex()];

    if (resolve_record.resolve_type & RESOLVE_TYPE_LBY_UPDATE || resolve_record.resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE ||
        resolve_record.resolve_type & RESOLVE_TYPE_NO_FAKE)
        resolve_record.resolved_angles.x = resolve_record.networked_angles.x;
    else
    {
        /// super fucking ghetto fix to stop their pitch from going to 0 when they're shooting (only neccesary when they're using psilent)
        if (fabs(UTILS::GetCurtime() - resolve_record.last_time_down_pitch) < 0.5f)
            resolve_record.resolved_angles.x = 70.f;
        else
            resolve_record.resolved_angles.x = resolve_record.networked_angles.x;
    }

    resolve_record.resolved_angles.x = game::math.NormalizePitch(resolve_record.resolved_angles.x);
}

Vector old_calcangle(Vector dst, Vector src)
{
    Vector angles;

    double delta[3] = { (src.x - dst.x), (src.y - dst.y), (src.z - dst.z) };
    double hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);
    angles.x = (float)(atan(delta[2] / hyp) * 180.0 / 3.14159265);
    angles.y = (float)(atanf(delta[1] / delta[0]) * 57.295779513082f);
    angles.z = 0.0f;

    if (delta[0] >= 0.0)
    {
        angles.y += 180.0f;
    }

    return angles;
}

float old_normalize(float Yaw)
{
    if (Yaw > 180)
    {
        Yaw -= (round(Yaw / 360) * 360.f);
    }
    else if (Yaw < -180)
    {
        Yaw += (round(Yaw / 360) * -360.f);
    }
    return Yaw;
}

float curtime(CUserCmd* ucmd) {
    auto local_player = game::localdata.localplayer();

    if (!local_player)
        return 0;

    int g_tick = 0;
    CUserCmd* g_pLastCmd = nullptr;
    if (!g_pLastCmd || g_pLastCmd->hasbeenpredicted) {
        g_tick = (float)local_player->GetTickBase();
    }
    else {
        ++g_tick;
    }
    g_pLastCmd = ucmd;
    float curtime = g_tick * m_pGlobals->interval_per_tick;
    return curtime;
}

bool find_layer(IClientEntity* entity, int act, CAnimationLayer *set)
{
    for (int i = 0; i < 13; i++)
    {
        CAnimationLayer layer = entity->GetAnimOverlay(i);
        const int activity = entity->GetSequenceActivity(layer.m_nSequence);
        if (activity == act) {
            *set = layer;
            return true;
        }
    }
    return false;
}

void CResolver::record(IClientEntity* entity, float new_yaw)
{
    if (entity->GetVelocity().Length2D() > 36)
        return;
    auto local_player = game::localdata.localplayer();
    auto c_baseweapon = reinterpret_cast<CBaseAttributableItem*>(m_pEntityList->GetClientEntity(local_player->GetActiveWeaponIndex()));

    if (!c_baseweapon)
        return;

    auto &info = player_info[entity->GetIndex()];

    if (entity->GetActiveWeaponIndex() && info.last_ammo < c_baseweapon->GetLoadedAmmo())
    {
        //ignore the yaw when it is from shooting (will be looking at you/other player)
        info.last_ammo = c_baseweapon->GetLoadedAmmo();
        return;
    }

    info.unresolved_yaw.insert(info.unresolved_yaw.begin(), new_yaw);
    if (info.unresolved_yaw.size() > 20) {
        info.unresolved_yaw.pop_back();
    }

    if (info.unresolved_yaw.size() < 2)
        return;

    auto average_unresolved_yaw = 0;
    for (auto val : info.unresolved_yaw)
        average_unresolved_yaw += val;
    average_unresolved_yaw /= info.unresolved_yaw.size();

    int delta = average_unresolved_yaw - entity->GetLowerBodyYaw();
    auto big_math_delta = abs((((delta + 180) % 360 + 360) % 360 - 180));

    info.lby_deltas.insert(info.lby_deltas.begin(), big_math_delta);
    if (info.lby_deltas.size() > 10) {
        info.lby_deltas.pop_back();
    }
}


auto IsViable(IClientEntity * pPlayer) -> bool
{
    if (!pPlayer)
        return false;

    auto local_player = game::localdata.localplayer();

    if (!local_player)
        return false;

    if (pPlayer->IsDormant() || (pPlayer->GetHealth() <= 0) || pPlayer->GetFlags() & FL_FROZEN)
        return false;

    auto pWeapon = pPlayer->GetActiveWeaponIndex();

    if (!pWeapon)
        return false;

    if (pPlayer->GetTeamNum() == local_player->GetTeamNum())
        return false;

    return true;
}
#define TICK_INTERVAL            (ctx::globals->interval_per_tick)
int latest_tick;
#define TIME_TO_TICKS( dt )        ( (int)( 0.5f + (float)(dt) / TICK_INTERVAL ) )

bool IsTickValid(int tick) {
    int delta = latest_tick - tick;
    float deltaTime = delta * m_pGlobals->interval_per_tick;
    return (fabs(deltaTime) <= 0.1f);
}



void CResolver::resolve(IClientEntity* entity)
{

    auto local_player = game::localdata.localplayer();

    if (!entity)
        return;

    if (!local_player)
        return;

    bool is_local_player = entity == local_player;
    bool is_teammate = local_player->GetTeamNum() == entity->GetTeamNum() && !is_local_player;

    if (is_local_player)
        return;

    if (is_teammate)
        return;

    if (entity->GetHealth() <= 0)
        return;

    if (local_player->GetHealth() <= 0)
        return;
    DoFSN();
}

#pragma once

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

struct Info
{
    Info() {}

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

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


class CResolver
{
public:
    Info player_info[65];
    void DoFSN();
    void record(SDK::CBaseEntity * entity, float new_yaw);
    //    void NoSpreade(SDK::CBaseEntity * player, int entID);
    //    void override(SDK::CBaseEntity * entity);
    void Nospread1(SDK::CBaseEntity* player, int entID);
    //    void resolve1(SDK::CBaseEntity * entity);
    void Byeter(SDK::CBaseEntity * entity);
    void resolve(SDK::CBaseEntity* entity);

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

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

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

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

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

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

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

        Vector resolved_angles, networked_angles;
        Vector velocity, origin;

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

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

        bool is_dormant;
        bool is_last_moving_lby_valid;
        bool is_fakewalking;
        bool is_last_moving_lby_delta_valid;
        bool is_balance_adjust_triggered, is_balance_adjust_playing;
        bool did_lby_flick, did_predicted_lby_flick;
        bool has_fake;
    };

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

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

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

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

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

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

        return false;
    }

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

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

    bool IsYawSideways(SDK::CBaseEntity* entity, float yaw);
    bool IsFakingYaw(SDK::CBaseEntity* entity);

    /// pushback a record onto the shot snapshot queue
    void AddShotSnapshot(SDK::CBaseEntity* entity, PlayerResolveRecord resolve_record);

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

private:
    //    void ProcessSnapShots();

    void UpdateResolveRecord(SDK::CBaseEntity* entity);

    void ResolveYaw(SDK::CBaseEntity* entity);
    void bruteforce();
    void ResolvePitch(SDK::CBaseEntity* entity);

    void ResolveYawBruteforce(SDK::CBaseEntity* entity);
    float ResolveYawOverride(SDK::CBaseEntity* entity);
    bool AntiFreestanding(SDK::CBaseEntity* entity, float& yaw);

};

Без хайда т.к гавной ваняет за 1 км

 

[Remario]

от этого он лучше не станет ) хоть туда скит ресольвер впили