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

Говно ресольвер для wayvee.sosat

Igor_mitrovich0
Vac88 | Overdose.it v2 coder
Забаненный
Igor_mitrovich0
Забаненный
Статус
Оффлайн
Регистрация
1 Янв 2021
Сообщения
28
Реакции
5
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
чо эта за говно? я сам не снайу...
сделена за 18 минут.
(- + говно btw)


C++:
Expand Collapse Copy 
#include "../hooks/Hooks.h"
#include "Resolver.h"
#include "RageBacktracking.h"
#include "Ragebot.h"
#include "AnimationFix.h"


std::string ResolverMode[65];
int last_ticks[65];
int IBasePlayer::GetChokedPackets() {
    auto ticks = TIME_TO_TICKS(GetSimulationTime() - GetOldSimulationTime());
    if (ticks == 0 && last_ticks[GetIndex()] > 0) {
        return last_ticks[GetIndex()] - 1;
    }
    else {
        last_ticks[GetIndex()] = ticks;
        return ticks;
    }
}

float CResolver::GetAngle(IBasePlayer* player) {
    return Math::NormalizeYaw(player->GetEyeAngles().y);
}

float CResolver::GetForwardYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(GetBackwardYaw(player) - 180.f);
}

float CResolver::GetBackwardYaw(IBasePlayer* player) {
    return Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;
}

float CResolver::GetLeftYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 360.f);
}

float CResolver::GetRightYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y + 360.f);
}
bool CResolver::TargetJitter(IBasePlayer* player, bool v2) {
    float yaw = v2 ? GetRightYaw(player) : GetLeftYaw(player);
    return fabsf(GetAngle(player) - Math::NormalizeYaw(yaw + 100.f))
        >= fabsf(GetAngle(player) - Math::NormalizeYaw(yaw - 100.f));
}
bool CResolver::TargetSide(IBasePlayer* player) {
    float yaw = Math::NormalizeYaw(GetBackwardYaw(player));
    float angle = GetAngle(player);
    return fabsf(angle - Math::NormalizeYaw(yaw + 100.f))
        >= fabsf(angle - Math::NormalizeYaw(yaw - 100.f));
}

void CResolver::DetectSide(IBasePlayer* player, int* side)
{
    Vector src3D, dst3D, forward, right, up, src, dst;
    float back_two, right_two, left_two;
    trace_t tr;
    Ray_t ray, ray2, ray3, ray4, ray5;
    CTraceFilter filter;

    Math::AngleVectors(Vector(0, GetBackwardYaw(player), 0), &forward, &right, &up);

    filter.pSkip = player;
    src3D = player->GetEyePosition();
    dst3D = src3D + (forward * 384); //Might want to experiment with other numbers, incase you don't know what the number does, its how far the trace will go. Lower = shorter.

    ray.Init(src3D, dst3D);
    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);
    back_two = (tr.endpos - tr.startpos).Length();

    ray2.Init(src3D + right * 35, dst3D + right * 35);
    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);
    right_two = (tr.endpos - tr.startpos).Length();

    ray3.Init(src3D - right * 35, dst3D - right * 35);
    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);
    left_two = (tr.endpos - tr.startpos).Length();

    if (left_two > right_two) {
        *side = -1;
        //Body should be right
    }
    else if (right_two > left_two) {
        *side = 1;
    }
    else
        *side = 0;
}

bool CResolver::DoesHaveJitter(IBasePlayer* player, int* new_side) {
    static float LastAngle[64];
    static int LastBrute[64];
    static bool Switch[64];
    static float LastUpdateTime[64];

    int i = player->GetIndex();

    float CurrentAngle = player->GetEyeAngles().y;
    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 50.f)) {
        Switch[i] = !Switch[i];
        LastAngle[i] = CurrentAngle;
        *new_side = Switch[i] ? 1 : -1;
        LastBrute[i] = *new_side;
        LastUpdateTime[i] = interfaces.global_vars->curtime;
        return true;
    }
    else {
        if (fabsf(LastUpdateTime[i] - interfaces.global_vars->curtime >= TICKS_TO_TIME(17))
            || player->GetSimulationTime() != player->GetOldSimulationTime()) {
            LastAngle[i] = CurrentAngle;
        }
        *new_side = LastBrute[i];
    }
    return false;
}


