Подпишитесь на наш Telegram-канал, чтобы всегда быть в курсе важных обновлений! Перейти
Что нового?

Исходник Rawetrip resolver

popugapopugay
Участник
P
Участник
Статус
Оффлайн
Регистрация
8 Янв 2020
Сообщения
427
Реакции
224
Rawetrip resolver.

Возможно вронг.

C++:
Expand Collapse Copy 
void Resolver::Initialize(Player* m_player, Record* m_record, float m_feet_yaw, float m_pitch)
{
    player = m_player;
    record = m_record;

    goalfeetyaw = Math::NormalizeYaw(m_feet_yaw);
    pitch = Math::NormalizePitch(m_pitch);
}

void Resolver::ResolvePitch()
{
    return pitch;
}

void Resolver::ResolveYaw()
{
    if (!local_player->alive() || !player->enemy())
    {
        player_record->side = RESOLVER_ORIGINAL;
        return;
    }

    bool BruteforceResolve = (record->resolver_type != LBY);

    if (BruteforceResolve)
    {
        switch (ResolverSide)
        {
        case RESOLVER_ORIGINAL:
            record->resolver_side = RESOLVER_ORIGINAL;
            record->resolver_type = BRUTEFORCE;
            break;
        case RESOLVER_ZERO:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_POSITIVE;

            brutforced_first = false;
            brutforced_second = false;
            return;
        case RESOLVER_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_second)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_NEGATIVE;

            record->resolver_side = resolver_side;
            brutforced_first = true;
            return;
        case RESOLVER_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_first)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_POSITIVE;

            record->resolver_side = resolver_side;
            brutforced_second = true;
            return;
        case RESOLVER_LOW_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_NEGATIVE;
            return;
        case RESOLVER_LOW_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_POSITIVE;
            return;
        }
    }

    animstate* animation_state = player->get_animstate();

    if (!animation_state)
    {
        record->resolver_side = RESOLVER_ORIGINAL;
        return;
    }

    float delta = Math::NormalizeYaw(player->eye_angles().y - goalfeetyaw);

    if (delta > 30.0 && valid_lby)
    {
        if (globals.missed_shots > 0)
            delta = -delta;

        if (delta <= 30.0)
        {
            if (delta < -30.0)
            {
                record->resolver_type = LBY;
                record->resolver_side = RESOLVER_NEGATIVE;
            }
        }
        else
        {
            record->resolver_type = LBY;
            record->resolver_side = RESOLVER_POSITIVE;
        }
    }
    else
    {
        bool trace = false;

        if (globals.curtime - previous_curtime > 2.0f)
        {
            bool first = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_positive), player, localplayer);
            bool second = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_negative), player, localplayer);

            bool positive = false;

            if (first == second)
            {
                float first2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_positive));
                float second2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_negative));

                if (Math::SecondFabs(first2 - second2) > 1.0f)
                    positive = first2 > second2;
            }
            else
            {
                trace = true;
                positive = second;
                previous_curtime = globals.curtime;
            }
        }
        else
            trace = true;

        if (positive)
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_POSITIVE;
        }
        else
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_NEGATIVE;
        }
    }

    bool low_pitch = (animation_state->eye_pitch < 20.0 && animation_state->eye_pitch > -20.0);

    if (low_pitch)
    {
        float feet_yaw = animation_state->goalfeetyaw;

        if (animation_state)
        {
            float lby_delta = player->eye_angles().yaw - player->lby();
            bool lby_stand = lby_delta > 35.0 && player->velocity().length_2d() < 5;

            if (!lby_stand)
                feet_yaw += lby_delta;
            
            animation_state->goalfeetyaw = feet_yaw;
        }
    }
    else
    {
        record->resolver_side = RESOLVER_ORIGINAL;
    }
}
 
popugapopugay написал(а):
Rawetrip resolver.

Возможно вронг.

