Вопрос Кто поможет Резик!

NlUser1337 · 18 Ноя 2025

кто даст резик норм для AirFlow

lolwhomeisme · 18 Ноя 2025

NlUser1337 написал(а):
кто даст резик норм для AirFlow

xanaxcoder · 18 Ноя 2025

NlUser1337 написал(а):
кто даст резик норм для AirFlow

2к25 уже через несколько недель 2к26 чуваки используют airflow

skoody · 19 Ноя 2025

бля дебил скит фри

maryblackfild · 19 Ноя 2025

какой же сленг у чуваков выше непонятный

Angelwingsov · 19 Ноя 2025

maryblackfild написал(а):
какой же сленг у чуваков выше непонятный

Где ты тут сленг увидел? Англицизмы максимум ("фри")

flairer · 19 Ноя 2025

C++:

inline vec3_t get_hitbox_pos( c_cs_player* player, matrix3x4_t* mat, int hitbox_id )
{
    if ( !player )
        return vec3_t( );

    auto hdr = HACKS->model_info->get_studio_model( player->get_model( ) );

    if ( !hdr )
        return vec3_t( );

    auto hitbox_set = hdr->hitbox_set( player->hitbox_set( ) );

    if ( !hitbox_set )
        return vec3_t( );

    auto hitbox = hitbox_set->hitbox( hitbox_id );

    if ( !hitbox )
        return vec3_t( );

    vec3_t min, max;

    math::vector_transform( hitbox->min, mat[ hitbox->bone ], min );
    math::vector_transform( hitbox->max, mat[ hitbox->bone ], max );

    return ( min + max ) * 0.5f;
}

inline float_t max_yaw_modifier( c_cs_player* enemy )
{
    auto animstate = enemy->animstate( );

    if ( !animstate )
        return 0.0f;

    auto speedfactor = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
    auto avg_speedfactor = ( animstate->speed_as_portion_of_walk_top_speed * -0.3f - 0.2f ) * speedfactor + 1.0f;

    auto duck_amount = animstate->anim_duck_amount;

    if ( duck_amount )
    {
        auto max_velocity = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
        auto duck_speed = duck_amount * max_velocity;

        avg_speedfactor += duck_speed * ( 0.5f - avg_speedfactor );
    }

    return animstate->get_max_rotation( ) * avg_speedfactor;
}

inline void prepare_side(c_cs_player* player, anim_record_t* current, anim_record_t* last)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || player->is_bot() || !g_cfg.rage.resolver)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto state = player->animstate();
    if (!state)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto hdr = player->get_studio_hdr();
    if (!hdr)
        return;

    if (current->choke < 2)
        info.add_legit_ticks();
    else
        info.add_fake_ticks();

    if (info.is_legit())
    {
        info.resolved = false;
        info.mode = XOR("no fake");
        return;
    }

    prepare_jitter(player, info, current);

    auto choked = abs( TIME_TO_TICKS( player->sim_time( ) - player->old_sim_time( ) ) - 1 );
    int playerint = player->index( );

    float new_body_yaw_pose = 0.0f;
    auto m_flCurrentFeetYaw = state->abs_yaw;
    auto m_flGoalFeetYaw = state->foot_lerp;
    auto m_flEyeYaw = state->eye_yaw;
    float flMaxYawModifier = max_yaw_modifier( player );
    float flMinYawModifier = state->get_min_rotation( );
    auto anglesy = math::normalize_yaw( player->eye_angles( ).y - state->abs_yaw );

    auto valid_lby = true;

    auto speed = player->velocity( ).length_2d( );

    float m_lby = player->lower_body_yaw( ) * 0.574f;

    auto player_stand = player->velocity( ).length_2d( );
    player_stand = 0.f;

    float m_flLastClientSideAnimationUpdateTimeDelta = 0.0f;
    auto trace = false;

    auto v54 = state->anim_duck_amount;
    auto v55 = ( ( ( ( *( float* )( ( uintptr_t )state + 0x11C ) ) * -0.30000001 ) - 0.19999999 ) * state->static_approach_speed ) + 1.0f;

    bool bWasMovingLastUpdate = false;
    bool bJustStartedMovingLastUpdate = false;

    auto unknown_velocity = *( float* )( uintptr_t( state ) + 0x2A4 );

    auto first_matrix = current->matrix_left.matrix;
    auto second_matrix = current->matrix_right.matrix;
    auto central_matrix = current->matrix_zero.matrix;
    auto leftPose = get_hitbox_pos( player, first_matrix, HITBOX_HEAD );
    auto rightPose = get_hitbox_pos( player, second_matrix, HITBOX_HEAD );
    auto centralPose = get_hitbox_pos( player, central_matrix, HITBOX_HEAD );

    auto fire_first = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, first_matrix ) );
    auto fire_second = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, second_matrix ) );
    auto fire_third = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, central_matrix ) );

    static const float resolve_list[ 3 ] = { 0.f, player->eye_angles( ).y + state->get_max_rotation( ), player->eye_angles( ).y - state->get_max_rotation( ) };

    int missed_player = player->index( );

    auto delta = math::angle_diff( state->abs_yaw, state->eye_yaw );

    int i = player->index( );
    c_animation_layers layers[ 13 ];
    c_animation_layers movelayers[ 3 ][ 13 ];
    memcpy( layers, player->animlayers( ), sizeof( c_animation_layers ) );

    if ( RAGEBOT->missed_shots[ i ] > 2 )
    {
        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
    }

    if ( player->flags( ).has( FL_ONGROUND ) )
    {
        if ( speed <= 1.f || current->layers[ 3 ].weight == layers[ 3 ].weight )
        {
            int m_side = 2 * ( m_lby > 0.f ) ? -1 : 1;
            state->abs_yaw = ( player->eye_angles( ).y + 58.f ) * m_side;
            if ( RAGEBOT->missed_shots[ i ] > 2 )
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
            }
        }
        else if ( speed > 1.f && ( !( current->layers[ 12 ].weight ) && ( current->layers[ 6 ].weight == layers[ 6 ].weight ) ) )
        {
            float delta_rotate_first = abs( layers[ 6 ].weight - movelayers[ 0 ][ 6 ].weight );
            float delta_rotate_second = abs( layers[ 6 ].weight - movelayers[ 2 ][ 6 ].weight );
            float delta_rotate_third = abs( layers[ 6 ].weight - movelayers[ 1 ][ 6 ].weight );

            if ( delta_rotate_first < delta_rotate_second || delta_rotate_second <= delta_rotate_third || delta_rotate_second )
            {
                if ( delta_rotate_first >= delta_rotate_third && delta_rotate_second > delta_rotate_third && !( delta_rotate_third ) )
                {
                    state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                    switch ( RAGEBOT->missed_shots[ i ] % 2 )
                    {
                        case 0:   
                            state->abs_yaw_last = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                            break;
                        case 1:
                            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                            break;
                        default:
                            break;
                    }
                }
            }
            else
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                switch ( RAGEBOT->missed_shots[ i ] % 2 )
                {
                    case 0:   
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                        break;
                    case 1:
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                        break;
                    default:
                    break;
                }
            }
        }
    }
}