void CResolver::StoreAntifreestand()
{
    if (!csgo->local->isAlive())
        return;

    if (!csgo->weapon->IsGun())
        return;


    for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)
    {
        auto player = interfaces.ent_list->GetClientEntity(i);

        if (!player || !player->isAlive() || player->IsDormant() || player->GetTeam() == csgo->local->GetTeam())
            continue;

        bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        auto idx =

            player->GetIndex();
        float angToLocal = Math::CalculateAngle(csgo->local->GetOrigin(),

            player->GetOrigin()).y;
        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);
        Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };

        Vector2D Side3 = { (50 * sin(DEG2RAD(angToLocal))),(50 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side4 = { (50 * sin(DEG2RAD(angToLocal + 180))) ,(50 * cos(DEG2RAD(angToLocal + 180))) };

        Vector Origin = player->GetOrigin();

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

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

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

            if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
            {
                if (side == 0)
                {
                    HitSide1 = true;
                    FreestandSide[idx] = -1;
                }
                else if (side == 1)
                {
                    HitSide2 = true;
                    FreestandSide[idx] = 1;
                }

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

                    if (g_AutoWall.CanHitFloatingPoint(ViewPointAutowallalternative, ViewPointAutowall))
                    {
                        if (sidealternative == 0)
                        {
                            HitSide1 = true;
                            FreestandSide[idx] = -1;
                            //FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                        }
                        else if (sidealternative == 1)
                        {
                            HitSide2 = true;
                            FreestandSide[idx] = 1;
                            //FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                        }

                        Autowalled = true;
                    }
                }
            }
        }
    }
}


void CResolver::Do(IBasePlayer* player) {
    auto animstate = player->GetPlayerAnimState();
    if (!animstate)
        return;
    animstate->m_flGoalFeetYaw = GetAngle(player);
    if (!vars.ragebot.resolver)
        return;
    if (!csgo->local->isAlive())
        return;
    if (player->GetChokedPackets() <= 0)
        return;

    int idx = player->GetIndex();

    if (player->GetPlayerInfo().fakeplayer)
        return;

    if (!(player->GetFlags() & FL_ONGROUND))
        return;

    float angle = GetAngle(player);
    //int new_side = 0;
    //if (DoesHaveJitter(player, &new_side)/* && player->GetEyeAngles().x < 45*/) {
    // switch (csgo->missedshots[idx] % 2) {
    // case 0:
    // ResolverMode[idx] = hs::AB.s();
    // animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 100.f * new_side);
    // break;
    // case 1:
    // ResolverMode[idx] = hs::AC.s();
    // animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 100.f * new_side);
    // break;
    // }
    //}
    //else
    {
        bool forward = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) < 90.f;
        if (csgo->missedshots[idx] == 0) {
            ResolverMode[idx] = "Main";
            animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);
            if (csgo->missedshots[idx])
                animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
            animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);

            if (forward) {
                FreestandSide[idx] *= -1;
                ResolverMode[idx] += "B";
                animstate->m_flGoalFeetYaw += 90;
                if (csgo->missedshots[idx]);
                animstate->m_flGoalFeetYaw -= 90;
                animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);

            }
            else
                ResolverMode[idx] += "A";
            animstate->m_flGoalFeetYaw += 60;
            if (csgo->missedshots[idx]);
            animstate->m_flGoalFeetYaw -= 60;
            animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 180.f);

        }
        else {
            if (forward) {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 60.f);
                    else

                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 60.f);
                    break;
                case 0:
                    ResolverMode[idx] = "DB";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);
                    break;
                }
            }
            else {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle

                            + 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    break;
                case 0:
                    ResolverMode[idx] = "DB";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 120.f);
                    break;
                }
            }
        }
    }

    animstate->m_flGoalFeetYaw = Math::NormalizeYaw(animstate->m_flGoalFeetYaw);
}
 
2.1. Запрещено оскорбление участников форума в любом виде. В том числе проявление любой грубости, угроз и нецензурных высказываний даже в скрытой форме.
Igor_mitrovich0 написал(а):
чо эта за говно? я сам не снайу...
сделена за 18 минут.
(- + говно btw)


C++:
Expand Collapse Copy 
#include "../hooks/Hooks.h"
#include "Resolver.h"
#include "RageBacktracking.h"
#include "Ragebot.h"
#include "AnimationFix.h"