C++:
Expand Collapse Copy 
void Resolver::Initialize(Player* m_player, Record* m_record, float m_feet_yaw, float m_pitch)
{
    player = m_player;
    record = m_record;

    goalfeetyaw = Math::NormalizeYaw(m_feet_yaw);
    pitch = Math::NormalizePitch(m_pitch);
}

void Resolver::ResolvePitch()
{
    return pitch;
}

void Resolver::ResolveYaw()
{
    if (!local_player->alive() || !player->enemy())
    {
        player_record->side = RESOLVER_ORIGINAL;
        return;
    }

    bool BruteforceResolve = (record->resolver_type != LBY);

    if (BruteforceResolve)
    {
        switch (ResolverSide)
        {
        case RESOLVER_ORIGINAL:
            record->resolver_side = RESOLVER_ORIGINAL;
            record->resolver_type = BRUTEFORCE;
            break;
        case RESOLVER_ZERO:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_POSITIVE;

            brutforced_first = false;
            brutforced_second = false;
            return;
        case RESOLVER_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_second)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_NEGATIVE;

            record->resolver_side = resolver_side;
            brutforced_first = true;
            return;
        case RESOLVER_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_first)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_POSITIVE;

            record->resolver_side = resolver_side;
            brutforced_second = true;
            return;
        case RESOLVER_LOW_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_NEGATIVE;
            return;
        case RESOLVER_LOW_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_POSITIVE;
            return;
        }
    }

    animstate* animation_state = player->get_animstate();

    if (!animation_state)
    {
        record->resolver_side = RESOLVER_ORIGINAL;
        return;
    }

    float delta = Math::NormalizeYaw(player->eye_angles().y - goalfeetyaw);

    if (delta > 30.0 && valid_lby)
    {
        if (globals.missed_shots > 0)
            delta = -delta;

        if (delta <= 30.0)
        {
            if (delta < -30.0)
            {
                record->resolver_type = LBY;
                record->resolver_side = RESOLVER_NEGATIVE;
            }
        }
        else
        {
            record->resolver_type = LBY;
            record->resolver_side = RESOLVER_POSITIVE;
        }
    }
    else
    {
        bool trace = false;

        if (globals.curtime - previous_curtime > 2.0f)
        {
            bool first = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_positive), player, localplayer);
            bool second = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_negative), player, localplayer);

            bool positive = false;

            if (first == second)
            {
                float first2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_positive));
                float second2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_negative));

                if (Math::SecondFabs(first2 - second2) > 1.0f)
                    positive = first2 > second2;
            }
            else
            {
                trace = true;
                positive = second;
                previous_curtime = globals.curtime;
            }
        }
        else
            trace = true;

        if (positive)
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_POSITIVE;
        }
        else
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_NEGATIVE;
        }
    }

    bool low_pitch = (animation_state->eye_pitch < 20.0 && animation_state->eye_pitch > -20.0);

    if (low_pitch)
    {
        float feet_yaw = animation_state->goalfeetyaw;

        if (animation_state)
        {
            float lby_delta = player->eye_angles().yaw - player->lby();
            bool lby_stand = lby_delta > 35.0 && player->velocity().length_2d() < 5;

            if (!lby_stand)
                feet_yaw += lby_delta;
           
            animation_state->goalfeetyaw = feet_yaw;
        }
    }
    else
    {
        record->resolver_side = RESOLVER_ORIGINAL;
    }
}
Нажмите для раскрытия...
ахуеть, не знаю фейк или нет, но блять с таким ресольвером ты даже бота в голову не убьешь
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
popugapopugay написал(а):
Rawetrip resolver.

Возможно вронг.

C++:
Expand Collapse Copy 
void Resolver::Initialize(Player* m_player, Record* m_record, float m_feet_yaw, float m_pitch)
{
    player = m_player;
    record = m_record;

    goalfeetyaw = Math::NormalizeYaw(m_feet_yaw);
    pitch = Math::NormalizePitch(m_pitch);
}

void Resolver::ResolvePitch()
{
    return pitch;
}

