C++ BruteForce resolver(by $fey mega paster$)

Начинающий
Статус
Оффлайн
Регистрация
9 Ноя 2020
Сообщения
153
Реакции[?]
7
Поинты[?]
0
C++:
/*
#include "animstates.h"
#include "..\ragebot\aim.h"
void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

    bool resolver::low_delta()
    {
        auto record = player_record;
        if (!csgo.local()->is_alive())
            return false;
        float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
        Vector first = ZERO, second = ZERO, third = ZERO;
        first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
        third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        Ray_t one, two, three;
        trace_t tone, ttwo, ttree;
        CTraceFilter fl;
        fl.pSkip = player;
        one.Init(csgo.local()->get_shoot_position(), first);
        two.Init(csgo.local()->get_shoot_position(), second);
        three.Init(csgo.local()->get_shoot_position(), third);
        m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
        m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
        m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
        if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
            return true;

        float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
        if (lby < 35 && lby > -35)
            return true;
        return false;
    }

bool resolver::low_delta2()
{
    auto record = player_record;
    if (!csgo.local()->is_alive())
        return false;
    float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
    Vector first = ZERO, second = ZERO, third = ZERO;
    first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
    third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    Ray_t one, two, three;
    trace_t tone, ttwo, ttree;
    CTraceFilter fl;
    fl.pSkip = player;
    one.Init(csgo.local()->get_shoot_position(), first);
    two.Init(csgo.local()->get_shoot_position(), second);
    three.Init(csgo.local()->get_shoot_position(), third);
    m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
    m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
    m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
    if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
        return true;

    float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
    if (lby < 20 && lby > -20)
        return true;
    return false;
}

float resolver::GetBackwardYaw(player_t* ent) {
    return math::calculate_angle(csgo.local()->GetAbsOrigin(), ent->GetAbsOrigin()).y;
}

float resolver::GetForwardYaw(player_t* ent) {
    return math::normalize_yaw(GetBackwardYaw(ent) - 180.f);
}

void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!m_engine()->GetPlayerInfo(player->EntIndex(), &player_info))
        return;

    static int side[63];
    auto animstate  = player->get_animation_state();
    auto speed = csgo.local()->m_vecVelocity().Length2D();
    if (speed <= 0.1f)
    {
        if (player_record->layers[3].m_flWeight == 0.0 && player_record->layers[3].m_flCycle == 0.0)
        {
            side[player->EntIndex()] = 2 * (math::normalize_diff(player->m_angEyeAngles().y, player_record->abs_angles.y) <= 0.0) - 1;
        }
    }
    else
    {
        const float f_delta = abs(player_record->layers[6].m_flPlaybackRate -   player_record->left_layers[6].m_flPlaybackRate);
        const float s_delta = abs(player_record->layers[6].m_flPlaybackRate - player_record->center_layers[6].m_flPlaybackRate);
        const float t_delta = abs(player_record->layers[6].m_flPlaybackRate -  player_record->right_layers[6].m_flPlaybackRate);

        if (f_delta < s_delta || t_delta <= s_delta || (s_delta * 1000.0))
        {
            if (f_delta >= t_delta && s_delta > t_delta && !(t_delta * 1000.0))
            {
                side[player->EntIndex()] = 1;
            }
        }
        else
        {
            side[player->EntIndex()] = -1;
        }
    }

    if (player->GetAbsOrigin().y == GetForwardYaw(player))
        side[player->EntIndex()] *= -1;
    
    if (csgo.globals.missed_shots[player->EntIndex()] == 0) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta() ? RESOLVER_LOW_FIRST : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta() ? RESOLVER_LOW_SECOND : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 1) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta2() ? RESOLVER_LOW_FIRST1 : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta2() ? RESOLVER_LOW_SECOND1 : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 2) {
        player_record->side = RESOLVER_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 3) {
        player_record->side = RESOLVER_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 4) {
        player_record->side = RESOLVER_LOW_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 5) {
        player_record->side = RESOLVER_LOW_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] >= 6) {
        m_cvar()->ConsoleColorPrintf(Color(255, 0, 0), u8"èäè íàõóé, ýòî ñïðèä, ó òåáÿ êôã èññóå\n");
        csgo.globals.missed_shots[player->EntIndex()] = 0;
    }

}

float resolver::resolve_pitch()
{
}
*/

// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com

#include "animation_system.h"
#include "..\ragebot\aim.h"

void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;
    bool fake = false;
    fake = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

float flAngleMod(float flAngle)
{
    return((360.0f / 65536.0f) * ((int32_t)(flAngle * (65536.0f / 360.0f)) & 65530));
}

float ApproachAngle(float target, float value, float speed)
{
    target = flAngleMod(target);
    value = flAngleMod(value);

    float delta = target - value;

    if (speed < 0)
        speed = -speed;

    if (delta < -180)
        delta += 360;
    else if (delta > 180)
        delta -= 360;

    if (delta > speed)
        value += speed;
    else if (delta < -speed)
        value -= speed;
    else
        value = target;

    return value;
}

float AngleDiff(float destAngle, float srcAngle)
{
    float delta;

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

float GetChokedPackets(player_t* e)
{
    float simtime = e->m_flSimulationTime();
    float oldsimtime = e->m_flOldSimulationTime();
    float simdiff = simtime - oldsimtime;

    auto chokedpackets = TIME_TO_TICKS(max(0, simdiff));

    if (chokedpackets >= 1)
        return chokedpackets;

    return 0;
}


bool resolver::Side()
{
    AnimationLayer layers[13];
    AnimationLayer moveLayers[3][13];
    AnimationLayer preserver_anim_layers[13];

    auto speed = player->m_vecVelocity().Length2D();

    if (speed > 1.1f)
    {
        if (!layers[12].m_flWeight * 1000.f)
        {
            if ((layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f))
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);

                if (Positive >= EyeYaw || Positive >= Negative || (Positive * 1000.f))
                {
                    last_anims_update_time = m_globals()->m_realtime;
                    return true;
                }
            }
            else
            {
                last_anims_update_time = m_globals()->m_realtime;
                return false;
            }
        }
    }
    else if (layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f)
    {
        auto delta = std::remainder(math::normalize_yaw(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
        if (2 * delta)
        {
            if (2 * delta == 2)
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
}

bool resolver::DesyncDetect()
{
    if (!player->is_alive())
        return false;
    if (!player->m_fFlags() & FL_ONGROUND)
        return false;
    if (player->get_max_desync_delta() < 10)
        return false;
    if (!player->m_iTeamNum() == csgo.local()->m_iTeamNum())
        return false;
    if (GetChokedPackets(player) == 0)
        return false;
    if (!player->m_hActiveWeapon().Get()->can_fire(true))
        return false;

    return true;
}

void resolver::shitresolver()
{
    auto animstate = player->get_animation_state();

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

    float maxMovementSpeed = 260.0f;

    auto weapon = player->m_hActiveWeapon().Get();

    Vector velocity = player->m_vecVelocity();
    Vector animVelocity = GetSmoothedVelocity(m_clientstate()->iChokedCommands * 2000.0f, velocity, player->m_vecVelocity());

    float speed = std::fminf(animVelocity.Length(), 260.0f);
    float runningSpeed = speed / (maxMovementSpeed * 0.520f);
    float duckSpeed = speed / (maxMovementSpeed * 0.340);
    float yawModifer = (((animstate->m_bOnGround * -0.3f) - 0.2f) * runningSpeed) + 1.0f;
    float maxBodyYaw = *(float*)(uintptr_t(animstate) + 0x334) * yawModifer;
    float minBodyYaw = *(float*)(uintptr_t(animstate) + 0x330) * yawModifer;
    float eyeYaw = player->m_angEyeAngles().y;
    float left = eyeYaw - minBodyYaw;
    float right = eyeYaw + maxBodyYaw;
    float eyeDiff = std::remainderf(eyeYaw - original_goal_feet_yaw, 360.f);

    if (eyeDiff <= minBodyYaw)
    {
        if (minBodyYaw > eyeDiff)
            original_goal_feet_yaw = fabs(minBodyYaw) + eyeYaw;
    }
    else
    {
        original_goal_feet_yaw = eyeYaw - fabs(maxBodyYaw);
    }

    original_goal_feet_yaw = std::remainderf(original_goal_feet_yaw, 360.f);

    if (speed > 0.1f || fabs(velocity.z) > 100.0f)
    {
        original_goal_feet_yaw = ApproachAngle(
            eyeYaw,
            original_goal_feet_yaw,
            ((animstate->m_bOnGround * 15.0f) + 30.0f) * m_clientstate()->iChokedCommands
        );
    }
    else
    {
        original_goal_feet_yaw = ApproachAngle(
            player->m_flLowerBodyYawTarget(), original_goal_feet_yaw, m_clientstate()->iChokedCommands * 90.0f);
    }

    if (resolver::Side())
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        }
    }
    else
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        }
    }
}


