Нужен помощь с ресольвером

[sw4ppy]

крч спастил я значит антифристенд в пандору из вейв
и немогу сделать брутфорс под афристенд
кто может примерно код написать буду блогодарен
заранее спасибо
оставлю и код

    void Resolver::StoreAntifreestand(Player, int)
{
    if ( !g_cl.m_local->alive( ) )
        return;

    if ( !g_cl.m_weapon->GetWeapon() )
        return;

    int FreestandSide[ 64 ];

    for ( int i = 1; i < g_csgo.m_globals->m_max_clients; ++i )
    {
        auto player = ( Player* )g_csgo.m_entlist->GetClientEntity( i );

        if ( !player || !player->m_lifeState( ) == LIFE_ALIVE || player->dormant( ) || player->m_iTeamNum( ) == g_cl.m_local->m_iTeamNum( ) )
            continue;

        bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        auto idx = player->index( );
        float angToLocal = math::CalcAngle( g_cl.m_local->m_vecOrigin( ), player->m_vecOrigin( ) ).y;
        vec3_t ViewPoint = g_cl.m_local->m_vecOrigin( ) + vec3_t( 0, 0, 90 );
        vec2_t Side1 = { ( 45 * sin( math::deg_to_rad( angToLocal ) ) ),( 45 * cos( math::deg_to_rad( angToLocal ) ) ) };
        vec2_t Side2 = { ( 45 * sin( math::deg_to_rad( angToLocal + 180 ) ) ) ,( 45 * cos( math::deg_to_rad( angToLocal + 180 ) ) ) };

        vec2_t Side3 = { ( 50 * sin( math::deg_to_rad( angToLocal ) ) ),( 50 * cos( math::deg_to_rad( angToLocal ) ) ) };
        vec2_t Side4 = { ( 50 * sin( math::deg_to_rad( angToLocal + 180 ) ) ) ,( 50 * cos( math::deg_to_rad( angToLocal + 180 ) ) ) };

        vec3_t Origin = player->m_vecOrigin( );

        vec2_t OriginLeftRight[ ] = { vec2_t( Side1.x, Side1.y ), vec2_t( Side2.x, Side2.y ) };

        vec2_t OriginLeftRightLocal[ ] = { vec2_t( Side3.x, Side3.y ), vec2_t( Side4.x, Side4.y ) };

        float niggaangle = GetAngle( player );

        for ( int side = 0; side < 2; side++ )
        {
            vec3_t OriginAutowall = { Origin.x + OriginLeftRight[ side ].x,  Origin.y - OriginLeftRight[ side ].y , Origin.z + 90 };
            vec3_t ViewPointAutowall = { ViewPoint.x + OriginLeftRightLocal[ side ].x,  ViewPoint.y - OriginLeftRightLocal[ side ].y , ViewPoint.z };

            if ( penetration::CanHitFloatingPoint( OriginAutowall, ViewPoint ) )
            {
                if ( niggaangle >= 45.f || niggaangle <= -45.f )
                {
                    if ( side == 0 )
                    {
                        HitSide1 = true;
                        FreestandSide[ idx ] = -1;
                    }
                    else if ( side == 1 )
                    {
                        HitSide2 = true;
                        FreestandSide[ idx ] = 1;
                    }

                    Autowalled = true;
                }
                else
                {
                    for ( int sidealternative = 0; sidealternative < 2; sidealternative++ )
                    {
                        vec3_t ViewPointAutowallalternative = { Origin.x + OriginLeftRight[ sidealternative ].x,  Origin.y - OriginLeftRight[ sidealternative ].y , Origin.z + 90 };

                        if ( penetration::CanHitFloatingPoint( ViewPointAutowallalternative, ViewPointAutowall ) )
                        {
                            if ( niggaangle >= 45.f )
                            {
                                if ( sidealternative == 0 )
                                {
                                    HitSide1 = true;
                                    FreestandSide[ idx ] = -1;
                                }
                                else if ( sidealternative == 1 )
                                {
                                    HitSide2 = true;
                                    FreestandSide[ idx ] = 1;
                                }

                                Autowalled = true;
                            }
                        }
                    }
                }
            }
        }
    }
}
void Resolver::ResolveStand(AimPlayer* idx, LagComp::LagRecord_t* record) {
    // get the players max rotation.
    float max_rotation = record->m_pEntity->GetMaxBodyRotation();

    // setup a starting brute angle.
    float resolve_value = 50.f;

    if (!record->m_pState)
        return;

    const auto info = g_anims.GetAnimationInfo(record->m_pEntity);
    if (!info)
        return;

    float eye_yaw = record->m_pState->m_flEyeYaw;

    // clamp our starting brute angle, to not brute an angle, we most likely can't hit.
    if (max_rotation < resolve_value)
        resolve_value = max_rotation;

    // detect if player is using maximum desync.
    idx->m_extending = record->m_pLayers[3].m_cycle == 0.f && record->m_pLayers[3].m_weight == 0.f;

    if (idx->m_extending)
        resolve_value = max_rotation;

    // resolve shooting players separately.
    if (record->m_bDidShot)
        info->m_flBrute = Resolver::ResolveShot(idx, record);

    // bruteforce player accordingly.
    else {
        float lbyt = record->m_pEntity->m_flLowerBodyYawTarget();
        idx->m_delta = std::abs(math::NormalizedAngle(eye_yaw - lbyt));

        float resolve_yaw = ((idx->m_delta < 0.f) ? resolve_value : resolve_value);

        switch (idx->m_missed_shots % 3) {
        case 0:
            info->m_flBrute = idx->m_last_resolve = resolve_yaw;
            break;
        case 1:
            info->m_flBrute = -idx->m_last_resolve;
            break;
        case 2:
            info->m_flBrute = 0;
            break;
        }
    }

    record->m_pState->m_flGoalFeetYaw = eye_yaw + info->m_flBrute;
}