inline void apply_side(c_cs_player* player, anim_record_t* current, int choke)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || !info.resolved || info.side == 1337 || player->is_teammate(false))
        return;

    auto state = player->animstate();
    if (!state)
        return;

    switch ( info.side )
    {
        case -1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
        }
        case 1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
        }
        case 0:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y );
        }
    }

}

xanaxcoder · 19 Ноя 2025

pineapplepizza22 написал(а):

C++:

inline vec3_t get_hitbox_pos( c_cs_player* player, matrix3x4_t* mat, int hitbox_id )
{
    if ( !player )
        return vec3_t( );

    auto hdr = HACKS->model_info->get_studio_model( player->get_model( ) );

    if ( !hdr )
        return vec3_t( );

    auto hitbox_set = hdr->hitbox_set( player->hitbox_set( ) );

    if ( !hitbox_set )
        return vec3_t( );

    auto hitbox = hitbox_set->hitbox( hitbox_id );

    if ( !hitbox )
        return vec3_t( );

    vec3_t min, max;

    math::vector_transform( hitbox->min, mat[ hitbox->bone ], min );
    math::vector_transform( hitbox->max, mat[ hitbox->bone ], max );

    return ( min + max ) * 0.5f;
}

inline float_t max_yaw_modifier( c_cs_player* enemy )
{
    auto animstate = enemy->animstate( );

    if ( !animstate )
        return 0.0f;

    auto speedfactor = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
    auto avg_speedfactor = ( animstate->speed_as_portion_of_walk_top_speed * -0.3f - 0.2f ) * speedfactor + 1.0f;

    auto duck_amount = animstate->anim_duck_amount;

    if ( duck_amount )
    {
        auto max_velocity = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
        auto duck_speed = duck_amount * max_velocity;

        avg_speedfactor += duck_speed * ( 0.5f - avg_speedfactor );
    }

    return animstate->get_max_rotation( ) * avg_speedfactor;
}