void Resolver::ResolveYaw()
{
    if (!local_player->alive() || !player->enemy())
    {
        player_record->side = RESOLVER_ORIGINAL;
        return;
    }

    bool BruteforceResolve = (record->resolver_type != LBY);

    if (BruteforceResolve)
    {
        switch (ResolverSide)
        {
        case RESOLVER_ORIGINAL:
            record->resolver_side = RESOLVER_ORIGINAL;
            record->resolver_type = BRUTEFORCE;
            break;
        case RESOLVER_ZERO:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_POSITIVE;

            brutforced_first = false;
            brutforced_second = false;
            return;
        case RESOLVER_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_second)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_NEGATIVE;

            record->resolver_side = resolver_side;
            brutforced_first = true;
            return;
        case RESOLVER_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_first)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_POSITIVE;

            record->resolver_side = resolver_side;
            brutforced_second = true;
            return;
        case RESOLVER_LOW_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_NEGATIVE;
            return;
        case RESOLVER_LOW_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_POSITIVE;
            return;
        }
    }

    animstate* animation_state = player->get_animstate();

    if (!animation_state)
    {
        record->resolver_side = RESOLVER_ORIGINAL;
        return;
    }

    float delta = Math::NormalizeYaw(player->eye_angles().y - goalfeetyaw);

    if (delta > 30.0 && valid_lby)
    {
        if (globals.missed_shots > 0)
            delta = -delta;

        if (delta <= 30.0)
        {
            if (delta < -30.0)
            {
                record->resolver_type = LBY;
                record->resolver_side = RESOLVER_NEGATIVE;
            }
        }
        else
        {
            record->resolver_type = LBY;
            record->resolver_side = RESOLVER_POSITIVE;
        }
    }
    else
    {
        bool trace = false;

        if (globals.curtime - previous_curtime > 2.0f)
        {
            bool first = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_positive), player, localplayer);
            bool second = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_negative), player, localplayer);

            bool positive = false;

            if (first == second)
            {
                float first2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_positive));
                float second2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_negative));

                if (Math::SecondFabs(first2 - second2) > 1.0f)
                    positive = first2 > second2;
            }
            else
            {
                trace = true;
                positive = second;
                previous_curtime = globals.curtime;
            }
        }
        else
            trace = true;

        if (positive)
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_POSITIVE;
        }
        else
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_NEGATIVE;
        }
    }

    bool low_pitch = (animation_state->eye_pitch < 20.0 && animation_state->eye_pitch > -20.0);

    if (low_pitch)
    {
        float feet_yaw = animation_state->goalfeetyaw;

        if (animation_state)
        {
            float lby_delta = player->eye_angles().yaw - player->lby();
            bool lby_stand = lby_delta > 35.0 && player->velocity().length_2d() < 5;

            if (!lby_stand)
                feet_yaw += lby_delta;
           
            animation_state->goalfeetyaw = feet_yaw;
        }
    }
    else
    {
        record->resolver_side = RESOLVER_ORIGINAL;
    }
}
Нажмите для раскрытия...
только вот почему std::fabs превратился в какой то second_fabs это не понятно
 
popugapopugay написал(а):
Rawetrip resolver.

Possibly Wrong.

C++:
Expand Collapse Copy 
void Resolver::Initialize(Player* m_player, Record* m_record, float m_feet_yaw, float m_pitch)
{
    player = m_player;
    record = m_record;

    goalfeetyaw = Math::NormalizeYaw(m_feet_yaw);
    pitch = Math::NormalizePitch(m_pitch);
}

void Resolver::ResolvePitch()
{
    return pitch;
}