void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!player || !player->get_animation_state() || !m_engine()->GetPlayerInfo(player->EntIndex(), &player_info) || player_info.fakeplayer || !resolver::DesyncDetect())
        return;

    if (csgo.globals.missed_shots[player->EntIndex()] <= 2)
    {
        resolver::shitresolver();
        return;
    }

    auto animstate = player->get_animation_state();
    float resolveValue;
    int resolveSide = resolver::Side() ? 1 : -1;

    if (player->m_vecVelocity().Length2D() > 1.1f && player->m_vecVelocity().Length2D() < 110.0f)
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            resolveValue = 30.0f;
            break;
        case 1:
            resolveValue = 58.0f;
            break;
        case 2:
            resolveValue = 19.0f;
            break;
        }
    }
    else
    {

            switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
            {
            case 0:
                resolveValue = 69.0f;
                break;
            case 1:
                resolveValue = 30.0f;
                break;
            case 2:
                resolveValue = 19.0f;
                break;
            }
    }

    if (resolveValue > player->get_max_desync_delta())
        resolveValue = player->get_max_desync_delta();

    player->get_animation_state()->m_flGoalFeetYaw = math::normalize_yaw(player->m_angEyeAngles().y + resolveValue * resolveSide);
    }
void resolver::skeetresik(player_t* e)
{
    if (!vars.ragebot.enable)
        return;

    auto anim_state = player->get_animation_state(); // get state

    static float v42, v56, v49,
        v51, v46;

    float desync_delta; // xmm0_4
    float v4; // xmm1_4
    float v5; // xmm1_4
    float v6; // xmm1_4
    float v7; // xmm1_4
    float v8; // xmm1_4
    float v9; // xmm1_4

    if (anim_state->m_fDuckAmount > 0.0)
    {
        auto v29 = 0.0;
        if (anim_state->m_flFeetSpeedUnknownForwardOrSideways < 0.0)
            v29 = 0.0;

        float v52 = anim_state->m_fDuckAmount * v51;
        v49 = v49 + (float)(v52 * (float)(0.5 - v49));
    }

    float v47 = (float)((anim_state->m_flStopToFullRunningFraction * -0.30000001f) - 0.19999999f) * v46;
    v49 = v47 + 1.0;

    float speed;
    if (*(float*)(anim_state + 0xF8) < 0.f)
    {
        speed = 0.0;
    }
    else
    {
        speed = fminf(*(DWORD*)(anim_state + 0xF8), 1.0f);
    }
    float flYawModifier = (*(float*)(anim_state + 0x11C) * -0.30000001 - 0.19999999) * speed;
    desync_delta = flYawModifier * 58.0;
    switch (csgo.globals.missed_shots[player->EntIndex()] % 4)
    {
    case 1:
        v4 = anim_state->m_flGoalFeetYaw + (desync_delta + desync_delta);
        if (v4 > 180.0 || v4 < -180.0)
            break;
    case 2:
        v5 = anim_state->m_flGoalFeetYaw + (desync_delta * 0.5);
        if (v5 > 180.0 || v5 < -180.0)
            break;
    case 4:
        v6 = anim_state->m_flGoalFeetYaw + (desync_delta * -0.5);
        if (v6 > 180.0 || v6 < -180.0)
            break;
    case 5:
        v8 = anim_state->m_flGoalFeetYaw - (desync_delta + desync_delta);
        if (v8 > 180.0 || v8 < -180.0)
            break;
    case 7:
        v9 = anim_state->m_flGoalFeetYaw + 120.0;
        if ((anim_state->m_flGoalFeetYaw + 120.0) > 180.0 || v9 < -180.0)
            break;
    case 8:
        v7 = anim_state->m_flGoalFeetYaw + -120.0;
        if ((anim_state->m_flGoalFeetYaw + -120.0) > 180.0 || v7 < -180.0)
            break;
    default:
        return;
    }
    float lby_delta = e->m_flLowerBodyYawTarget();
    lby_delta = std::remainderf(lby_delta, 360.f);
    lby_delta = math::clamp(lby_delta, -60.f, 60.f);

    float v73 = std::remainderf(lby_delta, 360.f);

    if (v73 < 0.f) {
        v73 += 360.f;
    }

    static int v36;
    if (anim_state)
    {
        if (csgo.globals.missed_shots[e->EntIndex()] <= 2) {

            if (v36 > 180.0)
                v36 = v36 - 360.0;
            if (v36 < 180.0)
                v36 = v36 + 360.0;
            anim_state->m_flGoalFeetYaw = v36;
        }
    }

    float v25 = math::clamp(anim_state->m_fDuckAmount + anim_state->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
    float v26 = anim_state->m_fDuckAmount;
    float v27 = 6.0f;
    float v28;

    if ((v25 - v26) <= v27) { // clamp
        if (-v27 <= (v25 - v26))
            v28 = v25;
        else
            v28 = v26 - v27;
    }
    else {
        v28 = v26 + v27;
    }
}

void resolver::ResolveAngles(player_t* player)
{
    // lets be real this is the most p thing we ever seen
    float m_flResolveValue;
    int m_flResolveSide;
    AnimationLayer layers[15];
    AnimationLayer moveLayers[3][15];
    int m_flSide;
    bool m_bAnimatePlayer;
    bool m_bAnimsUpdated;
    bool m_bResolve;
    bool m_flPreviousDelta;
    // yee jarvis nanotechnology please.
   // ok sir...
  // fly mode activated

    if (player->is_alive() && !player->is_player())
    {
        if (!(player->m_fFlags() & FL_ONGROUND))
        {
            m_flResolveSide = 0;
        }
        auto standing = layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f;
        auto animating = layers[12].m_flWeight * 1000.f;
        auto moving = !animating && (layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f);

        float m_flSpeed = player->m_vecVelocity().Length2D();
        if (m_flSpeed > 1.1f)
        {
            if (moving)
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                if (Positive > EyeYaw || Positive >= Negative || (Positive * 1000.0))
                {
                    if (EyeYaw >= Negative && Positive > Negative && !(Negative * 1000.0))
                    {
                        m_bAnimsUpdated = true;
                        m_bResolve = true;
                        m_flSide = 1;
                    }
                }
                else
                {
                    m_bAnimsUpdated = true;
                    m_bResolve = true;
                    m_flSide = -1;
                }
            }
        }
        else if (standing)
        {
            auto m_flEyeDelta = std::remainderf(math::NormalizedAngle(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
            if (2 * m_flEyeDelta)
            {
                if (2 * m_flEyeDelta == 2)
                {
                    m_flSide = -1;
                }
            }
            else
            {
                m_flSide = 1;
            }
            m_bResolve = true;
            m_flPreviousDelta = m_flEyeDelta;
        }
        m_flResolveValue = 58.f;
        player->get_animation_state()->m_flGoalFeetYaw = math::NormalizedAngle(player->m_angEyeAngles().y + m_flResolveValue * m_flSide);

    }

}


float resolver::resolve_pitch()
{
    return original_pitch;
}
 
Начинающий
Статус
Оффлайн
Регистрация
7 Июл 2020
Сообщения
62
Реакции[?]
4
Поинты[?]
0
P 100 delta checks
CoffeeScript:
 if (destAngle > srcAngle)
    {
        if (delta >= 180)
            delta -= 360;
    }
    else
    {
        if (delta <= -180)
            delta += 360;
 
Забаненный
Статус
Оффлайн
Регистрация
29 Дек 2021
Сообщения
18
Реакции[?]
5
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
get good get legendware
Участник
Статус
Оффлайн
Регистрация
22 Сен 2020
Сообщения
437
Реакции[?]
201
Поинты[?]
48K
it’s literally just random public shit just slapped together and nothing here is useful please don’t waste your time everything is set incorrectly even the detectside (not saving matrices)
 
Забаненный
Статус
Оффлайн
Регистрация
22 Мар 2021
Сообщения
1,019
Реакции[?]
315
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
крутяк из фаталити 19 года пастить притом вронг
 
мой нос как останкинская башня
Забаненный
Статус
Оффлайн
Регистрация
24 Апр 2020
Сообщения
483
Реакции[?]
60
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
C++:
/*
#include "animstates.h"
#include "..\ragebot\aim.h"
void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

    bool resolver::low_delta()
    {
        auto record = player_record;
        if (!csgo.local()->is_alive())
            return false;
        float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
        Vector first = ZERO, second = ZERO, third = ZERO;
        first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
        third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        Ray_t one, two, three;
        trace_t tone, ttwo, ttree;
        CTraceFilter fl;
        fl.pSkip = player;
        one.Init(csgo.local()->get_shoot_position(), first);
        two.Init(csgo.local()->get_shoot_position(), second);
        three.Init(csgo.local()->get_shoot_position(), third);
        m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
        m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
        m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
        if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
            return true;

        float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
        if (lby < 35 && lby > -35)
            return true;
        return false;
    }

bool resolver::low_delta2()
{
    auto record = player_record;
    if (!csgo.local()->is_alive())
        return false;
    float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
    Vector first = ZERO, second = ZERO, third = ZERO;
    first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
    third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    Ray_t one, two, three;
    trace_t tone, ttwo, ttree;
    CTraceFilter fl;
    fl.pSkip = player;
    one.Init(csgo.local()->get_shoot_position(), first);
    two.Init(csgo.local()->get_shoot_position(), second);
    three.Init(csgo.local()->get_shoot_position(), third);
    m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
    m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
    m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
    if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
        return true;

    float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
    if (lby < 20 && lby > -20)
        return true;
    return false;
}

float resolver::GetBackwardYaw(player_t* ent) {
    return math::calculate_angle(csgo.local()->GetAbsOrigin(), ent->GetAbsOrigin()).y;
}

float resolver::GetForwardYaw(player_t* ent) {
    return math::normalize_yaw(GetBackwardYaw(ent) - 180.f);
}

void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!m_engine()->GetPlayerInfo(player->EntIndex(), &player_info))
        return;

    static int side[63];
    auto animstate  = player->get_animation_state();
    auto speed = csgo.local()->m_vecVelocity().Length2D();
    if (speed <= 0.1f)
    {
        if (player_record->layers[3].m_flWeight == 0.0 && player_record->layers[3].m_flCycle == 0.0)
        {
            side[player->EntIndex()] = 2 * (math::normalize_diff(player->m_angEyeAngles().y, player_record->abs_angles.y) <= 0.0) - 1;
        }
    }
    else
    {
        const float f_delta = abs(player_record->layers[6].m_flPlaybackRate -   player_record->left_layers[6].m_flPlaybackRate);
        const float s_delta = abs(player_record->layers[6].m_flPlaybackRate - player_record->center_layers[6].m_flPlaybackRate);
        const float t_delta = abs(player_record->layers[6].m_flPlaybackRate -  player_record->right_layers[6].m_flPlaybackRate);

        if (f_delta < s_delta || t_delta <= s_delta || (s_delta * 1000.0))
        {
            if (f_delta >= t_delta && s_delta > t_delta && !(t_delta * 1000.0))
            {
                side[player->EntIndex()] = 1;
            }
        }
        else
        {
            side[player->EntIndex()] = -1;
        }
    }

    if (player->GetAbsOrigin().y == GetForwardYaw(player))
        side[player->EntIndex()] *= -1;
   
    if (csgo.globals.missed_shots[player->EntIndex()] == 0) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta() ? RESOLVER_LOW_FIRST : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta() ? RESOLVER_LOW_SECOND : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 1) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta2() ? RESOLVER_LOW_FIRST1 : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta2() ? RESOLVER_LOW_SECOND1 : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 2) {
        player_record->side = RESOLVER_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 3) {
        player_record->side = RESOLVER_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 4) {
        player_record->side = RESOLVER_LOW_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 5) {
        player_record->side = RESOLVER_LOW_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] >= 6) {
        m_cvar()->ConsoleColorPrintf(Color(255, 0, 0), u8"èäè íàõóé, ýòî ñïðèä, ó òåáÿ êôã èññóå\n");
        csgo.globals.missed_shots[player->EntIndex()] = 0;
    }

}

float resolver::resolve_pitch()
{
}
*/

// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com

#include "animation_system.h"
#include "..\ragebot\aim.h"

void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;
    bool fake = false;
    fake = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

float flAngleMod(float flAngle)
{
    return((360.0f / 65536.0f) * ((int32_t)(flAngle * (65536.0f / 360.0f)) & 65530));
}

float ApproachAngle(float target, float value, float speed)
{
    target = flAngleMod(target);
    value = flAngleMod(value);

    float delta = target - value;

    if (speed < 0)
        speed = -speed;

    if (delta < -180)
        delta += 360;
    else if (delta > 180)
        delta -= 360;

    if (delta > speed)
        value += speed;
    else if (delta < -speed)
        value -= speed;
    else
        value = target;

    return value;
}

float AngleDiff(float destAngle, float srcAngle)
{
    float delta;

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

float GetChokedPackets(player_t* e)
{
    float simtime = e->m_flSimulationTime();
    float oldsimtime = e->m_flOldSimulationTime();
    float simdiff = simtime - oldsimtime;

    auto chokedpackets = TIME_TO_TICKS(max(0, simdiff));

    if (chokedpackets >= 1)
        return chokedpackets;

    return 0;
}


bool resolver::Side()
{
    AnimationLayer layers[13];
    AnimationLayer moveLayers[3][13];
    AnimationLayer preserver_anim_layers[13];

    auto speed = player->m_vecVelocity().Length2D();

    if (speed > 1.1f)
    {
        if (!layers[12].m_flWeight * 1000.f)
        {
            if ((layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f))
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);

                if (Positive >= EyeYaw || Positive >= Negative || (Positive * 1000.f))
                {
                    last_anims_update_time = m_globals()->m_realtime;
                    return true;
                }
            }
            else
            {
                last_anims_update_time = m_globals()->m_realtime;
                return false;
            }
        }
    }
    else if (layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f)
    {
        auto delta = std::remainder(math::normalize_yaw(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
        if (2 * delta)
        {
            if (2 * delta == 2)
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
}

bool resolver::DesyncDetect()
{
    if (!player->is_alive())
        return false;
    if (!player->m_fFlags() & FL_ONGROUND)
        return false;
    if (player->get_max_desync_delta() < 10)
        return false;
    if (!player->m_iTeamNum() == csgo.local()->m_iTeamNum())
        return false;
    if (GetChokedPackets(player) == 0)
        return false;
    if (!player->m_hActiveWeapon().Get()->can_fire(true))
        return false;

    return true;
}

void resolver::shitresolver()
{
    auto animstate = player->get_animation_state();

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

    float maxMovementSpeed = 260.0f;

    auto weapon = player->m_hActiveWeapon().Get();

    Vector velocity = player->m_vecVelocity();
    Vector animVelocity = GetSmoothedVelocity(m_clientstate()->iChokedCommands * 2000.0f, velocity, player->m_vecVelocity());

    float speed = std::fminf(animVelocity.Length(), 260.0f);
    float runningSpeed = speed / (maxMovementSpeed * 0.520f);
    float duckSpeed = speed / (maxMovementSpeed * 0.340);
    float yawModifer = (((animstate->m_bOnGround * -0.3f) - 0.2f) * runningSpeed) + 1.0f;
    float maxBodyYaw = *(float*)(uintptr_t(animstate) + 0x334) * yawModifer;
    float minBodyYaw = *(float*)(uintptr_t(animstate) + 0x330) * yawModifer;
    float eyeYaw = player->m_angEyeAngles().y;
    float left = eyeYaw - minBodyYaw;
    float right = eyeYaw + maxBodyYaw;
    float eyeDiff = std::remainderf(eyeYaw - original_goal_feet_yaw, 360.f);

    if (eyeDiff <= minBodyYaw)
    {
        if (minBodyYaw > eyeDiff)
            original_goal_feet_yaw = fabs(minBodyYaw) + eyeYaw;
    }
    else
    {
        original_goal_feet_yaw = eyeYaw - fabs(maxBodyYaw);
    }

    original_goal_feet_yaw = std::remainderf(original_goal_feet_yaw, 360.f);

    if (speed > 0.1f || fabs(velocity.z) > 100.0f)
    {
        original_goal_feet_yaw = ApproachAngle(
            eyeYaw,
            original_goal_feet_yaw,
            ((animstate->m_bOnGround * 15.0f) + 30.0f) * m_clientstate()->iChokedCommands
        );
    }
    else
    {
        original_goal_feet_yaw = ApproachAngle(
            player->m_flLowerBodyYawTarget(), original_goal_feet_yaw, m_clientstate()->iChokedCommands * 90.0f);
    }

    if (resolver::Side())
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        }
    }
    else
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        }
    }
}


void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!player || !player->get_animation_state() || !m_engine()->GetPlayerInfo(player->EntIndex(), &player_info) || player_info.fakeplayer || !resolver::DesyncDetect())
        return;

    if (csgo.globals.missed_shots[player->EntIndex()] <= 2)
    {
        resolver::shitresolver();
        return;
    }

    auto animstate = player->get_animation_state();
    float resolveValue;
    int resolveSide = resolver::Side() ? 1 : -1;

    if (player->m_vecVelocity().Length2D() > 1.1f && player->m_vecVelocity().Length2D() < 110.0f)
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            resolveValue = 30.0f;
            break;
        case 1:
            resolveValue = 58.0f;
            break;
        case 2:
            resolveValue = 19.0f;
            break;
        }
    }
    else
    {

            switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
            {
            case 0:
                resolveValue = 69.0f;
                break;
            case 1:
                resolveValue = 30.0f;
                break;
            case 2:
                resolveValue = 19.0f;
                break;
            }
    }

    if (resolveValue > player->get_max_desync_delta())
        resolveValue = player->get_max_desync_delta();

    player->get_animation_state()->m_flGoalFeetYaw = math::normalize_yaw(player->m_angEyeAngles().y + resolveValue * resolveSide);
    }