inline void prepare_side(c_cs_player* player, anim_record_t* current, anim_record_t* last)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || player->is_bot() || !g_cfg.rage.resolver)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto state = player->animstate();
    if (!state)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto hdr = player->get_studio_hdr();
    if (!hdr)
        return;

    if (current->choke < 2)
        info.add_legit_ticks();
    else
        info.add_fake_ticks();

    if (info.is_legit())
    {
        info.resolved = false;
        info.mode = XOR("no fake");
        return;
    }

    prepare_jitter(player, info, current);

    auto choked = abs( TIME_TO_TICKS( player->sim_time( ) - player->old_sim_time( ) ) - 1 );
    int playerint = player->index( );

    float new_body_yaw_pose = 0.0f;
    auto m_flCurrentFeetYaw = state->abs_yaw;
    auto m_flGoalFeetYaw = state->foot_lerp;
    auto m_flEyeYaw = state->eye_yaw;
    float flMaxYawModifier = max_yaw_modifier( player );
    float flMinYawModifier = state->get_min_rotation( );
    auto anglesy = math::normalize_yaw( player->eye_angles( ).y - state->abs_yaw );

    auto valid_lby = true;

    auto speed = player->velocity( ).length_2d( );

    float m_lby = player->lower_body_yaw( ) * 0.574f;

    auto player_stand = player->velocity( ).length_2d( );
    player_stand = 0.f;

    float m_flLastClientSideAnimationUpdateTimeDelta = 0.0f;
    auto trace = false;

    auto v54 = state->anim_duck_amount;
    auto v55 = ( ( ( ( *( float* )( ( uintptr_t )state + 0x11C ) ) * -0.30000001 ) - 0.19999999 ) * state->static_approach_speed ) + 1.0f;

    bool bWasMovingLastUpdate = false;
    bool bJustStartedMovingLastUpdate = false;

    auto unknown_velocity = *( float* )( uintptr_t( state ) + 0x2A4 );

    auto first_matrix = current->matrix_left.matrix;
    auto second_matrix = current->matrix_right.matrix;
    auto central_matrix = current->matrix_zero.matrix;
    auto leftPose = get_hitbox_pos( player, first_matrix, HITBOX_HEAD );
    auto rightPose = get_hitbox_pos( player, second_matrix, HITBOX_HEAD );
    auto centralPose = get_hitbox_pos( player, central_matrix, HITBOX_HEAD );

    auto fire_first = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, first_matrix ) );
    auto fire_second = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, second_matrix ) );
    auto fire_third = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, central_matrix ) );

    static const float resolve_list[ 3 ] = { 0.f, player->eye_angles( ).y + state->get_max_rotation( ), player->eye_angles( ).y - state->get_max_rotation( ) };

    int missed_player = player->index( );

    auto delta = math::angle_diff( state->abs_yaw, state->eye_yaw );

    int i = player->index( );
    c_animation_layers layers[ 13 ];
    c_animation_layers movelayers[ 3 ][ 13 ];
    memcpy( layers, player->animlayers( ), sizeof( c_animation_layers ) );

    if ( RAGEBOT->missed_shots[ i ] > 2 )
    {
        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
    }

    if ( player->flags( ).has( FL_ONGROUND ) )
    {
        if ( speed <= 1.f || current->layers[ 3 ].weight == layers[ 3 ].weight )
        {
            int m_side = 2 * ( m_lby > 0.f ) ? -1 : 1;
            state->abs_yaw = ( player->eye_angles( ).y + 58.f ) * m_side;
            if ( RAGEBOT->missed_shots[ i ] > 2 )
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
            }
        }
        else if ( speed > 1.f && ( !( current->layers[ 12 ].weight ) && ( current->layers[ 6 ].weight == layers[ 6 ].weight ) ) )
        {
            float delta_rotate_first = abs( layers[ 6 ].weight - movelayers[ 0 ][ 6 ].weight );
            float delta_rotate_second = abs( layers[ 6 ].weight - movelayers[ 2 ][ 6 ].weight );
            float delta_rotate_third = abs( layers[ 6 ].weight - movelayers[ 1 ][ 6 ].weight );

            if ( delta_rotate_first < delta_rotate_second || delta_rotate_second <= delta_rotate_third || delta_rotate_second )
            {
                if ( delta_rotate_first >= delta_rotate_third && delta_rotate_second > delta_rotate_third && !( delta_rotate_third ) )
                {
                    state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                    switch ( RAGEBOT->missed_shots[ i ] % 2 )
                    {
                        case 0:  
                            state->abs_yaw_last = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                            break;
                        case 1:
                            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                            break;
                        default:
                            break;
                    }
                }
            }
            else
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                switch ( RAGEBOT->missed_shots[ i ] % 2 )
                {
                    case 0:  
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                        break;
                    case 1:
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                        break;
                    default:
                    break;
                }
            }
        }
    }
}

inline void apply_side(c_cs_player* player, anim_record_t* current, int choke)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || !info.resolved || info.side == 1337 || player->is_teammate(false))
        return;

    auto state = player->animstate();
    if (!state)
        return;

    switch ( info.side )
    {
        case -1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
        }
        case 1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
        }
        case 0:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y );
        }
    }

}

какаха

phanetic · 28 Ноя 2025

flairer написал(а):

C++:

inline vec3_t get_hitbox_pos( c_cs_player* player, matrix3x4_t* mat, int hitbox_id )
{
    if ( !player )
        return vec3_t( );

    auto hdr = HACKS->model_info->get_studio_model( player->get_model( ) );

    if ( !hdr )
        return vec3_t( );

    auto hitbox_set = hdr->hitbox_set( player->hitbox_set( ) );

    if ( !hitbox_set )
        return vec3_t( );

    auto hitbox = hitbox_set->hitbox( hitbox_id );

    if ( !hitbox )
        return vec3_t( );

    vec3_t min, max;

    math::vector_transform( hitbox->min, mat[ hitbox->bone ], min );
    math::vector_transform( hitbox->max, mat[ hitbox->bone ], max );

    return ( min + max ) * 0.5f;
}

inline float_t max_yaw_modifier( c_cs_player* enemy )
{
    auto animstate = enemy->animstate( );

    if ( !animstate )
        return 0.0f;

    auto speedfactor = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
    auto avg_speedfactor = ( animstate->speed_as_portion_of_walk_top_speed * -0.3f - 0.2f ) * speedfactor + 1.0f;

    auto duck_amount = animstate->anim_duck_amount;

    if ( duck_amount )
    {
        auto max_velocity = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
        auto duck_speed = duck_amount * max_velocity;

        avg_speedfactor += duck_speed * ( 0.5f - avg_speedfactor );
    }

    return animstate->get_max_rotation( ) * avg_speedfactor;
}