std::string ResolverMode[65];
int last_ticks[65];
int IBasePlayer::GetChokedPackets() {
    auto ticks = TIME_TO_TICKS(GetSimulationTime() - GetOldSimulationTime());
    if (ticks == 0 && last_ticks[GetIndex()] > 0) {
        return last_ticks[GetIndex()] - 1;
    }
    else {
        last_ticks[GetIndex()] = ticks;
        return ticks;
    }
}

float CResolver::GetAngle(IBasePlayer* player) {
    return Math::NormalizeYaw(player->GetEyeAngles().y);
}

float CResolver::GetForwardYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(GetBackwardYaw(player) - 180.f);
}

float CResolver::GetBackwardYaw(IBasePlayer* player) {
    return Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;
}

float CResolver::GetLeftYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 360.f);
}

float CResolver::GetRightYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y + 360.f);
}
bool CResolver::TargetJitter(IBasePlayer* player, bool v2) {
    float yaw = v2 ? GetRightYaw(player) : GetLeftYaw(player);
    return fabsf(GetAngle(player) - Math::NormalizeYaw(yaw + 100.f))
        >= fabsf(GetAngle(player) - Math::NormalizeYaw(yaw - 100.f));
}
bool CResolver::TargetSide(IBasePlayer* player) {
    float yaw = Math::NormalizeYaw(GetBackwardYaw(player));
    float angle = GetAngle(player);
    return fabsf(angle - Math::NormalizeYaw(yaw + 100.f))
        >= fabsf(angle - Math::NormalizeYaw(yaw - 100.f));
}

void CResolver::DetectSide(IBasePlayer* player, int* side)
{
    Vector src3D, dst3D, forward, right, up, src, dst;
    float back_two, right_two, left_two;
    trace_t tr;
    Ray_t ray, ray2, ray3, ray4, ray5;
    CTraceFilter filter;

    Math::AngleVectors(Vector(0, GetBackwardYaw(player), 0), &forward, &right, &up);

    filter.pSkip = player;
    src3D = player->GetEyePosition();
    dst3D = src3D + (forward * 384); //Might want to experiment with other numbers, incase you don't know what the number does, its how far the trace will go. Lower = shorter.

    ray.Init(src3D, dst3D);
    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);
    back_two = (tr.endpos - tr.startpos).Length();

    ray2.Init(src3D + right * 35, dst3D + right * 35);
    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);
    right_two = (tr.endpos - tr.startpos).Length();

    ray3.Init(src3D - right * 35, dst3D - right * 35);
    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);
    left_two = (tr.endpos - tr.startpos).Length();

    if (left_two > right_two) {
        *side = -1;
        //Body should be right
    }
    else if (right_two > left_two) {
        *side = 1;
    }
    else
        *side = 0;
}

bool CResolver::DoesHaveJitter(IBasePlayer* player, int* new_side) {
    static float LastAngle[64];
    static int LastBrute[64];
    static bool Switch[64];
    static float LastUpdateTime[64];

    int i = player->GetIndex();

    float CurrentAngle = player->GetEyeAngles().y;
    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 50.f)) {
        Switch[i] = !Switch[i];
        LastAngle[i] = CurrentAngle;
        *new_side = Switch[i] ? 1 : -1;
        LastBrute[i] = *new_side;
        LastUpdateTime[i] = interfaces.global_vars->curtime;
        return true;
    }
    else {
        if (fabsf(LastUpdateTime[i] - interfaces.global_vars->curtime >= TICKS_TO_TIME(17))
            || player->GetSimulationTime() != player->GetOldSimulationTime()) {
            LastAngle[i] = CurrentAngle;
        }
        *new_side = LastBrute[i];
    }
    return false;
}


void CResolver::StoreAntifreestand()
{
    if (!csgo->local->isAlive())
        return;

    if (!csgo->weapon->IsGun())
        return;


    for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)
    {
        auto player = interfaces.ent_list->GetClientEntity(i);

        if (!player || !player->isAlive() || player->IsDormant() || player->GetTeam() == csgo->local->GetTeam())
            continue;

        bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        auto idx =

            player->GetIndex();
        float angToLocal = Math::CalculateAngle(csgo->local->GetOrigin(),

            player->GetOrigin()).y;
        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);
        Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };

        Vector2D Side3 = { (50 * sin(DEG2RAD(angToLocal))),(50 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side4 = { (50 * sin(DEG2RAD(angToLocal + 180))) ,(50 * cos(DEG2RAD(angToLocal + 180))) };

        Vector Origin = player->GetOrigin();

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

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

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

            if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
            {
                if (side == 0)
                {
                    HitSide1 = true;
                    FreestandSide[idx] = -1;
                }
                else if (side == 1)
                {
                    HitSide2 = true;
                    FreestandSide[idx] = 1;
                }

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

                    if (g_AutoWall.CanHitFloatingPoint(ViewPointAutowallalternative, ViewPointAutowall))
                    {
                        if (sidealternative == 0)
                        {
                            HitSide1 = true;
                            FreestandSide[idx] = -1;
                            //FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                        }
                        else if (sidealternative == 1)
                        {
                            HitSide2 = true;
                            FreestandSide[idx] = 1;
                            //FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                        }

                        Autowalled = true;
                    }
                }
            }
        }
    }
}