void Resolver::ResolveYaw()
{
    if (!local_player->alive() || !player->enemy())
    {
        player_record->side = RESOLVER_ORIGINAL;
        return;
    }

    bool BruteforceResolve = (record->resolver_type != LBY);

    if (BruteforceResolve)
    {
        switch(ResolverSide)
        {
        case RESOLVER_ORIGINAL:
            record->resolver_side = RESOLVER_ORIGINAL;
            record->resolver_type = BRUTEFORCE;
            break;
        case RESOLVER_ZERO:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_POSITIVE;

            brutforced_first = false;
            brutforced_second = false;
            return;
        case RESOLVER_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_second)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_NEGATIVE;

            record->resolver_side = resolver_side;
            brutforced_first = true;
            return;
        case RESOLVER_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_first)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_POSITIVE;

            record->resolver_side = resolver_side;
            brutforced_second = true;
            return;
        case RESOLVER_LOW_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_NEGATIVE;
            return;
        case RESOLVER_LOW_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_POSITIVE;
            return;
        }
    }

    animstate* animation_state = player->get_animstate();

    if (!animation_state)
    {
        record->resolver_side = RESOLVER_ORIGINAL;
        return;
    }

    float delta = Math::NormalizeYaw(player->eye_angles().y - goalfeetyaw);

    if (delta > 30.0 && valid_lby)
    {
        if (globals.missed_shots > 0)
            delta=-delta;

        if (delta <= 30.0)
        {
            if (delta < -30.0)
            {
                record->resolver_type = LBY;
                record->resolver_side = RESOLVER_NEGATIVE;
            }
        }
        else
        {
            record->resolver_type = LBY;
            record->resolver_side = RESOLVER_POSITIVE;
        }
    }
    else
    {
        bool trace = false;

        if (globals.curtime - previous_curtime > 2.0f)
        {
            bool first = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_positive), player, localplayer);
            bool second = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_negative), player, localplayer);

            bool positive = false;

            if (first == second)
            {
                float first2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_positive));
                float second2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_negative));

                if (Math::SecondFabs(first2 - second2) > 1.0f)
                    positive = first2 > second2;
            }
            else
            {
                trace = true;
                positive = second;
                previous_curtime = globals.curtime;
            }
        }
        else
            trace = true;

        if (positive)
        {
            inttype=ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type=DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_POSITIVE;
        }
        else
        {
            inttype=ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type=DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_NEGATIVE;
        }
    }

    bool low_pitch = (animation_state->eye_pitch < 20.0 && animation_state->eye_pitch > -20.0);

    if (low_pitch)
    {
        float feet_yaw = animation_state->goalfeetyaw;

        if(animation_state)
        {
            float lby_delta = player->eye_angles().yaw - player->lby();
            bool lby_stand = lby_delta > 35.0 && player->velocity().length_2d() < 5;

            if (!lby_stand)
                feet_yaw += lby_delta;
         
            animation_state->goalfeetyaw = feet_yaw;
        }
    }
    else
    {
        record->resolver_side = RESOLVER_ORIGINAL;
    }
}
Нажмите для раскрытия...
Looks like a shittier version of def lw resolver, however I thought rawetrip used animlayers?
Maybe reverse the visuals instead because they are the only decent part.
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
USSR-Lover написал(а):
Looks like a shittier version of def lw resolver, however I thought rawetrip used animlayers?
Maybe reverse the visuals instead because they are the only decent part.
Нажмите для раскрытия...
hello sir, this is UnknownCheats premium reverse tech support, welcome to our help desk thank u for ur question, our experienced p2c reverse-engineers will be w/ u shortly
 
popugapopugay написал(а):
Rawetrip resolver.

Возможно вронг.

C++:
Expand Collapse Copy 
void Resolver::Initialize(Player* m_player, Record* m_record, float m_feet_yaw, float m_pitch)
{
    player = m_player;
    record = m_record;

    goalfeetyaw = Math::NormalizeYaw(m_feet_yaw);
    pitch = Math::NormalizePitch(m_pitch);
}

void Resolver::ResolvePitch()
{
    return pitch;
}