inline void prepare_side(c_cs_player* player, anim_record_t* current, anim_record_t* last)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || player->is_bot() || !g_cfg.rage.resolver)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto state = player->animstate();
    if (!state)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto hdr = player->get_studio_hdr();
    if (!hdr)
        return;

    if (current->choke < 2)
        info.add_legit_ticks();
    else
        info.add_fake_ticks();

    if (info.is_legit())
    {
        info.resolved = false;
        info.mode = XOR("no fake");
        return;
    }

    prepare_jitter(player, info, current);

    auto choked = abs( TIME_TO_TICKS( player->sim_time( ) - player->old_sim_time( ) ) - 1 );
    int playerint = player->index( );

    float new_body_yaw_pose = 0.0f;
    auto m_flCurrentFeetYaw = state->abs_yaw;
    auto m_flGoalFeetYaw = state->foot_lerp;
    auto m_flEyeYaw = state->eye_yaw;
    float flMaxYawModifier = max_yaw_modifier( player );
    float flMinYawModifier = state->get_min_rotation( );
    auto anglesy = math::normalize_yaw( player->eye_angles( ).y - state->abs_yaw );

    auto valid_lby = true;

    auto speed = player->velocity( ).length_2d( );

    float m_lby = player->lower_body_yaw( ) * 0.574f;

    auto player_stand = player->velocity( ).length_2d( );
    player_stand = 0.f;

    float m_flLastClientSideAnimationUpdateTimeDelta = 0.0f;
    auto trace = false;

    auto v54 = state->anim_duck_amount;
    auto v55 = ( ( ( ( *( float* )( ( uintptr_t )state + 0x11C ) ) * -0.30000001 ) - 0.19999999 ) * state->static_approach_speed ) + 1.0f;

    bool bWasMovingLastUpdate = false;
    bool bJustStartedMovingLastUpdate = false;

    auto unknown_velocity = *( float* )( uintptr_t( state ) + 0x2A4 );

    auto first_matrix = current->matrix_left.matrix;
    auto second_matrix = current->matrix_right.matrix;
    auto central_matrix = current->matrix_zero.matrix;
    auto leftPose = get_hitbox_pos( player, first_matrix, HITBOX_HEAD );
    auto rightPose = get_hitbox_pos( player, second_matrix, HITBOX_HEAD );
    auto centralPose = get_hitbox_pos( player, central_matrix, HITBOX_HEAD );

    auto fire_first = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, first_matrix ) );
    auto fire_second = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, second_matrix ) );
    auto fire_third = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, central_matrix ) );

    static const float resolve_list[ 3 ] = { 0.f, player->eye_angles( ).y + state->get_max_rotation( ), player->eye_angles( ).y - state->get_max_rotation( ) };

    int missed_player = player->index( );

    auto delta = math::angle_diff( state->abs_yaw, state->eye_yaw );

    int i = player->index( );
    c_animation_layers layers[ 13 ];
    c_animation_layers movelayers[ 3 ][ 13 ];
    memcpy( layers, player->animlayers( ), sizeof( c_animation_layers ) );

    if ( RAGEBOT->missed_shots[ i ] > 2 )
    {
        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
    }

    if ( player->flags( ).has( FL_ONGROUND ) )
    {
        if ( speed <= 1.f || current->layers[ 3 ].weight == layers[ 3 ].weight )
        {
            int m_side = 2 * ( m_lby > 0.f ) ? -1 : 1;
            state->abs_yaw = ( player->eye_angles( ).y + 58.f ) * m_side;
            if ( RAGEBOT->missed_shots[ i ] > 2 )
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
            }
        }
        else if ( speed > 1.f && ( !( current->layers[ 12 ].weight ) && ( current->layers[ 6 ].weight == layers[ 6 ].weight ) ) )
        {
            float delta_rotate_first = abs( layers[ 6 ].weight - movelayers[ 0 ][ 6 ].weight );
            float delta_rotate_second = abs( layers[ 6 ].weight - movelayers[ 2 ][ 6 ].weight );
            float delta_rotate_third = abs( layers[ 6 ].weight - movelayers[ 1 ][ 6 ].weight );

            if ( delta_rotate_first < delta_rotate_second || delta_rotate_second <= delta_rotate_third || delta_rotate_second )
            {
                if ( delta_rotate_first >= delta_rotate_third && delta_rotate_second > delta_rotate_third && !( delta_rotate_third ) )
                {
                    state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                    switch ( RAGEBOT->missed_shots[ i ] % 2 )
                    {
                        case 0:  
                            state->abs_yaw_last = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                            break;
                        case 1:
                            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                            break;
                        default:
                            break;
                    }
                }
            }
            else
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                switch ( RAGEBOT->missed_shots[ i ] % 2 )
                {
                    case 0:  
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                        break;
                    case 1:
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                        break;
                    default:
                    break;
                }
            }
        }
    }
}

inline void apply_side(c_cs_player* player, anim_record_t* current, int choke)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || !info.resolved || info.side == 1337 || player->is_teammate(false))
        return;

    auto state = player->animstate();
    if (!state)
        return;

    switch ( info.side )
    {
        case -1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
        }
        case 1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
        }
        case 0:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y );
        }
    }

}

а че не весь math.cpp в резике нахуй мелочиться то

Hack3r_jopi · 28 Ноя 2025

flairer написал(а):

C++:

inline vec3_t get_hitbox_pos( c_cs_player* player, matrix3x4_t* mat, int hitbox_id )
{
    if ( !player )
        return vec3_t( );

    auto hdr = HACKS->model_info->get_studio_model( player->get_model( ) );

    if ( !hdr )
        return vec3_t( );

    auto hitbox_set = hdr->hitbox_set( player->hitbox_set( ) );

    if ( !hitbox_set )
        return vec3_t( );

    auto hitbox = hitbox_set->hitbox( hitbox_id );

    if ( !hitbox )
        return vec3_t( );

    vec3_t min, max;

    math::vector_transform( hitbox->min, mat[ hitbox->bone ], min );
    math::vector_transform( hitbox->max, mat[ hitbox->bone ], max );

    return ( min + max ) * 0.5f;
}