void CResolver::Do(IBasePlayer* player) {
    auto animstate = player->GetPlayerAnimState();
    if (!animstate)
        return;
    animstate->m_flGoalFeetYaw = GetAngle(player);
    if (!vars.ragebot.resolver)
        return;
    if (!csgo->local->isAlive())
        return;
    if (player->GetChokedPackets() <= 0)
        return;

    int idx = player->GetIndex();

    if (player->GetPlayerInfo().fakeplayer)
        return;

    if (!(player->GetFlags() & FL_ONGROUND))
        return;

    float angle = GetAngle(player);
    {
        bool forward = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) < 90.f;
        if (csgo->missedshots[idx] == 0) {
            ResolverMode[idx] = "Main";
            animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);
            if (csgo->missedshots[idx])
                animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
            animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);

            if (forward) {
                FreestandSide[idx] *= -1;
                ResolverMode[idx] += "B";
                animstate->m_flGoalFeetYaw += 90;
                if (csgo->missedshots[idx]);
                animstate->m_flGoalFeetYaw -= 90;
                animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);

            }
            else
                ResolverMode[idx] += "A";
            animstate->m_flGoalFeetYaw += 60;
            if (csgo->missedshots[idx]);
            animstate->m_flGoalFeetYaw -= 60;
            animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 180.f);

        }
        else {
            if (forward) {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 60.f);
                    else

                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 60.f);
                    break;
                case 0:
                    ResolverMode[idx] = "DB";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);
                    break;
                }
            }
            else {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle

                            + 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    break;
                case 0:
                    ResolverMode[idx] = "DB";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 120.f);
                    break;
                }
            }
        }
    }

    animstate->m_flGoalFeetYaw = Math::NormalizeYaw(animstate->m_flGoalFeetYaw);
}
Нажмите для раскрытия...
Код по настоящему велик. Он расскрывает всю свою суть когда мы видим данное чудо :

C++:
Expand Collapse Copy 
    //int new_side = 0;

    //if (DoesHaveJitter(player, &new_side)/* && player->GetEyeAngles().x < 45*/) {

    // switch (csgo->missedshots[idx] % 2) {

    // case 0:

    // ResolverMode[idx] = hs::AB.s();

    // animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 100.f * new_side);

    // break;

    // case 1:

    // ResolverMode[idx] = hs::AC.s();

    // animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 100.f * new_side);

    // break;

    // }

    //}

    //else
После этого мы уже потеряв 4 раза сознание видим это :
C++:
Expand Collapse Copy 
                    ResolverMode[idx] = "DB";
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
                }
            }
            else {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                case 0:
                    ResolverMode[idx] = "DB";
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 120.f);
                    break;
Брутфорсим сначала 60 градусов,потом 90,и 120(Кстати забыл упомянуть,что детект сайд ушел покурить поэтому его тут не будет. Только настоящие мужские технологии - брутфорс сначала одного сайда,потом другого,и нам без разницы что если у чела будут джиттеры наш чит будет гадать на гуще кофе...)
И самое любимое название "режимов" ресольвера - DA и DB. Как я понял автор хотел сделать полностью надпись как его называют в кругу людей,поэтому я доделаю за него = ********.
На этом обзор лучшего ресольвера на вейв закончен(там еще много мемасов,но мне лень писать)
UPD: Я иммел виду фейк джиттеры,когда вертится фейк,а не реал.
 
Последнее редактирование:
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
нахуя шитпостить :NotLikeThis:
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
so why post it if its shit?
 
Igor_mitrovich0 написал(а):
чо эта за говно? я сам не снайу...
сделена за 18 минут.
(- + говно btw)


C++:
Expand Collapse Copy 
#include "../hooks/Hooks.h"
#include "Resolver.h"
#include "RageBacktracking.h"
#include "Ragebot.h"
#include "AnimationFix.h"