void resolver::skeetresik(player_t* e)
{
    if (!vars.ragebot.enable)
        return;

    auto anim_state = player->get_animation_state(); // get state

    static float v42, v56, v49,
        v51, v46;

    float desync_delta; // xmm0_4
    float v4; // xmm1_4
    float v5; // xmm1_4
    float v6; // xmm1_4
    float v7; // xmm1_4
    float v8; // xmm1_4
    float v9; // xmm1_4

    if (anim_state->m_fDuckAmount > 0.0)
    {
        auto v29 = 0.0;
        if (anim_state->m_flFeetSpeedUnknownForwardOrSideways < 0.0)
            v29 = 0.0;

        float v52 = anim_state->m_fDuckAmount * v51;
        v49 = v49 + (float)(v52 * (float)(0.5 - v49));
    }

    float v47 = (float)((anim_state->m_flStopToFullRunningFraction * -0.30000001f) - 0.19999999f) * v46;
    v49 = v47 + 1.0;

    float speed;
    if (*(float*)(anim_state + 0xF8) < 0.f)
    {
        speed = 0.0;
    }
    else
    {
        speed = fminf(*(DWORD*)(anim_state + 0xF8), 1.0f);
    }
    float flYawModifier = (*(float*)(anim_state + 0x11C) * -0.30000001 - 0.19999999) * speed;
    desync_delta = flYawModifier * 58.0;
    switch (csgo.globals.missed_shots[player->EntIndex()] % 4)
    {
    case 1:
        v4 = anim_state->m_flGoalFeetYaw + (desync_delta + desync_delta);
        if (v4 > 180.0 || v4 < -180.0)
            break;
    case 2:
        v5 = anim_state->m_flGoalFeetYaw + (desync_delta * 0.5);
        if (v5 > 180.0 || v5 < -180.0)
            break;
    case 4:
        v6 = anim_state->m_flGoalFeetYaw + (desync_delta * -0.5);
        if (v6 > 180.0 || v6 < -180.0)
            break;
    case 5:
        v8 = anim_state->m_flGoalFeetYaw - (desync_delta + desync_delta);
        if (v8 > 180.0 || v8 < -180.0)
            break;
    case 7:
        v9 = anim_state->m_flGoalFeetYaw + 120.0;
        if ((anim_state->m_flGoalFeetYaw + 120.0) > 180.0 || v9 < -180.0)
            break;
    case 8:
        v7 = anim_state->m_flGoalFeetYaw + -120.0;
        if ((anim_state->m_flGoalFeetYaw + -120.0) > 180.0 || v7 < -180.0)
            break;
    default:
        return;
    }
    float lby_delta = e->m_flLowerBodyYawTarget();
    lby_delta = std::remainderf(lby_delta, 360.f);
    lby_delta = math::clamp(lby_delta, -60.f, 60.f);

    float v73 = std::remainderf(lby_delta, 360.f);

    if (v73 < 0.f) {
        v73 += 360.f;
    }

    static int v36;
    if (anim_state)
    {
        if (csgo.globals.missed_shots[e->EntIndex()] <= 2) {

            if (v36 > 180.0)
                v36 = v36 - 360.0;
            if (v36 < 180.0)
                v36 = v36 + 360.0;
            anim_state->m_flGoalFeetYaw = v36;
        }
    }

    float v25 = math::clamp(anim_state->m_fDuckAmount + anim_state->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
    float v26 = anim_state->m_fDuckAmount;
    float v27 = 6.0f;
    float v28;

    if ((v25 - v26) <= v27) { // clamp
        if (-v27 <= (v25 - v26))
            v28 = v25;
        else
            v28 = v26 - v27;
    }
    else {
        v28 = v26 + v27;
    }
}

void resolver::ResolveAngles(player_t* player)
{
    // lets be real this is the most p thing we ever seen
    float m_flResolveValue;
    int m_flResolveSide;
    AnimationLayer layers[15];
    AnimationLayer moveLayers[3][15];
    int m_flSide;
    bool m_bAnimatePlayer;
    bool m_bAnimsUpdated;
    bool m_bResolve;
    bool m_flPreviousDelta;
    // yee jarvis nanotechnology please.
   // ok sir...
  // fly mode activated

    if (player->is_alive() && !player->is_player())
    {
        if (!(player->m_fFlags() & FL_ONGROUND))
        {
            m_flResolveSide = 0;
        }
        auto standing = layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f;
        auto animating = layers[12].m_flWeight * 1000.f;
        auto moving = !animating && (layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f);

        float m_flSpeed = player->m_vecVelocity().Length2D();
        if (m_flSpeed > 1.1f)
        {
            if (moving)
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                if (Positive > EyeYaw || Positive >= Negative || (Positive * 1000.0))
                {
                    if (EyeYaw >= Negative && Positive > Negative && !(Negative * 1000.0))
                    {
                        m_bAnimsUpdated = true;
                        m_bResolve = true;
                        m_flSide = 1;
                    }
                }
                else
                {
                    m_bAnimsUpdated = true;
                    m_bResolve = true;
                    m_flSide = -1;
                }
            }
        }
        else if (standing)
        {
            auto m_flEyeDelta = std::remainderf(math::NormalizedAngle(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
            if (2 * m_flEyeDelta)
            {
                if (2 * m_flEyeDelta == 2)
                {
                    m_flSide = -1;
                }
            }
            else
            {
                m_flSide = 1;
            }
            m_bResolve = true;
            m_flPreviousDelta = m_flEyeDelta;
        }
        m_flResolveValue = 58.f;
        player->get_animation_state()->m_flGoalFeetYaw = math::NormalizedAngle(player->m_angEyeAngles().y + m_flResolveValue * m_flSide);

    }

}


float resolver::resolve_pitch()
{
    return original_pitch;
}
где то на форуме видел почти идентичный код.
Да и тем более тут мем на меме.
 
Пользователь
Статус
Оффлайн
Регистрация
12 Июн 2019
Сообщения
865
Реакции[?]
127
Поинты[?]
1K
C++:
/*
#include "animstates.h"
#include "..\ragebot\aim.h"
void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

    bool resolver::low_delta()
    {
        auto record = player_record;
        if (!csgo.local()->is_alive())
            return false;
        float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
        Vector first = ZERO, second = ZERO, third = ZERO;
        first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
        third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        Ray_t one, two, three;
        trace_t tone, ttwo, ttree;
        CTraceFilter fl;
        fl.pSkip = player;
        one.Init(csgo.local()->get_shoot_position(), first);
        two.Init(csgo.local()->get_shoot_position(), second);
        three.Init(csgo.local()->get_shoot_position(), third);
        m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
        m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
        m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
        if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
            return true;

        float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
        if (lby < 35 && lby > -35)
            return true;
        return false;
    }

bool resolver::low_delta2()
{
    auto record = player_record;
    if (!csgo.local()->is_alive())
        return false;
    float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
    Vector first = ZERO, second = ZERO, third = ZERO;
    first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
    third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    Ray_t one, two, three;
    trace_t tone, ttwo, ttree;
    CTraceFilter fl;
    fl.pSkip = player;
    one.Init(csgo.local()->get_shoot_position(), first);
    two.Init(csgo.local()->get_shoot_position(), second);
    three.Init(csgo.local()->get_shoot_position(), third);
    m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
    m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
    m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
    if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
        return true;

    float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
    if (lby < 20 && lby > -20)
        return true;
    return false;
}

float resolver::GetBackwardYaw(player_t* ent) {
    return math::calculate_angle(csgo.local()->GetAbsOrigin(), ent->GetAbsOrigin()).y;
}

float resolver::GetForwardYaw(player_t* ent) {
    return math::normalize_yaw(GetBackwardYaw(ent) - 180.f);
}

void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!m_engine()->GetPlayerInfo(player->EntIndex(), &player_info))
        return;

    static int side[63];
    auto animstate  = player->get_animation_state();
    auto speed = csgo.local()->m_vecVelocity().Length2D();
    if (speed <= 0.1f)
    {
        if (player_record->layers[3].m_flWeight == 0.0 && player_record->layers[3].m_flCycle == 0.0)
        {
            side[player->EntIndex()] = 2 * (math::normalize_diff(player->m_angEyeAngles().y, player_record->abs_angles.y) <= 0.0) - 1;
        }
    }
    else
    {
        const float f_delta = abs(player_record->layers[6].m_flPlaybackRate -   player_record->left_layers[6].m_flPlaybackRate);
        const float s_delta = abs(player_record->layers[6].m_flPlaybackRate - player_record->center_layers[6].m_flPlaybackRate);
        const float t_delta = abs(player_record->layers[6].m_flPlaybackRate -  player_record->right_layers[6].m_flPlaybackRate);

        if (f_delta < s_delta || t_delta <= s_delta || (s_delta * 1000.0))
        {
            if (f_delta >= t_delta && s_delta > t_delta && !(t_delta * 1000.0))
            {
                side[player->EntIndex()] = 1;
            }
        }
        else
        {
            side[player->EntIndex()] = -1;
        }
    }

    if (player->GetAbsOrigin().y == GetForwardYaw(player))
        side[player->EntIndex()] *= -1;
   
    if (csgo.globals.missed_shots[player->EntIndex()] == 0) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta() ? RESOLVER_LOW_FIRST : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta() ? RESOLVER_LOW_SECOND : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 1) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta2() ? RESOLVER_LOW_FIRST1 : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta2() ? RESOLVER_LOW_SECOND1 : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 2) {
        player_record->side = RESOLVER_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 3) {
        player_record->side = RESOLVER_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 4) {
        player_record->side = RESOLVER_LOW_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 5) {
        player_record->side = RESOLVER_LOW_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] >= 6) {
        m_cvar()->ConsoleColorPrintf(Color(255, 0, 0), u8"èäè íàõóé, ýòî ñïðèä, ó òåáÿ êôã èññóå\n");
        csgo.globals.missed_shots[player->EntIndex()] = 0;
    }

}

float resolver::resolve_pitch()
{
}
*/

// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com

#include "animation_system.h"
#include "..\ragebot\aim.h"

void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;
    bool fake = false;
    fake = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

float flAngleMod(float flAngle)
{
    return((360.0f / 65536.0f) * ((int32_t)(flAngle * (65536.0f / 360.0f)) & 65530));
}

float ApproachAngle(float target, float value, float speed)
{
    target = flAngleMod(target);
    value = flAngleMod(value);

    float delta = target - value;

    if (speed < 0)
        speed = -speed;

    if (delta < -180)
        delta += 360;
    else if (delta > 180)
        delta -= 360;

    if (delta > speed)
        value += speed;
    else if (delta < -speed)
        value -= speed;
    else
        value = target;

    return value;
}

float AngleDiff(float destAngle, float srcAngle)
{
    float delta;

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

float GetChokedPackets(player_t* e)
{
    float simtime = e->m_flSimulationTime();
    float oldsimtime = e->m_flOldSimulationTime();
    float simdiff = simtime - oldsimtime;

    auto chokedpackets = TIME_TO_TICKS(max(0, simdiff));

    if (chokedpackets >= 1)
        return chokedpackets;

    return 0;
}


bool resolver::Side()
{
    AnimationLayer layers[13];
    AnimationLayer moveLayers[3][13];
    AnimationLayer preserver_anim_layers[13];

    auto speed = player->m_vecVelocity().Length2D();

    if (speed > 1.1f)
    {
        if (!layers[12].m_flWeight * 1000.f)
        {
            if ((layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f))
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);

                if (Positive >= EyeYaw || Positive >= Negative || (Positive * 1000.f))
                {
                    last_anims_update_time = m_globals()->m_realtime;
                    return true;
                }
            }
            else
            {
                last_anims_update_time = m_globals()->m_realtime;
                return false;
            }
        }
    }
    else if (layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f)
    {
        auto delta = std::remainder(math::normalize_yaw(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
        if (2 * delta)
        {
            if (2 * delta == 2)
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
}

bool resolver::DesyncDetect()
{
    if (!player->is_alive())
        return false;
    if (!player->m_fFlags() & FL_ONGROUND)
        return false;
    if (player->get_max_desync_delta() < 10)
        return false;
    if (!player->m_iTeamNum() == csgo.local()->m_iTeamNum())
        return false;
    if (GetChokedPackets(player) == 0)
        return false;
    if (!player->m_hActiveWeapon().Get()->can_fire(true))
        return false;

    return true;
}

void resolver::shitresolver()
{
    auto animstate = player->get_animation_state();

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

    float maxMovementSpeed = 260.0f;

    auto weapon = player->m_hActiveWeapon().Get();

    Vector velocity = player->m_vecVelocity();
    Vector animVelocity = GetSmoothedVelocity(m_clientstate()->iChokedCommands * 2000.0f, velocity, player->m_vecVelocity());

    float speed = std::fminf(animVelocity.Length(), 260.0f);
    float runningSpeed = speed / (maxMovementSpeed * 0.520f);
    float duckSpeed = speed / (maxMovementSpeed * 0.340);
    float yawModifer = (((animstate->m_bOnGround * -0.3f) - 0.2f) * runningSpeed) + 1.0f;
    float maxBodyYaw = *(float*)(uintptr_t(animstate) + 0x334) * yawModifer;
    float minBodyYaw = *(float*)(uintptr_t(animstate) + 0x330) * yawModifer;
    float eyeYaw = player->m_angEyeAngles().y;
    float left = eyeYaw - minBodyYaw;
    float right = eyeYaw + maxBodyYaw;
    float eyeDiff = std::remainderf(eyeYaw - original_goal_feet_yaw, 360.f);

    if (eyeDiff <= minBodyYaw)
    {
        if (minBodyYaw > eyeDiff)
            original_goal_feet_yaw = fabs(minBodyYaw) + eyeYaw;
    }
    else
    {
        original_goal_feet_yaw = eyeYaw - fabs(maxBodyYaw);
    }

    original_goal_feet_yaw = std::remainderf(original_goal_feet_yaw, 360.f);

    if (speed > 0.1f || fabs(velocity.z) > 100.0f)
    {
        original_goal_feet_yaw = ApproachAngle(
            eyeYaw,
            original_goal_feet_yaw,
            ((animstate->m_bOnGround * 15.0f) + 30.0f) * m_clientstate()->iChokedCommands
        );
    }
    else
    {
        original_goal_feet_yaw = ApproachAngle(
            player->m_flLowerBodyYawTarget(), original_goal_feet_yaw, m_clientstate()->iChokedCommands * 90.0f);
    }

    if (resolver::Side())
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        }
    }
    else
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        }
    }
}


void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!player || !player->get_animation_state() || !m_engine()->GetPlayerInfo(player->EntIndex(), &player_info) || player_info.fakeplayer || !resolver::DesyncDetect())
        return;

    if (csgo.globals.missed_shots[player->EntIndex()] <= 2)
    {
        resolver::shitresolver();
        return;
    }

    auto animstate = player->get_animation_state();
    float resolveValue;
    int resolveSide = resolver::Side() ? 1 : -1;

    if (player->m_vecVelocity().Length2D() > 1.1f && player->m_vecVelocity().Length2D() < 110.0f)
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            resolveValue = 30.0f;
            break;
        case 1:
            resolveValue = 58.0f;
            break;
        case 2:
            resolveValue = 19.0f;
            break;
        }
    }
    else
    {

            switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
            {
            case 0:
                resolveValue = 69.0f;
                break;
            case 1:
                resolveValue = 30.0f;
                break;
            case 2:
                resolveValue = 19.0f;
                break;
            }
    }

    if (resolveValue > player->get_max_desync_delta())
        resolveValue = player->get_max_desync_delta();

    player->get_animation_state()->m_flGoalFeetYaw = math::normalize_yaw(player->m_angEyeAngles().y + resolveValue * resolveSide);
    }