inline float_t max_yaw_modifier( c_cs_player* enemy )
{
    auto animstate = enemy->animstate( );

    if ( !animstate )
        return 0.0f;

    auto speedfactor = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
    auto avg_speedfactor = ( animstate->speed_as_portion_of_walk_top_speed * -0.3f - 0.2f ) * speedfactor + 1.0f;

    auto duck_amount = animstate->anim_duck_amount;

    if ( duck_amount )
    {
        auto max_velocity = std::clamp( animstate->speed_as_portion_of_run_top_speed, 0.0f, 1.0f );
        auto duck_speed = duck_amount * max_velocity;

        avg_speedfactor += duck_speed * ( 0.5f - avg_speedfactor );
    }

    return animstate->get_max_rotation( ) * avg_speedfactor;
}

inline void prepare_side(c_cs_player* player, anim_record_t* current, anim_record_t* last)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || player->is_bot() || !g_cfg.rage.resolver)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto state = player->animstate();
    if (!state)
    {
        if (info.resolved)
            info.reset();

        return;
    }

    auto hdr = player->get_studio_hdr();
    if (!hdr)
        return;

    if (current->choke < 2)
        info.add_legit_ticks();
    else
        info.add_fake_ticks();

    if (info.is_legit())
    {
        info.resolved = false;
        info.mode = XOR("no fake");
        return;
    }

    prepare_jitter(player, info, current);

    auto choked = abs( TIME_TO_TICKS( player->sim_time( ) - player->old_sim_time( ) ) - 1 );
    int playerint = player->index( );

    float new_body_yaw_pose = 0.0f;
    auto m_flCurrentFeetYaw = state->abs_yaw;
    auto m_flGoalFeetYaw = state->foot_lerp;
    auto m_flEyeYaw = state->eye_yaw;
    float flMaxYawModifier = max_yaw_modifier( player );
    float flMinYawModifier = state->get_min_rotation( );
    auto anglesy = math::normalize_yaw( player->eye_angles( ).y - state->abs_yaw );

    auto valid_lby = true;

    auto speed = player->velocity( ).length_2d( );

    float m_lby = player->lower_body_yaw( ) * 0.574f;

    auto player_stand = player->velocity( ).length_2d( );
    player_stand = 0.f;

    float m_flLastClientSideAnimationUpdateTimeDelta = 0.0f;
    auto trace = false;

    auto v54 = state->anim_duck_amount;
    auto v55 = ( ( ( ( *( float* )( ( uintptr_t )state + 0x11C ) ) * -0.30000001 ) - 0.19999999 ) * state->static_approach_speed ) + 1.0f;

    bool bWasMovingLastUpdate = false;
    bool bJustStartedMovingLastUpdate = false;

    auto unknown_velocity = *( float* )( uintptr_t( state ) + 0x2A4 );

    auto first_matrix = current->matrix_left.matrix;
    auto second_matrix = current->matrix_right.matrix;
    auto central_matrix = current->matrix_zero.matrix;
    auto leftPose = get_hitbox_pos( player, first_matrix, HITBOX_HEAD );
    auto rightPose = get_hitbox_pos( player, second_matrix, HITBOX_HEAD );
    auto centralPose = get_hitbox_pos( player, central_matrix, HITBOX_HEAD );

    auto fire_first = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, first_matrix ) );
    auto fire_second = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, second_matrix ) );
    auto fire_third = penetration::simulate( HACKS->local, player, HACKS->local->get_eye_position( ), player->get_hitbox_position( HITBOX_HEAD, central_matrix ) );

    static const float resolve_list[ 3 ] = { 0.f, player->eye_angles( ).y + state->get_max_rotation( ), player->eye_angles( ).y - state->get_max_rotation( ) };

    int missed_player = player->index( );

    auto delta = math::angle_diff( state->abs_yaw, state->eye_yaw );

    int i = player->index( );
    c_animation_layers layers[ 13 ];
    c_animation_layers movelayers[ 3 ][ 13 ];
    memcpy( layers, player->animlayers( ), sizeof( c_animation_layers ) );

    if ( RAGEBOT->missed_shots[ i ] > 2 )
    {
        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
    }

    if ( player->flags( ).has( FL_ONGROUND ) )
    {
        if ( speed <= 1.f || current->layers[ 3 ].weight == layers[ 3 ].weight )
        {
            int m_side = 2 * ( m_lby > 0.f ) ? -1 : 1;
            state->abs_yaw = ( player->eye_angles( ).y + 58.f ) * m_side;
            if ( RAGEBOT->missed_shots[ i ] > 2 )
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
            }
        }
        else if ( speed > 1.f && ( !( current->layers[ 12 ].weight ) && ( current->layers[ 6 ].weight == layers[ 6 ].weight ) ) )
        {
            float delta_rotate_first = abs( layers[ 6 ].weight - movelayers[ 0 ][ 6 ].weight );
            float delta_rotate_second = abs( layers[ 6 ].weight - movelayers[ 2 ][ 6 ].weight );
            float delta_rotate_third = abs( layers[ 6 ].weight - movelayers[ 1 ][ 6 ].weight );

            if ( delta_rotate_first < delta_rotate_second || delta_rotate_second <= delta_rotate_third || delta_rotate_second )
            {
                if ( delta_rotate_first >= delta_rotate_third && delta_rotate_second > delta_rotate_third && !( delta_rotate_third ) )
                {
                    state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                    switch ( RAGEBOT->missed_shots[ i ] % 2 )
                    {
                        case 0: 
                            state->abs_yaw_last = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                            break;
                        case 1:
                            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                            break;
                        default:
                            break;
                    }
                }
            }
            else
            {
                state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
                switch ( RAGEBOT->missed_shots[ i ] % 2 )
                {
                    case 0: 
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
                        break;
                    case 1:
                        state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + resolve_list[ RAGEBOT->missed_shots[ i ] % 3 ] );
                        break;
                    default:
                    break;
                }
            }
        }
    }
}