std::string ResolverMode[65];
int last_ticks[65];
int IBasePlayer::GetChokedPackets() {
    auto ticks = TIME_TO_TICKS(GetSimulationTime() - GetOldSimulationTime());
    if (ticks == 0 && last_ticks[GetIndex()] > 0) {
        return last_ticks[GetIndex()] - 1;
    }
    else {
        last_ticks[GetIndex()] = ticks;
        return ticks;
    }
}

float CResolver::GetAngle(IBasePlayer* player) {
    return Math::NormalizeYaw(player->GetEyeAngles().y);
}

float CResolver::GetForwardYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(GetBackwardYaw(player) - 180.f);
}

float CResolver::GetBackwardYaw(IBasePlayer* player) {
    return Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;
}

float CResolver::GetLeftYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 360.f);
}

float CResolver::GetRightYaw(IBasePlayer* player) {
    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y + 360.f);
}
bool CResolver::TargetJitter(IBasePlayer* player, bool v2) {
    float yaw = v2 ? GetRightYaw(player) : GetLeftYaw(player);
    return fabsf(GetAngle(player) - Math::NormalizeYaw(yaw + 100.f))
        >= fabsf(GetAngle(player) - Math::NormalizeYaw(yaw - 100.f));
}
bool CResolver::TargetSide(IBasePlayer* player) {
    float yaw = Math::NormalizeYaw(GetBackwardYaw(player));
    float angle = GetAngle(player);
    return fabsf(angle - Math::NormalizeYaw(yaw + 100.f))
        >= fabsf(angle - Math::NormalizeYaw(yaw - 100.f));
}

void CResolver::DetectSide(IBasePlayer* player, int* side)
{
    Vector src3D, dst3D, forward, right, up, src, dst;
    float back_two, right_two, left_two;
    trace_t tr;
    Ray_t ray, ray2, ray3, ray4, ray5;
    CTraceFilter filter;

    Math::AngleVectors(Vector(0, GetBackwardYaw(player), 0), &forward, &right, &up);

    filter.pSkip = player;
    src3D = player->GetEyePosition();
    dst3D = src3D + (forward * 384); //Might want to experiment with other numbers, incase you don't know what the number does, its how far the trace will go. Lower = shorter.

    ray.Init(src3D, dst3D);
    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);
    back_two = (tr.endpos - tr.startpos).Length();

    ray2.Init(src3D + right * 35, dst3D + right * 35);
    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);
    right_two = (tr.endpos - tr.startpos).Length();

    ray3.Init(src3D - right * 35, dst3D - right * 35);
    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);
    left_two = (tr.endpos - tr.startpos).Length();

    if (left_two > right_two) {
        *side = -1;
        //Body should be right
    }
    else if (right_two > left_two) {
        *side = 1;
    }
    else
        *side = 0;
}

bool CResolver::DoesHaveJitter(IBasePlayer* player, int* new_side) {
    static float LastAngle[64];
    static int LastBrute[64];
    static bool Switch[64];
    static float LastUpdateTime[64];

    int i = player->GetIndex();

    float CurrentAngle = player->GetEyeAngles().y;
    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 50.f)) {
        Switch[i] = !Switch[i];
        LastAngle[i] = CurrentAngle;
        *new_side = Switch[i] ? 1 : -1;
        LastBrute[i] = *new_side;
        LastUpdateTime[i] = interfaces.global_vars->curtime;
        return true;
    }
    else {
        if (fabsf(LastUpdateTime[i] - interfaces.global_vars->curtime >= TICKS_TO_TIME(17))
            || player->GetSimulationTime() != player->GetOldSimulationTime()) {
            LastAngle[i] = CurrentAngle;
        }
        *new_side = LastBrute[i];
    }
    return false;
}