void Resolver::ResolveYaw()
{
    if (!local_player->alive() || !player->enemy())
    {
        player_record->side = RESOLVER_ORIGINAL;
        return;
    }

    bool BruteforceResolve = (record->resolver_type != LBY);

    if (BruteforceResolve)
    {
        switch (ResolverSide)
        {
        case RESOLVER_ORIGINAL:
            record->resolver_side = RESOLVER_ORIGINAL;
            record->resolver_type = BRUTEFORCE;
            break;
        case RESOLVER_ZERO:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_POSITIVE;

            brutforced_first = false;
            brutforced_second = false;
            return;
        case RESOLVER_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_second)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_NEGATIVE;

            record->resolver_side = resolver_side;
            brutforced_first = true;
            return;
        case RESOLVER_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_first)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_POSITIVE;

            record->resolver_side = resolver_side;
            brutforced_second = true;
            return;
        case RESOLVER_LOW_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_NEGATIVE;
            return;
        case RESOLVER_LOW_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_POSITIVE;
            return;
        }
    }

    animstate* animation_state = player->get_animstate();

    if (!animation_state)
    {
        record->resolver_side = RESOLVER_ORIGINAL;
        return;
    }

    float delta = Math::NormalizeYaw(player->eye_angles().y - goalfeetyaw);

    if (delta > 30.0 && valid_lby)
    {
        if (globals.missed_shots > 0)
            delta = -delta;

        if (delta <= 30.0)
        {
            if (delta < -30.0)
            {
                record->resolver_type = LBY;
                record->resolver_side = RESOLVER_NEGATIVE;
            }
        }
        else
        {
            record->resolver_type = LBY;
            record->resolver_side = RESOLVER_POSITIVE;
        }
    }
    else
    {
        bool trace = false;

        if (globals.curtime - previous_curtime > 2.0f)
        {
            bool first = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_positive), player, localplayer);
            bool second = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_negative), player, localplayer);

            bool positive = false;

            if (first == second)
            {
                float first2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_positive));
                float second2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_negative));

                if (Math::SecondFabs(first2 - second2) > 1.0f)
                    positive = first2 > second2;
            }
            else
            {
                trace = true;
                positive = second;
                previous_curtime = globals.curtime;
            }
        }
        else
            trace = true;

        if (positive)
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_POSITIVE;
        }
        else
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_NEGATIVE;
        }
    }

    bool low_pitch = (animation_state->eye_pitch < 20.0 && animation_state->eye_pitch > -20.0);

    if (low_pitch)
    {
        float feet_yaw = animation_state->goalfeetyaw;

        if (animation_state)
        {
            float lby_delta = player->eye_angles().yaw - player->lby();
            bool lby_stand = lby_delta > 35.0 && player->velocity().length_2d() < 5;

            if (!lby_stand)
                feet_yaw += lby_delta;
           
            animation_state->goalfeetyaw = feet_yaw;
        }
    }
    else
    {
        record->resolver_side = RESOLVER_ORIGINAL;
    }
}
Нажмите для раскрытия...
где то я это видел....
AbsentBem написал(а):
это джс?
Нажмите для раскрытия...
c++ это джс?
 
popugapopugay написал(а):
Rawetrip resolver.

Возможно вронг.

C++:
Expand Collapse Copy 
void Resolver::Initialize(Player* m_player, Record* m_record, float m_feet_yaw, float m_pitch)
{
    player = m_player;
    record = m_record;

    goalfeetyaw = Math::NormalizeYaw(m_feet_yaw);
    pitch = Math::NormalizePitch(m_pitch);
}

void Resolver::ResolvePitch()
{
    return pitch;
}