inline void apply_side(c_cs_player* player, anim_record_t* current, int choke)
{
    auto& info = resolver_info[player->index()];
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || !info.resolved || info.side == 1337 || player->is_teammate(false))
        return;

    auto state = player->animstate();
    if (!state)
        return;

    switch ( info.side )
    {
        case -1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y - state->get_max_rotation( ) );
        }
        case 1:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y + state->get_max_rotation( ) );
        }
        case 0:
        {
            state->abs_yaw = math::normalize_yaw( player->eye_angles( ).y );
        }
    }

}

ебать тебе грусно мужик что ресольвер на стендах не работает на челов у которых есть десинк... (подсказка: если человечек использует в целом десинк, на стендах необходим микромув 1.01 в даке 3.25 помоему, и именно по этой причине его ебливый чек простой единички это фейл + чек с леерами где по итогу за 32 рекорда они никогда не будут равны друг другу тк каждый тик у чувачка микромув и его сайдмув/форвардмув все время ебланятся -1.01 / 1.01).

flairer · 29 Ноя 2025

Hack3r_jopi написал(а):
Посмотреть вложение 320991
ебать тебе грусно мужик что ресольвер на стендах не работает на челов у которых есть десинк... (подсказка: если человечек использует в целом десинк, на стендах необходим микромув 1.01 в даке 3.25 помоему, и именно по этой причине его ебливый чек простой единички это фейл + чек с леерами где по итогу за 32 рекорда они никогда не будут равны друг другу тк каждый тик у чувачка микромув и его сайдмув/форвардмув все время ебланятся -1.01 / 1.01).

if you really thought that id post an actual resolver, you must be out of your mind.

Beady · 29 Ноя 2025

NlUser1337 написал(а):
кто даст резик норм для AirFlow

bla bla idk what hte heck is this:

#include <algorithm>
#include <vector>
#include <cmath>

enum ResolverMode {
    R_NONE = 0,
    R_MOVE,
    R_LBY_UPD,
    R_FREESTAND,
    R_BRUTE
};

struct ResolverData {
    int missed_shots = 0;
    float last_moving_lby = 0.f;
    bool has_stopped_recently = false;
    ResolverMode mode = R_NONE;
    int side = 0;
    
    void reset() {
        missed_shots = 0;
        last_moving_lby = 0.f;
        has_stopped_recently = false;
        mode = R_NONE;
        side = 0;
    }
} resolver_data[65];

inline float angle_diff(float destAngle, float srcAngle) {
    float delta = fmod(destAngle - srcAngle, 360.0f);
    if (destAngle > srcAngle) {
        if (delta >= 180) delta -= 360;
    } else {
        if (delta <= -180) delta += 360;
    }
    return delta;
}

inline vec3_t get_hitbox_pos(c_cs_player* player, matrix3x4_t* mat, int hitbox_id)
{
    if (!player || !mat) return vec3_t();

    const auto model = player->get_model();
    if (!model) return vec3_t();

    const auto hdr = HACKS->model_info->get_studio_model(model);
    if (!hdr) return vec3_t();

    const auto hitbox_set = hdr->hitbox_set(player->hitbox_set());
    if (!hitbox_set) return vec3_t();

    const auto hitbox = hitbox_set->hitbox(hitbox_id);
    if (!hitbox) return vec3_t();

    vec3_t min, max;
    math::vector_transform(hitbox->min, mat[hitbox->bone], min);
    math::vector_transform(hitbox->max, mat[hitbox->bone], max);

    return (min + max) * 0.5f;
}

inline float get_max_desync_delta(c_cs_player* player) {
    auto state = player->animstate();
    if (!state) return 0.f;

    float speedfactor = std::clamp(state->speed_as_portion_of_run_top_speed, 0.f, 1.f);
    float avg_speedfactor = (state->speed_as_portion_of_walk_top_speed * -0.3f - 0.2f) * speedfactor + 1.f;
    
    float duck = state->anim_duck_amount;
    if (duck > 0.f) {
        float max_vel = std::clamp(state->speed_as_portion_of_run_top_speed, 0.f, 1.f);
        float duck_speed = duck * max_vel;
        avg_speedfactor += duck_speed * (0.5f - avg_speedfactor);
    }
    
    return state->get_max_rotation() * avg_speedfactor;
}