void CResolver::StoreAntifreestand()
{
    if (!csgo->local->isAlive())
        return;

    if (!csgo->weapon->IsGun())
        return;


    for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)
    {
        auto player = interfaces.ent_list->GetClientEntity(i);

        if (!player || !player->isAlive() || player->IsDormant() || player->GetTeam() == csgo->local->GetTeam())
            continue;

        bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        auto idx =

            player->GetIndex();
        float angToLocal = Math::CalculateAngle(csgo->local->GetOrigin(),

            player->GetOrigin()).y;
        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);
        Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };

        Vector2D Side3 = { (50 * sin(DEG2RAD(angToLocal))),(50 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side4 = { (50 * sin(DEG2RAD(angToLocal + 180))) ,(50 * cos(DEG2RAD(angToLocal + 180))) };

        Vector Origin = player->GetOrigin();

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

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

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

            if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
            {
                if (side == 0)
                {
                    HitSide1 = true;
                    FreestandSide[idx] = -1;
                }
                else if (side == 1)
                {
                    HitSide2 = true;
                    FreestandSide[idx] = 1;
                }

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

                    if (g_AutoWall.CanHitFloatingPoint(ViewPointAutowallalternative, ViewPointAutowall))
                    {
                        if (sidealternative == 0)
                        {
                            HitSide1 = true;
                            FreestandSide[idx] = -1;
                            //FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                        }
                        else if (sidealternative == 1)
                        {
                            HitSide2 = true;
                            FreestandSide[idx] = 1;
                            //FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                        }

                        Autowalled = true;
                    }
                }
            }
        }
    }
}


void CResolver::Do(IBasePlayer* player) {
    auto animstate = player->GetPlayerAnimState();
    if (!animstate)
        return;
    animstate->m_flGoalFeetYaw = GetAngle(player);
    if (!vars.ragebot.resolver)
        return;
    if (!csgo->local->isAlive())
        return;
    if (player->GetChokedPackets() <= 0)
        return;

    int idx = player->GetIndex();

    if (player->GetPlayerInfo().fakeplayer)
        return;

    if (!(player->GetFlags() & FL_ONGROUND))
        return;

    float angle = GetAngle(player);
    //int new_side = 0;
    //if (DoesHaveJitter(player, &new_side)/* && player->GetEyeAngles().x < 45*/) {
    // switch (csgo->missedshots[idx] % 2) {
    // case 0:
    // ResolverMode[idx] = hs::AB.s();
    // animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 100.f * new_side);
    // break;
    // case 1:
    // ResolverMode[idx] = hs::AC.s();
    // animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 100.f * new_side);
    // break;
    // }
    //}
    //else
    {
        bool forward = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) < 90.f;
        if (csgo->missedshots[idx] == 0) {
            ResolverMode[idx] = "Main";
            animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);
            if (csgo->missedshots[idx])
                animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
            animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);

            if (forward) {
                FreestandSide[idx] *= -1;
                ResolverMode[idx] += "B";
                animstate->m_flGoalFeetYaw += 90;
                if (csgo->missedshots[idx]);
                animstate->m_flGoalFeetYaw -= 90;
                animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);

            }
            else
                ResolverMode[idx] += "A";
            animstate->m_flGoalFeetYaw += 60;
            if (csgo->missedshots[idx]);
            animstate->m_flGoalFeetYaw -= 60;
            animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 180.f);

        }
        else {
            if (forward) {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 60.f);
                    else

                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 60.f);
                    break;
                case 0:
                    ResolverMode[idx] = "DB";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 90.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);
                    break;
                }
            }
            else {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "DA";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle

                            + 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    break;
                case 0:
                    ResolverMode[idx] = "DB";
                    if (FreestandSide[idx] == 1)
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);
                    else
                        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle + 120.f);
                    break;
                }
            }
        }
    }

    animstate->m_flGoalFeetYaw = Math::NormalizeYaw(animstate->m_flGoalFeetYaw);
}
Нажмите для раскрытия...
дохуя говно кода. Вопрос - Зачем?
 
animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 120.f);

animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f);

animstate->m_flGoalFeetYaw = remainderf(animstate->m_flGoalFeetYaw, 360.f);
нанотехнологии?
 

Похожие темы

mercury997
Исходник Nemesis Resolver // supremacy c+p ready
Ответы
1
Просмотры
750
veinedhvhs
veinedhvhs
mercury997
Исходник Supremacy Rebuilt Animations // supremacy c+p ready
Ответы
5
Просмотры
846
FunTimesWithZustin
F
mercury997
Исходник Updated OnBodyUpdate // supremacy c+p ready
Ответы
6
Просмотры
767
flairer
flairer
mercury997
Исходник Check hitchance reworked // supremacy c+p ready
Ответы
4
Просмотры
723
mercury997
mercury997
mercury997
Исходник How to paste server animations into supremacy // c+p ready
Ответы
10
Просмотры
1K
blehme44
B
Немного о главном
Полезные мелочи
О нас

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

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