Вопрос Opposite aa

layzonx · 14 Сен 2021

Включаю оппозиты, происходит это:
код аа: деф лв, изза чего может быть?
Видео ->

Пожалуйста, авторизуйтесь для просмотра ссылки.

Abybachup · 14 Сен 2021

layzonx написал(а):
Включаю оппозиты, происходит это:
код аа: деф лв, изза чего может быть?
Видео ->
Пожалуйста, авторизуйтесь для просмотра ссылки.

переменную speed посмотри в yaw

PanHack · 14 Сен 2021

show code??

layzonx · 14 Сен 2021

NosokkosoN написал(а):
переменную speed посмотри в yaw

C++:

float antiaim::get_yaw(CUserCmd* m_pcmd)
{

    static auto invert_jitter = false;
    static auto should_invert = false;

    if (m_pcmd->m_buttons & IN_USE)
        final_manual_side == SIDE_NONE;

    if (g_ctx.send_packet)
        should_invert = true;

    else if (!g_ctx.send_packet && should_invert) //-V560
    {
        should_invert = false;
        invert_jitter = !invert_jitter;
    }
    auto max_desync_delta = g_ctx.local()->get_max_desync_delta(); //-V807

    auto yaw = 0.0f;
    auto lby_type = 0;

    if (g_cfg.legitbot.enabled && !g_cfg.ragebot.enable)
    {
        yaw = m_pcmd->m_viewangles.y;

        if (!g_cfg.antiaim.desync)
            return yaw;

        if (g_cfg.antiaim.desync == 1) {

            if (g_cfg.antiaim.freestanding[REAL]) {
                flip = automatic_direction(g_ctx.local(), m_pcmd->m_viewangles);
                if (flip && key_binds::get().get_key_bind_state(16))
                    flip = true;
                else if (!flip && key_binds::get().get_key_bind_state(16))
                    flip = false;
                else if (flip && !key_binds::get().get_key_bind_state(16))
                    flip = false;
                else if (!flip && key_binds::get().get_key_bind_state(16))
                    flip = true;
            }
            else
                flip = key_binds::get().get_key_bind_state(16);

            if (g_cfg.antiaim.freestanding[DESYNC]) {
                flip = automatic_direction_desync(g_ctx.local(), m_pcmd->m_viewangles);
                if (flip && key_binds::get().get_key_bind_state(16))
                    flip = false;
                else if (!flip && key_binds::get().get_key_bind_state(16))
                    flip = true;
                else if (flip && !key_binds::get().get_key_bind_state(16))
                    flip = true;
                else if (!flip && key_binds::get().get_key_bind_state(16))
                    flip = false;
            }
            else
                flip = key_binds::get().get_key_bind_state(16);

        }
        else if (g_cfg.antiaim.desync == 2)
            flip = invert_jitter;

        desync_angle = max_desync_delta;

        if (g_cfg.antiaim.lby_type && g_ctx.local()->m_vecVelocity().Length() < 5.0f && g_ctx.local()->m_fFlags() & FL_ONGROUND && engineprediction::get().backup_data.flags & FL_ONGROUND)
            desync_angle *= 2.0f;

        if (flip)
        {
            desync_angle = -desync_angle;
            max_desync_delta = -max_desync_delta;
        }

        yaw -= desync_angle;
        lby_type = g_cfg.antiaim.lby_type;
    }
    else if (!g_cfg.legitbot.enabled && g_cfg.ragebot.enable)
    {
        float f_yaw = 0;
        float freestand_angle = 0;
        auto base_angle = 0;
        auto ee_yaw = 0.f;
        if ((m_pcmd->m_buttons & IN_USE))
            ee_yaw = 0.f + m_pcmd->m_viewangles.y;
        else
            ee_yaw = 0.f + m_pcmd->m_viewangles.y;
        switch (g_cfg.antiaim.type[type].base_angle)
        {
        case 0:
            base_angle += 0;
            break;
        case 1:
            base_angle += ee_yaw;
            break;
        case 2:
            if (!(m_pcmd->m_buttons & IN_USE) && manual_side == SIDE_NONE)
                base_angle = at_targets();
            else
                base_angle += m_pcmd->m_viewangles.y;
            break;
        }
        if (g_cfg.antiaim.type[type].yaw)
        {
            base_angle += add_yaw(m_pcmd);
        }
        if (g_cfg.antiaim.freestanding[YAW])
            base_angle += freestand_angle;

        if (final_manual_side == SIDE_NONE)
            base_angle -= 0.f;
        if (manual_side == SIDE_NONE)
            base_angle -= 0.f;
        else
            final_manual_side = manual_side;
        if (final_manual_side == SIDE_LEFT)
            base_angle -= 90.0f;
        if (final_manual_side == SIDE_RIGHT)
            base_angle += 90.0f;
        if (final_manual_side == SIDE_NONE)
        {
            manual_side = SIDE_NONE;
        }

        if ((m_pcmd->m_buttons & IN_USE))
            return m_pcmd->m_viewangles.y;

        freestanding(g_usercmd());

        if (g_cfg.antiaim.desync != 2 && (g_cfg.antiaim.freestanding[REAL]))
        {
            if (final_manual_side == SIDE_LEFT)
                flip = true;
            else if (final_manual_side == SIDE_RIGHT)
                flip = false;
            else
                flip = automatic_direction(g_ctx.local(), m_pcmd->m_viewangles);
        }
        else if (g_cfg.antiaim.desync != 2 && (g_cfg.antiaim.freestanding[DESYNC]))
        {
            if (final_manual_side == SIDE_LEFT)
                flip = true;
            else if (final_manual_side == SIDE_RIGHT)
                flip = false;
            else
                flip = automatic_direction_desync(g_ctx.local(), m_pcmd->m_viewangles);
        }
        else if (g_cfg.antiaim.desync == 1)
            flip = key_binds::get().get_key_bind_state(16);
        else if (g_cfg.antiaim.desync == 2)
            flip = invert_jitter;

        auto yaw_angle = 0.0f;

        switch (g_cfg.antiaim.type[type].yaw)
        {
        case 0:
            yaw_angle = 180.0f;
            break;
        case 1:
            yaw_angle = 0.0f;
            break;
        case 2:
        {
            yaw_angle = invert_jitter ? (float)g_cfg.antiaim.type[type].range * -0.5f : (float)g_cfg.antiaim.type[type].range * 0.5f;
        }
        break;
        case 3:
        {
            yaw_angle = math::random_int((float)g_cfg.antiaim.type[type].range * -0.5f, (float)g_cfg.antiaim.type[type].range * 0.5f);
        }
        break;
        }

        auto velocity = g_ctx.local()->m_vecVelocity().Length(); //-V807

        if (g_cfg.antiaim.inverted_condition[INVERDTED_STAND])
        {
            if (velocity <= 1.01f && g_ctx.local()->m_fFlags() & FL_ONGROUND && engineprediction::get().backup_data.flags & FL_ONGROUND)
                flip = invert_jitter;
        }
        else if (g_cfg.antiaim.inverted_condition[INVERDTED_MOVE])
        {
            if (velocity >= 5.0f && g_ctx.local()->m_fFlags() & FL_ONGROUND && engineprediction::get().backup_data.flags & FL_ONGROUND)
                flip = invert_jitter;
        }
        else if (g_cfg.antiaim.inverted_condition[INVERDTED_SLOWWALK])
        {
            if (velocity >= 5.0f && g_ctx.globals.slowwalking)
                flip = invert_jitter;
        }
        else if (g_cfg.antiaim.inverted_condition[INVERDTED_AIR])
        {
            if (!(g_ctx.local()->m_fFlags() & FL_ONGROUND && engineprediction::get().backup_data.flags & FL_ONGROUND))
                flip = invert_jitter;
        }

        desync_angle = 0.0f;

        if (g_cfg.antiaim.desync)
        {
            if (g_cfg.antiaim.desync == 2)
                flip = invert_jitter;

            auto desync_delta = max_desync_delta;
            if (g_cfg.antiaim.lby_type)
                desync_delta *= 2.0f;
            else
            {
                if (!flip)
                    desync_delta = min(desync_delta, (float)g_cfg.antiaim.type[type].desync_range);
                else
                    desync_delta = min(desync_delta, (float)g_cfg.antiaim.type[type].inverted_desync_range);
            }

            if (!flip)
            {
                desync_delta = -desync_delta;
                max_desync_delta = -max_desync_delta;
            }
            base_angle -= desync_delta;

            desync_angle = desync_delta;
        }

        yaw = base_angle + yaw_angle;

        if (!desync_angle) //-V550
            return yaw;

        lby_type = g_cfg.antiaim.lby_type;

    }
    static auto sway_counter = 0;
    static auto force_choke = false;

    if (should_break_lby(m_pcmd, lby_type))
    {
        auto speed = 1.01f;

        if (m_pcmd->m_buttons & IN_DUCK || g_ctx.globals.fakeducking)
            speed *= 2.94117647f;

        static auto switch_move = false;

        if (switch_move)
            m_pcmd->m_sidemove += speed;
        else
            m_pcmd->m_sidemove -= speed;

        switch_move = !switch_move;

        if (lby_type != 2 || sway_counter > 3)
        {
            if (desync_angle > 0.0f)
                yaw -= 179.0f;
            else
                yaw += 179.0f;
        }

        if (sway_counter < 8)
            ++sway_counter;
        else
            sway_counter = 0;

        breaking_lby = true;
        force_choke = true;
        g_ctx.send_packet = false;

        return yaw;
    }
    else if (force_choke)
    {
        force_choke = false;
        g_ctx.send_packet = false;
        return yaw;
    }
    else if (g_ctx.send_packet)
        yaw += desync_angle;

    return yaw;
}
[QUOTE="PanHack, post: 2367780, member: 250421"]
show code??
[/QUOTE]

PanHack написал(а):
show code??

up

C++:

bool antiaim::should_break_lby(CUserCmd* m_pcmd, int lby_type)
{
    if (!lby_type)
        return false;

    if (g_ctx.globals.fakeducking && m_clientstate()->iChokedCommands > 12)
        return false;

    if (!g_ctx.globals.fakeducking && m_clientstate()->iChokedCommands > 14)
    {
        g_ctx.send_packet = true;
        fakelag::get().started_peeking = false;
    }

    auto animstate = g_ctx.local()->get_animation_state(); //-V807

    if (!animstate)
        return false;

    if (animstate->m_velocity > 0.1f || fabs(animstate->flUpVelocity) > 100.0f)
        g_ctx.globals.next_lby_update = TICKS_TO_TIME(g_ctx.globals.fixed_tickbase + 14);
    else
    {
        if (TICKS_TO_TIME(g_ctx.globals.fixed_tickbase) > g_ctx.globals.next_lby_update)
        {
            g_ctx.globals.next_lby_update = 0.0f;
            return true;
        }
    }

    return false;
}