int detect_freestanding(c_cs_player* enemy) {
    if (!HACKS->local) return 0;

    vec3_t src = enemy->get_origin() + vec3_t(0, 0, 50);
    vec3_t local_eye = HACKS->local->get_eye_position();

    float at_target = math::calculate_angle(src, local_eye).y;
    
    vec3_t left_pos, right_pos;
    math::angle_vectors(vec3_t(0, at_target - 90.f, 0), left_pos);
    math::angle_vectors(vec3_t(0, at_target + 90.f, 0), right_pos);

    left_pos = src + (left_pos * 40.f);
    right_pos = src + (right_pos * 40.f);

    float left_dmg = penetration::simulate(HACKS->local, enemy, local_eye, left_pos);
    float right_dmg = penetration::simulate(HACKS->local, enemy, local_eye, right_pos);

    if (left_dmg > right_dmg) return 1;
    if (right_dmg > left_dmg) return -1;

    return 0;
}

void on_missed_shot(int entity_index) {
    if (entity_index >= 0 && entity_index < 65)
        resolver_data[entity_index].missed_shots++;
}

inline void prepare_side(c_cs_player* player, anim_record_t* current, anim_record_t* last)
{
    int idx = player->index();
    auto& res_info = resolver_data[idx];
    
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || !g_cfg.rage.resolver || player->is_bot() || player->is_teammate(false)) {
        res_info.reset();
        return;
    }

    auto state = player->animstate();
    if (!state) return;

    if (player->spawn_time() != current->sim_time) {
        
    }

    float speed_2d = player->velocity().length_2d();
    bool on_ground = player->flags().has(FL_ONGROUND);
    float max_desync = get_max_desync_delta(player);

    if (speed_2d > 1.1f && on_ground)
    {
        res_info.mode = R_MOVE;
        res_info.side = 0;
        res_info.last_moving_lby = player->lower_body_yaw();
        res_info.has_stopped_recently = false;
        
        state->abs_yaw = player->lower_body_yaw();
        
        if (state->time_since_stopped_moving < 0.22f)
            res_info.missed_shots = 0;
    }
    else
    {
        if (!res_info.has_stopped_recently && speed_2d < 1.0f) {
            res_info.has_stopped_recently = true;
        }

        int side_resolv = 0;
        
        float lby_delta = angle_diff(player->lower_body_yaw(), res_info.last_moving_lby);
        if (abs(lby_delta) < 35.0f && res_info.missed_shots == 0) {
             res_info.mode = R_LBY_UPD;
             res_info.side = 0;
             state->abs_yaw = res_info.last_moving_lby;
             return;
        }

        if (res_info.missed_shots <= 1) {
             int wall_side = detect_freestanding(player);
             if (wall_side != 0) {
                 res_info.mode = R_FREESTAND;
                 res_info.side = wall_side;
                 state->abs_yaw = math::normalize_yaw(player->eye_angles().y + (max_desync * wall_side));
                 return;
             }
        }

        res_info.mode = R_BRUTE;
        
        switch (res_info.missed_shots % 3) {
            case 0:
                side_resolv = 1;
                break;
            case 1:
                side_resolv = -1;
                break;
            case 2:
                side_resolv = 0;
                break;
        }

        res_info.side = side_resolv;
        
        if (side_resolv == 0)
             state->abs_yaw = player->eye_angles().y;
        else
             state->abs_yaw = math::normalize_yaw(player->eye_angles().y + (max_desync * side_resolv));
    }
}

inline void apply_side(c_cs_player* player, anim_record_t* current, int choke)
{
    int idx = player->index();
    auto& res_info = resolver_data[idx];

    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || res_info.side == 1337 || player->is_teammate(false))
        return;

    auto state = player->animstate();
    if (!state) return;
    
    float max_desync = get_max_desync_delta(player);

    switch (res_info.side)
    {
        case -1:
            state->abs_yaw = math::normalize_yaw(player->eye_angles().y - max_desync);
            break;
        case 1:
            state->abs_yaw = math::normalize_yaw(player->eye_angles().y + max_desync);
            break;
        case 0:
            state->abs_yaw = math::normalize_yaw(player->eye_angles().y);
            break;
    }
}

flairer · 29 Ноя 2025

Beady написал(а):

bla bla idk what hte heck is this:

#include <algorithm>
#include <vector>
#include <cmath>

enum ResolverMode {
    R_NONE = 0,
    R_MOVE,
    R_LBY_UPD,
    R_FREESTAND,
    R_BRUTE
};

struct ResolverData {
    int missed_shots = 0;
    float last_moving_lby = 0.f;
    bool has_stopped_recently = false;
    ResolverMode mode = R_NONE;
    int side = 0;
   
    void reset() {
        missed_shots = 0;
        last_moving_lby = 0.f;
        has_stopped_recently = false;
        mode = R_NONE;
        side = 0;
    }
} resolver_data[65];

inline float angle_diff(float destAngle, float srcAngle) {
    float delta = fmod(destAngle - srcAngle, 360.0f);
    if (destAngle > srcAngle) {
        if (delta >= 180) delta -= 360;
    } else {
        if (delta <= -180) delta += 360;
    }
    return delta;
}

inline vec3_t get_hitbox_pos(c_cs_player* player, matrix3x4_t* mat, int hitbox_id)
{
    if (!player || !mat) return vec3_t();

    const auto model = player->get_model();
    if (!model) return vec3_t();

    const auto hdr = HACKS->model_info->get_studio_model(model);
    if (!hdr) return vec3_t();

    const auto hitbox_set = hdr->hitbox_set(player->hitbox_set());
    if (!hitbox_set) return vec3_t();

    const auto hitbox = hitbox_set->hitbox(hitbox_id);
    if (!hitbox) return vec3_t();

    vec3_t min, max;
    math::vector_transform(hitbox->min, mat[hitbox->bone], min);
    math::vector_transform(hitbox->max, mat[hitbox->bone], max);

    return (min + max) * 0.5f;
}