void Resolver::ResolveYaw()
{
    if (!local_player->alive() || !player->enemy())
    {
        player_record->side = RESOLVER_ORIGINAL;
        return;
    }

    bool BruteforceResolve = (record->resolver_type != LBY);

    if (BruteforceResolve)
    {
        switch (ResolverSide)
        {
        case RESOLVER_ORIGINAL:
            record->resolver_side = RESOLVER_ORIGINAL;
            record->resolver_type = BRUTEFORCE;
            break;
        case RESOLVER_ZERO:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_POSITIVE;

            brutforced_first = false;
            brutforced_second = false;
            return;
        case RESOLVER_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_second)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_NEGATIVE;

            record->resolver_side = resolver_side;
            brutforced_first = true;
            return;
        case RESOLVER_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            int resolver_side;

            if (brutforced_first)
                resolver_side = RESOLVER_ZERO;
            else
                resolver_side = RESOLVER_POSITIVE;

            record->resolver_side = resolver_side;
            brutforced_second = true;
            return;
        case RESOLVER_LOW_POSITIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_LOW_NEGATIVE;
            return;
        case RESOLVER_LOW_NEGATIVE:
            record->resolver_type = BRUTEFORCE;
            record->resolver_side = RESOLVER_POSITIVE;
            return;
        }
    }

    animstate* animation_state = player->get_animstate();

    if (!animation_state)
    {
        record->resolver_side = RESOLVER_ORIGINAL;
        return;
    }

    float delta = Math::NormalizeYaw(player->eye_angles().y - goalfeetyaw);

    if (delta > 30.0 && valid_lby)
    {
        if (globals.missed_shots > 0)
            delta = -delta;

        if (delta <= 30.0)
        {
            if (delta < -30.0)
            {
                record->resolver_type = LBY;
                record->resolver_side = RESOLVER_NEGATIVE;
            }
        }
        else
        {
            record->resolver_type = LBY;
            record->resolver_side = RESOLVER_POSITIVE;
        }
    }
    else
    {
        bool trace = false;

        if (globals.curtime - previous_curtime > 2.0f)
        {
            bool first = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_positive), player, localplayer);
            bool second = visible(globals.eye_pos, player->hitbox_pos(1, record->matrix_negative), player, localplayer);

            bool positive = false;

            if (first == second)
            {
                float first2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_positive));
                float second2 = globals.eye_pos.dist(player->hitbox_pos(1, record->matrix_negative));

                if (Math::SecondFabs(first2 - second2) > 1.0f)
                    positive = first2 > second2;
            }
            else
            {
                trace = true;
                positive = second;
                previous_curtime = globals.curtime;
            }
        }
        else
            trace = true;

        if (positive)
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_POSITIVE;
        }
        else
        {
            int type = ORIGINAL;

            if (trace)
                type = TRACE;
            else
                type = DIRECTIONAL;

            record->resolver_type = type;
            record->resolver_side = RESOLVER_NEGATIVE;
        }
    }

    bool low_pitch = (animation_state->eye_pitch < 20.0 && animation_state->eye_pitch > -20.0);

    if (low_pitch)
    {
        float feet_yaw = animation_state->goalfeetyaw;

        if (animation_state)
        {
            float lby_delta = player->eye_angles().yaw - player->lby();
            bool lby_stand = lby_delta > 35.0 && player->velocity().length_2d() < 5;

            if (!lby_stand)
                feet_yaw += lby_delta;
           
            animation_state->goalfeetyaw = feet_yaw;
        }
    }
    else
    {
        record->resolver_side = RESOLVER_ORIGINAL;
    }
}
Нажмите для раскрытия...
Фулл, вронг
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
наконец то слили PROPER RESOLVER FOR LEGENDWARE
 
if (delta > 30.0 && valid_lby)
{
if (globals.missed_shots > 0)
delta = -delta;

if (delta <= 30.0)
{
if (delta < -30.0)
{
record->resolver_type = LBY;
record->resolver_side = RESOLVER_NEGATIVE;
}
}
else
{
record->resolver_type = LBY;
record->resolver_side = RESOLVER_POSITIVE;
}
}
good hahaha
 

Похожие темы

mercury997
Исходник Nemesis Resolver // supremacy c+p ready
Ответы
1
Просмотры
705
veinedhvhs
veinedhvhs
mercury997
Исходник Updated OnBodyUpdate // supremacy c+p ready
Ответы
6
Просмотры
710
flairer
flairer
mercury997
Исходник Check hitchance reworked // supremacy c+p ready
Ответы
4
Просмотры
707
mercury997
mercury997
K
Вопрос How to make resolver better?
Ответы
4
Просмотры
855
kralondon11
K
mercury997
Исходник Supremacy Rebuilt Animations // supremacy c+p ready
Ответы
5
Просмотры
819
FunTimesWithZustin
F
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Назад
Сверху Снизу