void resolver::skeetresik(player_t* e)
{
    if (!vars.ragebot.enable)
        return;

    auto anim_state = player->get_animation_state(); // get state

    static float v42, v56, v49,
        v51, v46;

    float desync_delta; // xmm0_4
    float v4; // xmm1_4
    float v5; // xmm1_4
    float v6; // xmm1_4
    float v7; // xmm1_4
    float v8; // xmm1_4
    float v9; // xmm1_4

    if (anim_state->m_fDuckAmount > 0.0)
    {
        auto v29 = 0.0;
        if (anim_state->m_flFeetSpeedUnknownForwardOrSideways < 0.0)
            v29 = 0.0;

        float v52 = anim_state->m_fDuckAmount * v51;
        v49 = v49 + (float)(v52 * (float)(0.5 - v49));
    }

    float v47 = (float)((anim_state->m_flStopToFullRunningFraction * -0.30000001f) - 0.19999999f) * v46;
    v49 = v47 + 1.0;

    float speed;
    if (*(float*)(anim_state + 0xF8) < 0.f)
    {
        speed = 0.0;
    }
    else
    {
        speed = fminf(*(DWORD*)(anim_state + 0xF8), 1.0f);
    }
    float flYawModifier = (*(float*)(anim_state + 0x11C) * -0.30000001 - 0.19999999) * speed;
    desync_delta = flYawModifier * 58.0;
    switch (csgo.globals.missed_shots[player->EntIndex()] % 4)
    {
    case 1:
        v4 = anim_state->m_flGoalFeetYaw + (desync_delta + desync_delta);
        if (v4 > 180.0 || v4 < -180.0)
            break;
    case 2:
        v5 = anim_state->m_flGoalFeetYaw + (desync_delta * 0.5);
        if (v5 > 180.0 || v5 < -180.0)
            break;
    case 4:
        v6 = anim_state->m_flGoalFeetYaw + (desync_delta * -0.5);
        if (v6 > 180.0 || v6 < -180.0)
            break;
    case 5:
        v8 = anim_state->m_flGoalFeetYaw - (desync_delta + desync_delta);
        if (v8 > 180.0 || v8 < -180.0)
            break;
    case 7:
        v9 = anim_state->m_flGoalFeetYaw + 120.0;
        if ((anim_state->m_flGoalFeetYaw + 120.0) > 180.0 || v9 < -180.0)
            break;
    case 8:
        v7 = anim_state->m_flGoalFeetYaw + -120.0;
        if ((anim_state->m_flGoalFeetYaw + -120.0) > 180.0 || v7 < -180.0)
            break;
    default:
        return;
    }
    float lby_delta = e->m_flLowerBodyYawTarget();
    lby_delta = std::remainderf(lby_delta, 360.f);
    lby_delta = math::clamp(lby_delta, -60.f, 60.f);

    float v73 = std::remainderf(lby_delta, 360.f);

    if (v73 < 0.f) {
        v73 += 360.f;
    }

    static int v36;
    if (anim_state)
    {
        if (csgo.globals.missed_shots[e->EntIndex()] <= 2) {

            if (v36 > 180.0)
                v36 = v36 - 360.0;
            if (v36 < 180.0)
                v36 = v36 + 360.0;
            anim_state->m_flGoalFeetYaw = v36;
        }
    }

    float v25 = math::clamp(anim_state->m_fDuckAmount + anim_state->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
    float v26 = anim_state->m_fDuckAmount;
    float v27 = 6.0f;
    float v28;

    if ((v25 - v26) <= v27) { // clamp
        if (-v27 <= (v25 - v26))
            v28 = v25;
        else
            v28 = v26 - v27;
    }
    else {
        v28 = v26 + v27;
    }
}

void resolver::ResolveAngles(player_t* player)
{
    // lets be real this is the most p thing we ever seen
    float m_flResolveValue;
    int m_flResolveSide;
    AnimationLayer layers[15];
    AnimationLayer moveLayers[3][15];
    int m_flSide;
    bool m_bAnimatePlayer;
    bool m_bAnimsUpdated;
    bool m_bResolve;
    bool m_flPreviousDelta;
    // yee jarvis nanotechnology please.
   // ok sir...
  // fly mode activated

    if (player->is_alive() && !player->is_player())
    {
        if (!(player->m_fFlags() & FL_ONGROUND))
        {
            m_flResolveSide = 0;
        }
        auto standing = layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f;
        auto animating = layers[12].m_flWeight * 1000.f;
        auto moving = !animating && (layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f);

        float m_flSpeed = player->m_vecVelocity().Length2D();
        if (m_flSpeed > 1.1f)
        {
            if (moving)
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                if (Positive > EyeYaw || Positive >= Negative || (Positive * 1000.0))
                {
                    if (EyeYaw >= Negative && Positive > Negative && !(Negative * 1000.0))
                    {
                        m_bAnimsUpdated = true;
                        m_bResolve = true;
                        m_flSide = 1;
                    }
                }
                else
                {
                    m_bAnimsUpdated = true;
                    m_bResolve = true;
                    m_flSide = -1;
                }
            }
        }
        else if (standing)
        {
            auto m_flEyeDelta = std::remainderf(math::NormalizedAngle(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
            if (2 * m_flEyeDelta)
            {
                if (2 * m_flEyeDelta == 2)
                {
                    m_flSide = -1;
                }
            }
            else
            {
                m_flSide = 1;
            }
            m_bResolve = true;
            m_flPreviousDelta = m_flEyeDelta;
        }
        m_flResolveValue = 58.f;
        player->get_animation_state()->m_flGoalFeetYaw = math::NormalizedAngle(player->m_angEyeAngles().y + m_flResolveValue * m_flSide);

    }

}


float resolver::resolve_pitch()
{
    return original_pitch;
}
выглядит очень похоже как смешали понос и говно после активируваного угля,после того как поел в МБОУ СОШ
 
n00bie
Пользователь
Статус
Оффлайн
Регистрация
10 Июн 2020
Сообщения
91
Реакции[?]
43
Поинты[?]
1K
C++:
/*
#include "animstates.h"
#include "..\ragebot\aim.h"
void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

    bool resolver::low_delta()
    {
        auto record = player_record;
        if (!csgo.local()->is_alive())
            return false;
        float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
        Vector first = ZERO, second = ZERO, third = ZERO;
        first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
        third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 35), player->hitbox_position(HITBOX_HEAD).z);
        Ray_t one, two, three;
        trace_t tone, ttwo, ttree;
        CTraceFilter fl;
        fl.pSkip = player;
        one.Init(csgo.local()->get_shoot_position(), first);
        two.Init(csgo.local()->get_shoot_position(), second);
        three.Init(csgo.local()->get_shoot_position(), third);
        m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
        m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
        m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
        if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
            return true;

        float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
        if (lby < 35 && lby > -35)
            return true;
        return false;
    }

bool resolver::low_delta2()
{
    auto record = player_record;
    if (!csgo.local()->is_alive())
        return false;
    float angle_diff = math::angle_diff(player->m_angEyeAngles().y, player->get_animation_state()->m_flGoalFeetYaw);
    Vector first = ZERO, second = ZERO, third = ZERO;
    first = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y + min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    second = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y, player->hitbox_position(HITBOX_HEAD).z);
    third = Vector(player->hitbox_position(HITBOX_HEAD).x, player->hitbox_position(HITBOX_HEAD).y - min(angle_diff, 20), player->hitbox_position(HITBOX_HEAD).z);
    Ray_t one, two, three;
    trace_t tone, ttwo, ttree;
    CTraceFilter fl;
    fl.pSkip = player;
    one.Init(csgo.local()->get_shoot_position(), first);
    two.Init(csgo.local()->get_shoot_position(), second);
    three.Init(csgo.local()->get_shoot_position(), third);
    m_trace()->TraceRay(one, MASK_PLAYERSOLID, &fl, &tone);
    m_trace()->TraceRay(two, MASK_PLAYERSOLID, &fl, &ttwo);
    m_trace()->TraceRay(three, MASK_PLAYERSOLID, &fl, &ttree);
    if (!tone.allsolid && !ttwo.allsolid && !ttree.allsolid && tone.fraction < 0.97 && ttwo.fraction < 0.97 && ttree.fraction < 0.97)
        return true;

    float lby = fabs(math::normalize_yaw(player->m_flLowerBodyYawTarget()));
    if (lby < 20 && lby > -20)
        return true;
    return false;
}

float resolver::GetBackwardYaw(player_t* ent) {
    return math::calculate_angle(csgo.local()->GetAbsOrigin(), ent->GetAbsOrigin()).y;
}

float resolver::GetForwardYaw(player_t* ent) {
    return math::normalize_yaw(GetBackwardYaw(ent) - 180.f);
}

void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!m_engine()->GetPlayerInfo(player->EntIndex(), &player_info))
        return;

    static int side[63];
    auto animstate  = player->get_animation_state();
    auto speed = csgo.local()->m_vecVelocity().Length2D();
    if (speed <= 0.1f)
    {
        if (player_record->layers[3].m_flWeight == 0.0 && player_record->layers[3].m_flCycle == 0.0)
        {
            side[player->EntIndex()] = 2 * (math::normalize_diff(player->m_angEyeAngles().y, player_record->abs_angles.y) <= 0.0) - 1;
        }
    }
    else
    {
        const float f_delta = abs(player_record->layers[6].m_flPlaybackRate -   player_record->left_layers[6].m_flPlaybackRate);
        const float s_delta = abs(player_record->layers[6].m_flPlaybackRate - player_record->center_layers[6].m_flPlaybackRate);
        const float t_delta = abs(player_record->layers[6].m_flPlaybackRate -  player_record->right_layers[6].m_flPlaybackRate);

        if (f_delta < s_delta || t_delta <= s_delta || (s_delta * 1000.0))
        {
            if (f_delta >= t_delta && s_delta > t_delta && !(t_delta * 1000.0))
            {
                side[player->EntIndex()] = 1;
            }
        }
        else
        {
            side[player->EntIndex()] = -1;
        }
    }

    if (player->GetAbsOrigin().y == GetForwardYaw(player))
        side[player->EntIndex()] *= -1;
   
    if (csgo.globals.missed_shots[player->EntIndex()] == 0) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta() ? RESOLVER_LOW_FIRST : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta() ? RESOLVER_LOW_SECOND : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 1) {
        if (side[player->EntIndex()] >= 1) {
            //right
            player_record->side = low_delta2() ? RESOLVER_LOW_FIRST1 : RESOLVER_FIRST;
        }
        else if (side[player->EntIndex()] <= -1) {
            //left
            player_record->side = low_delta2() ? RESOLVER_LOW_SECOND1 : RESOLVER_SECOND;
        }
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 2) {
        player_record->side = RESOLVER_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 3) {
        player_record->side = RESOLVER_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 4) {
        player_record->side = RESOLVER_LOW_FIRST;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] == 5) {
        player_record->side = RESOLVER_LOW_SECOND;
    }
    else if (csgo.globals.missed_shots[player->EntIndex()] >= 6) {
        m_cvar()->ConsoleColorPrintf(Color(255, 0, 0), u8"èäè íàõóé, ýòî ñïðèä, ó òåáÿ êôã èññóå\n");
        csgo.globals.missed_shots[player->EntIndex()] = 0;
    }

}

float resolver::resolve_pitch()
{
}
*/

// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com

#include "animation_system.h"
#include "..\ragebot\aim.h"

void resolver::initialize(player_t* e, adjust_data* record, const float& goal_feet_yaw, const float& pitch)
{
    player = e;
    player_record = record;

    original_goal_feet_yaw = math::normalize_yaw(goal_feet_yaw);
    original_pitch = math::normalize_pitch(pitch);
}

void resolver::reset()
{
    player = nullptr;
    player_record = nullptr;

    side = false;
    bool fake = false;
    fake = false;

    was_first_bruteforce = false;
    was_second_bruteforce = false;

    original_goal_feet_yaw = 0.0f;
    original_pitch = 0.0f;
}

Vector player_t::get_eye_pos() {
    return m_vecOrigin() + m_vecViewOffset();
}

float flAngleMod(float flAngle)
{
    return((360.0f / 65536.0f) * ((int32_t)(flAngle * (65536.0f / 360.0f)) & 65530));
}

float ApproachAngle(float target, float value, float speed)
{
    target = flAngleMod(target);
    value = flAngleMod(value);

    float delta = target - value;

    if (speed < 0)
        speed = -speed;

    if (delta < -180)
        delta += 360;
    else if (delta > 180)
        delta -= 360;

    if (delta > speed)
        value += speed;
    else if (delta < -speed)
        value -= speed;
    else
        value = target;

    return value;
}

float AngleDiff(float destAngle, float srcAngle)
{
    float delta;

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

float GetChokedPackets(player_t* e)
{
    float simtime = e->m_flSimulationTime();
    float oldsimtime = e->m_flOldSimulationTime();
    float simdiff = simtime - oldsimtime;

    auto chokedpackets = TIME_TO_TICKS(max(0, simdiff));

    if (chokedpackets >= 1)
        return chokedpackets;

    return 0;
}


bool resolver::Side()
{
    AnimationLayer layers[13];
    AnimationLayer moveLayers[3][13];
    AnimationLayer preserver_anim_layers[13];

    auto speed = player->m_vecVelocity().Length2D();

    if (speed > 1.1f)
    {
        if (!layers[12].m_flWeight * 1000.f)
        {
            if ((layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f))
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);

                if (Positive >= EyeYaw || Positive >= Negative || (Positive * 1000.f))
                {
                    last_anims_update_time = m_globals()->m_realtime;
                    return true;
                }
            }
            else
            {
                last_anims_update_time = m_globals()->m_realtime;
                return false;
            }
        }
    }
    else if (layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f)
    {
        auto delta = std::remainder(math::normalize_yaw(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
        if (2 * delta)
        {
            if (2 * delta == 2)
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
}

bool resolver::DesyncDetect()
{
    if (!player->is_alive())
        return false;
    if (!player->m_fFlags() & FL_ONGROUND)
        return false;
    if (player->get_max_desync_delta() < 10)
        return false;
    if (!player->m_iTeamNum() == csgo.local()->m_iTeamNum())
        return false;
    if (GetChokedPackets(player) == 0)
        return false;
    if (!player->m_hActiveWeapon().Get()->can_fire(true))
        return false;

    return true;
}

void resolver::shitresolver()
{
    auto animstate = player->get_animation_state();

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

    float maxMovementSpeed = 260.0f;

    auto weapon = player->m_hActiveWeapon().Get();

    Vector velocity = player->m_vecVelocity();
    Vector animVelocity = GetSmoothedVelocity(m_clientstate()->iChokedCommands * 2000.0f, velocity, player->m_vecVelocity());

    float speed = std::fminf(animVelocity.Length(), 260.0f);
    float runningSpeed = speed / (maxMovementSpeed * 0.520f);
    float duckSpeed = speed / (maxMovementSpeed * 0.340);
    float yawModifer = (((animstate->m_bOnGround * -0.3f) - 0.2f) * runningSpeed) + 1.0f;
    float maxBodyYaw = *(float*)(uintptr_t(animstate) + 0x334) * yawModifer;
    float minBodyYaw = *(float*)(uintptr_t(animstate) + 0x330) * yawModifer;
    float eyeYaw = player->m_angEyeAngles().y;
    float left = eyeYaw - minBodyYaw;
    float right = eyeYaw + maxBodyYaw;
    float eyeDiff = std::remainderf(eyeYaw - original_goal_feet_yaw, 360.f);

    if (eyeDiff <= minBodyYaw)
    {
        if (minBodyYaw > eyeDiff)
            original_goal_feet_yaw = fabs(minBodyYaw) + eyeYaw;
    }
    else
    {
        original_goal_feet_yaw = eyeYaw - fabs(maxBodyYaw);
    }

    original_goal_feet_yaw = std::remainderf(original_goal_feet_yaw, 360.f);

    if (speed > 0.1f || fabs(velocity.z) > 100.0f)
    {
        original_goal_feet_yaw = ApproachAngle(
            eyeYaw,
            original_goal_feet_yaw,
            ((animstate->m_bOnGround * 15.0f) + 30.0f) * m_clientstate()->iChokedCommands
        );
    }
    else
    {
        original_goal_feet_yaw = ApproachAngle(
            player->m_flLowerBodyYawTarget(), original_goal_feet_yaw, m_clientstate()->iChokedCommands * 90.0f);
    }

    if (resolver::Side())
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        }
    }
    else
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(left);
            break;
        case 1:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(original_goal_feet_yaw);
            break;
        case 2:
            animstate->m_flGoalFeetYaw = math::normalize_yaw(right);
            break;
        }
    }
}


void resolver::resolve_yaw()
{
    player_info_t player_info;

    if (!player || !player->get_animation_state() || !m_engine()->GetPlayerInfo(player->EntIndex(), &player_info) || player_info.fakeplayer || !resolver::DesyncDetect())
        return;

    if (csgo.globals.missed_shots[player->EntIndex()] <= 2)
    {
        resolver::shitresolver();
        return;
    }

    auto animstate = player->get_animation_state();
    float resolveValue;
    int resolveSide = resolver::Side() ? 1 : -1;

    if (player->m_vecVelocity().Length2D() > 1.1f && player->m_vecVelocity().Length2D() < 110.0f)
    {
        switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
        {
        case 0:
            resolveValue = 30.0f;
            break;
        case 1:
            resolveValue = 58.0f;
            break;
        case 2:
            resolveValue = 19.0f;
            break;
        }
    }
    else
    {

            switch (csgo.globals.missed_shots[player->EntIndex()] % 3)
            {
            case 0:
                resolveValue = 69.0f;
                break;
            case 1:
                resolveValue = 30.0f;
                break;
            case 2:
                resolveValue = 19.0f;
                break;
            }
    }

    if (resolveValue > player->get_max_desync_delta())
        resolveValue = player->get_max_desync_delta();

    player->get_animation_state()->m_flGoalFeetYaw = math::normalize_yaw(player->m_angEyeAngles().y + resolveValue * resolveSide);
    }
void resolver::skeetresik(player_t* e)
{
    if (!vars.ragebot.enable)
        return;

    auto anim_state = player->get_animation_state(); // get state

    static float v42, v56, v49,
        v51, v46;

    float desync_delta; // xmm0_4
    float v4; // xmm1_4
    float v5; // xmm1_4
    float v6; // xmm1_4
    float v7; // xmm1_4
    float v8; // xmm1_4
    float v9; // xmm1_4

    if (anim_state->m_fDuckAmount > 0.0)
    {
        auto v29 = 0.0;
        if (anim_state->m_flFeetSpeedUnknownForwardOrSideways < 0.0)
            v29 = 0.0;

        float v52 = anim_state->m_fDuckAmount * v51;
        v49 = v49 + (float)(v52 * (float)(0.5 - v49));
    }

    float v47 = (float)((anim_state->m_flStopToFullRunningFraction * -0.30000001f) - 0.19999999f) * v46;
    v49 = v47 + 1.0;

    float speed;
    if (*(float*)(anim_state + 0xF8) < 0.f)
    {
        speed = 0.0;
    }
    else
    {
        speed = fminf(*(DWORD*)(anim_state + 0xF8), 1.0f);
    }
    float flYawModifier = (*(float*)(anim_state + 0x11C) * -0.30000001 - 0.19999999) * speed;
    desync_delta = flYawModifier * 58.0;
    switch (csgo.globals.missed_shots[player->EntIndex()] % 4)
    {
    case 1:
        v4 = anim_state->m_flGoalFeetYaw + (desync_delta + desync_delta);
        if (v4 > 180.0 || v4 < -180.0)
            break;
    case 2:
        v5 = anim_state->m_flGoalFeetYaw + (desync_delta * 0.5);
        if (v5 > 180.0 || v5 < -180.0)
            break;
    case 4:
        v6 = anim_state->m_flGoalFeetYaw + (desync_delta * -0.5);
        if (v6 > 180.0 || v6 < -180.0)
            break;
    case 5:
        v8 = anim_state->m_flGoalFeetYaw - (desync_delta + desync_delta);
        if (v8 > 180.0 || v8 < -180.0)
            break;
    case 7:
        v9 = anim_state->m_flGoalFeetYaw + 120.0;
        if ((anim_state->m_flGoalFeetYaw + 120.0) > 180.0 || v9 < -180.0)
            break;
    case 8:
        v7 = anim_state->m_flGoalFeetYaw + -120.0;
        if ((anim_state->m_flGoalFeetYaw + -120.0) > 180.0 || v7 < -180.0)
            break;
    default:
        return;
    }
    float lby_delta = e->m_flLowerBodyYawTarget();
    lby_delta = std::remainderf(lby_delta, 360.f);
    lby_delta = math::clamp(lby_delta, -60.f, 60.f);

    float v73 = std::remainderf(lby_delta, 360.f);

    if (v73 < 0.f) {
        v73 += 360.f;
    }

    static int v36;
    if (anim_state)
    {
        if (csgo.globals.missed_shots[e->EntIndex()] <= 2) {

            if (v36 > 180.0)
                v36 = v36 - 360.0;
            if (v36 < 180.0)
                v36 = v36 + 360.0;
            anim_state->m_flGoalFeetYaw = v36;
        }
    }

    float v25 = math::clamp(anim_state->m_fDuckAmount + anim_state->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
    float v26 = anim_state->m_fDuckAmount;
    float v27 = 6.0f;
    float v28;

    if ((v25 - v26) <= v27) { // clamp
        if (-v27 <= (v25 - v26))
            v28 = v25;
        else
            v28 = v26 - v27;
    }
    else {
        v28 = v26 + v27;
    }
}

void resolver::ResolveAngles(player_t* player)
{
    // lets be real this is the most p thing we ever seen
    float m_flResolveValue;
    int m_flResolveSide;
    AnimationLayer layers[15];
    AnimationLayer moveLayers[3][15];
    int m_flSide;
    bool m_bAnimatePlayer;
    bool m_bAnimsUpdated;
    bool m_bResolve;
    bool m_flPreviousDelta;
    // yee jarvis nanotechnology please.
   // ok sir...
  // fly mode activated

    if (player->is_alive() && !player->is_player())
    {
        if (!(player->m_fFlags() & FL_ONGROUND))
        {
            m_flResolveSide = 0;
        }
        auto standing = layers[3].m_flWeight == 0.0f && layers[3].m_flCycle == 0.0f;
        auto animating = layers[12].m_flWeight * 1000.f;
        auto moving = !animating && (layers[6].m_flWeight * 1000.f) == (layers[6].m_flWeight * 1000.f);

        float m_flSpeed = player->m_vecVelocity().Length2D();
        if (m_flSpeed > 1.1f)
        {
            if (moving)
            {
                float EyeYaw = fabs(layers[6].m_flPlaybackRate - moveLayers[0][6].m_flPlaybackRate);
                float Negative = fabs(layers[6].m_flPlaybackRate - moveLayers[2][6].m_flPlaybackRate);
                float Positive = fabs(layers[6].m_flPlaybackRate - moveLayers[1][6].m_flPlaybackRate);
                if (Positive > EyeYaw || Positive >= Negative || (Positive * 1000.0))
                {
                    if (EyeYaw >= Negative && Positive > Negative && !(Negative * 1000.0))
                    {
                        m_bAnimsUpdated = true;
                        m_bResolve = true;
                        m_flSide = 1;
                    }
                }
                else
                {
                    m_bAnimsUpdated = true;
                    m_bResolve = true;
                    m_flSide = -1;
                }
            }
        }
        else if (standing)
        {
            auto m_flEyeDelta = std::remainderf(math::NormalizedAngle(player->m_angEyeAngles().y - player->m_flLowerBodyYawTarget()), 360.f) <= 0.f;
            if (2 * m_flEyeDelta)
            {
                if (2 * m_flEyeDelta == 2)
                {
                    m_flSide = -1;
                }
            }
            else
            {
                m_flSide = 1;
            }
            m_bResolve = true;
            m_flPreviousDelta = m_flEyeDelta;
        }
        m_flResolveValue = 58.f;
        player->get_animation_state()->m_flGoalFeetYaw = math::NormalizedAngle(player->m_angEyeAngles().y + m_flResolveValue * m_flSide);

    }

}


float resolver::resolve_pitch()
{
    return original_pitch;
}
ну зачем ты слил супериор резольвер своего чита
 
Сверху Снизу