inline float get_max_desync_delta(c_cs_player* player) {
    auto state = player->animstate();
    if (!state) return 0.f;

    float speedfactor = std::clamp(state->speed_as_portion_of_run_top_speed, 0.f, 1.f);
    float avg_speedfactor = (state->speed_as_portion_of_walk_top_speed * -0.3f - 0.2f) * speedfactor + 1.f;
   
    float duck = state->anim_duck_amount;
    if (duck > 0.f) {
        float max_vel = std::clamp(state->speed_as_portion_of_run_top_speed, 0.f, 1.f);
        float duck_speed = duck * max_vel;
        avg_speedfactor += duck_speed * (0.5f - avg_speedfactor);
    }
   
    return state->get_max_rotation() * avg_speedfactor;
}

int detect_freestanding(c_cs_player* enemy) {
    if (!HACKS->local) return 0;

    vec3_t src = enemy->get_origin() + vec3_t(0, 0, 50);
    vec3_t local_eye = HACKS->local->get_eye_position();

    float at_target = math::calculate_angle(src, local_eye).y;
   
    vec3_t left_pos, right_pos;
    math::angle_vectors(vec3_t(0, at_target - 90.f, 0), left_pos);
    math::angle_vectors(vec3_t(0, at_target + 90.f, 0), right_pos);

    left_pos = src + (left_pos * 40.f);
    right_pos = src + (right_pos * 40.f);

    float left_dmg = penetration::simulate(HACKS->local, enemy, local_eye, left_pos);
    float right_dmg = penetration::simulate(HACKS->local, enemy, local_eye, right_pos);

    if (left_dmg > right_dmg) return 1;
    if (right_dmg > left_dmg) return -1;

    return 0;
}

void on_missed_shot(int entity_index) {
    if (entity_index >= 0 && entity_index < 65)
        resolver_data[entity_index].missed_shots++;
}

inline void prepare_side(c_cs_player* player, anim_record_t* current, anim_record_t* last)
{
    int idx = player->index();
    auto& res_info = resolver_data[idx];
   
    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || !g_cfg.rage.resolver || player->is_bot() || player->is_teammate(false)) {
        res_info.reset();
        return;
    }

    auto state = player->animstate();
    if (!state) return;

    if (player->spawn_time() != current->sim_time) {
       
    }

    float speed_2d = player->velocity().length_2d();
    bool on_ground = player->flags().has(FL_ONGROUND);
    float max_desync = get_max_desync_delta(player);

    if (speed_2d > 1.1f && on_ground)
    {
        res_info.mode = R_MOVE;
        res_info.side = 0;
        res_info.last_moving_lby = player->lower_body_yaw();
        res_info.has_stopped_recently = false;
       
        state->abs_yaw = player->lower_body_yaw();
       
        if (state->time_since_stopped_moving < 0.22f)
            res_info.missed_shots = 0;
    }
    else
    {
        if (!res_info.has_stopped_recently && speed_2d < 1.0f) {
            res_info.has_stopped_recently = true;
        }

        int side_resolv = 0;
       
        float lby_delta = angle_diff(player->lower_body_yaw(), res_info.last_moving_lby);
        if (abs(lby_delta) < 35.0f && res_info.missed_shots == 0) {
             res_info.mode = R_LBY_UPD;
             res_info.side = 0;
             state->abs_yaw = res_info.last_moving_lby;
             return;
        }

        if (res_info.missed_shots <= 1) {
             int wall_side = detect_freestanding(player);
             if (wall_side != 0) {
                 res_info.mode = R_FREESTAND;
                 res_info.side = wall_side;
                 state->abs_yaw = math::normalize_yaw(player->eye_angles().y + (max_desync * wall_side));
                 return;
             }
        }

        res_info.mode = R_BRUTE;
       
        switch (res_info.missed_shots % 3) {
            case 0:
                side_resolv = 1;
                break;
            case 1:
                side_resolv = -1;
                break;
            case 2:
                side_resolv = 0;
                break;
        }

        res_info.side = side_resolv;
       
        if (side_resolv == 0)
             state->abs_yaw = player->eye_angles().y;
        else
             state->abs_yaw = math::normalize_yaw(player->eye_angles().y + (max_desync * side_resolv));
    }
}

inline void apply_side(c_cs_player* player, anim_record_t* current, int choke)
{
    int idx = player->index();
    auto& res_info = resolver_data[idx];

    if (!HACKS->weapon_info || !HACKS->local || !HACKS->local->is_alive() || res_info.side == 1337 || player->is_teammate(false))
        return;

    auto state = player->animstate();
    if (!state) return;
   
    float max_desync = get_max_desync_delta(player);

    switch (res_info.side)
    {
        case -1:
            state->abs_yaw = math::normalize_yaw(player->eye_angles().y - max_desync);
            break;
        case 1:
            state->abs_yaw = math::normalize_yaw(player->eye_angles().y + max_desync);
            break;
        case 0:
            state->abs_yaw = math::normalize_yaw(player->eye_angles().y);
            break;
    }
}

Beady · 29 Ноя 2025

flairer написал(а):
Посмотреть вложение 321076

Вопрос Кто поможет Резик!

Похожие темы