float Resolver::ResolveShot( AimPlayer* data, LagComp::LagRecord_t* record ) {
    float flPseudoFireYaw = math::NormalizedAngle( math::CalcAngle( record->m_pMatrix[ 8 ].GetOrigin( ), g_cl.m_local->m_BoneCache( ).m_pCachedBones[ 0 ].GetOrigin( ) ).y );

    if ( data->m_extending ) {
        float flLeftFireYawDelta = fabsf( math::NormalizedAngle( flPseudoFireYaw - ( record->m_angEyeAngles.y + 58.f ) ) );
        float flRightFireYawDelta = fabsf( math::NormalizedAngle( flPseudoFireYaw - ( record->m_angEyeAngles.y - 58.f ) ) );


        return flLeftFireYawDelta > flRightFireYawDelta ? -58.f : 58.f;
    }
    else {
        float flLeftFireYawDelta = fabsf( math::NormalizedAngle( flPseudoFireYaw - ( record->m_angEyeAngles.y + 29.f ) ) );
        float flRightFireYawDelta = fabsf( math::NormalizedAngle( flPseudoFireYaw - ( record->m_angEyeAngles.y - 29.f ) ) );


        return flLeftFireYawDelta > flRightFireYawDelta ? -29.f :+29.f;
    }
}

class ShotRecord;

struct resolverInfo_t {
    resolverInfo_t( ) = default;

    struct missInfo_t {
        missInfo_t( ) {
            this->m_freestand = 0;
            this->m_first_shot = 0;
            this->m_static = 0;
            this->m_jitter = 0;
        }

        int m_freestand;
        int m_first_shot;
        int m_static;
        int m_jitter;
    };

    struct hitInfo_t {
        hitInfo_t( ) {
            this->m_freestand = 0;
            this->m_first_shot = 0;
            this->m_static = 0;
            this->m_jitter = 0;
        }

        int m_freestand;
        int m_first_shot;
        int m_static;
        int m_jitter;
    };

    bool m_jitter{};
    bool m_use_freestand{};

    missInfo_t m_misses{};
    hitInfo_t m_hits{};
};

class Resolver {
public:
    enum Modes : size_t {
        RESOLVE_NONE = 0,
        RESOLVE_MOVE,
        RESOLVE_STAND,
    };

public:


    void ResolveStand(AimPlayer* idx, LagComp::LagRecord_t* record);
    
    float ResolveShot(AimPlayer* data, LagComp::LagRecord_t* record );

public:
    std::array< vec3_t, 64 > m_impacts;
    void ResolveAngles( Player* player, LagComp::LagRecord_t* record );
    
    float GetAngle( Player* );
    float GetForwardYaw( Player* );
    float GetBackwardYaw( Player* );
    float GetLeftYaw( Player* );
    float GetRightYaw( Player* );
    bool TargetSide( Player* );
    
    void DetectSide( Player*, int*);
    void StoreAntifreestand(Player, int);
    bool DoesHaveJitter( Player* player, int* new_side );
    
};

extern Resolver g_resolver;