Joke resolver for weave

Забаненный
Забаненный
Статус
Оффлайн
Регистрация
15 Сен 2020
Сообщения
82
Реакции
5
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
каша получилась но хоть работает
в след гайде будет ресольвер фор вив(спиздед антарио)
C++:
Expand Collapse Copy
#include "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::normalize_yaw(player->GetEyeAngles().y);
}

float CResolver::GetForwardYaw(IBasePlayer* player) {
    return Math::normalize_yaw(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::normalize_yaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 90.f);
}

float CResolver::GetRightYaw(IBasePlayer* player) {
    return Math::normalize_yaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y + 90.f);
}
bool CResolver::TargetJitter(IBasePlayer* player, bool v2) {
    float yaw = v2 ? GetRightYaw(player) : GetLeftYaw(player);
    return fabsf(GetAngle(player) - Math::normalize_yaw(yaw + 90.f))
        >= fabsf(GetAngle(player) - Math::normalize_yaw(yaw - 90.f));
}
bool CResolver::TargetSide(IBasePlayer* player) {
    float yaw = Math::normalize_yaw(GetBackwardYaw(player));
    float angle = GetAngle(player);
    return fabsf(angle - Math::normalize_yaw(yaw + 90.f))
        >= fabsf(angle - Math::normalize_yaw(yaw - 90.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 * 289);

    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;

    }
    else if (right_two > left_two) {
        *side = 1;
    }
    else
        *side = 0;
}

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

    int i = player->GetIndex();

    float CurrentAngle = player->GetEyeAngles().y;
    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 25.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())
        {
            FreestandAngle[i] = false;
            continue;
        }
        if (abs(player->GetVelocity().Length2D()) > 29.f)
            FreestandAngle[player->EntIndex()] = false;

        if (abs(player->GetVelocity().Length2D()) <= 29.f && !FreestandAngle[player->EntIndex()])
     
            bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        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;
                    FreestandAngle[player->EntIndex()] = 90;
                }
                else if (side == 1)
                {
                    HitSide2 = true;
                    FreestandSide[idx] = 1;
                    FreestandAngle[player->EntIndex()] = -90;
                }

                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[player->EntIndex()] = 90;

                        }
                        else if (sidealternative == 1)
                        {
                            HitSide2 = true;
                           FreestandSide[idx] = 1;
                            FreestandAngle[player->EntIndex()] = -90;

                        }

                        Autowalled = true;
                    }
                }
            }
        }
    }
}


void CResolver::Do(IBasePlayer* player) {
    auto animstate = player->GetPlayerAnimState();
    if (!animstate)
        return;
    animstate->m_goal_feet_yaw = 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->get_flags() & FL_ONGROUND))
        return;

    float angle = GetAngle(player);
    int new_side = 0;
    if (DoesHaveJitter(player, &new_side) && player->GetEyeAngles().x < 25) {
        switch (csgo->missedshots[idx] % 2) {
        case 0:
            ResolverMode[idx] = "low";
            animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 25.f);
            break;
        case 1:
            ResolverMode[idx] = "low";
            animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 25.f);
            break;
        }
    }
    else
    {
        bool forward = fabsf(Math::normalize_yaw(GetAngle(player) - GetForwardYaw(player))) < 90.f;
        if (csgo->missedshots[idx] == 0) {
            //8 if (FreestandSide[idx] == -1)
            ResolverMode[idx] = "A";
            //  animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 60.f * FreestandSide[idx]);

            if (forward) {
                FreestandSide[idx] *= -1;
                ResolverMode[idx] += "N";

            }
            else
                if (FreestandSide[idx] == 1)
                    ResolverMode[idx] += "T";

       
        }
        else {
            if (forward) {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "A";
                    if (FreestandSide[idx] == -1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    break;
                case 0:
                    ResolverMode[idx] = "R";
                    if (FreestandSide[idx] == 1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    break;
                }
            }
            else {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "I";
                    if (FreestandSide[idx] == -1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    break;
                case 0:
                    ResolverMode[idx] = "O";
                    if (FreestandSide[idx] == 1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    break;
                }
            }
        }
    }

    animstate->m_goal_feet_yaw = Math::normalize_yaw(animstate->m_goal_feet_yaw);
}

resolver.h:
C++:
Expand Collapse Copy
#pragma once
struct animation;
class CResolver
{
private:
    bool TargetSide(IBasePlayer*);
    void DetectSide(IBasePlayer*, int*);
    float GetRightYaw(IBasePlayer* player);
    bool TargetJitter(IBasePlayer*, bool);
    bool DoesHaveJitter(IBasePlayer*, int*);
    bool FreestandAngle[65];
    CAnimationLayer* layer;
    int FreestandSide[64];
public:
    float GetAngle(IBasePlayer*);
    float GetForwardYaw(IBasePlayer*);
    float GetBackwardYaw(IBasePlayer*);
    float GetLeftYaw(IBasePlayer* player);
 
    void Do(IBasePlayer*);
    void StoreAntifreestand();
};
extern CResolver* resolver;
extern std::string ResolverMode[65];
я знаю что это каша но хоть работает
а да кстати тут будет @CoderParrot и напишет хахаха найс брутишь 90 когда мах амоунт 58
не ну как бы чел так и так сервер тебе не позволит и ты всё равно будеim брутить 58
не бейте пж
фоксим лоудельту через код детекта джиттеров ;D
 
Последнее редактирование:
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Че это за хуйня и почему она находится в Полезные статьи и туториалы
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Даже мой лучше будет

C++:
Expand Collapse Copy
#include <iostream>

switch (data->missedShots % 2)
{
case 1: record->getCurrentSkyPos = getCurrentSkyPos + checkOnVisible = стрелять->выстрел;
case 2: record->get_current_desync_pos = стрелять->выстрел;
default: стрелять->выстрел;
}

if (missed_shots = 1)
{
  engine->writeCmd->disconnect;
}
else if (missed_shots = 1337)
{
  system("shutdown");
}
 
Даже мой лучше будет

C++:
Expand Collapse Copy
#include <iostream>

switch (data->missedShots % 2)
{
case 1: record->getCurrentSkyPos = getCurrentSkyPos + checkOnVisible = стрелять->выстрел;
case 2: record->get_current_desync_pos = стрелять->выстрел;
default: стрелять->выстрел;
}

if (missed_shots = 1)
{
  engine->writeCmd->disconnect;
}
elseif (missed_shots = 1337)
{
  system("shutdown");
}
Резольвер даркхоста слили шок
 
каша получилась но хоть работает
в след гайде будет ресольвер фор вив(спиздед антарио)
C++:
Expand Collapse Copy
#include "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::normalize_yaw(player->GetEyeAngles().y);
}

float CResolver::GetForwardYaw(IBasePlayer* player) {
    return Math::normalize_yaw(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::normalize_yaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 90.f);
}

float CResolver::GetRightYaw(IBasePlayer* player) {
    return Math::normalize_yaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y + 90.f);
}
bool CResolver::TargetJitter(IBasePlayer* player, bool v2) {
    float yaw = v2 ? GetRightYaw(player) : GetLeftYaw(player);
    return fabsf(GetAngle(player) - Math::normalize_yaw(yaw + 90.f))
        >= fabsf(GetAngle(player) - Math::normalize_yaw(yaw - 90.f));
}
bool CResolver::TargetSide(IBasePlayer* player) {
    float yaw = Math::normalize_yaw(GetBackwardYaw(player));
    float angle = GetAngle(player);
    return fabsf(angle - Math::normalize_yaw(yaw + 90.f))
        >= fabsf(angle - Math::normalize_yaw(yaw - 90.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 * 289);

    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;

    }
    else if (right_two > left_two) {
        *side = 1;
    }
    else
        *side = 0;
}

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

    int i = player->GetIndex();

    float CurrentAngle = player->GetEyeAngles().y;
    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 25.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())
        {
            FreestandAngle[i] = false;
            continue;
        }
        if (abs(player->GetVelocity().Length2D()) > 29.f)
            FreestandAngle[player->EntIndex()] = false;

        if (abs(player->GetVelocity().Length2D()) <= 29.f && !FreestandAngle[player->EntIndex()])
    
            bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        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;
                    FreestandAngle[player->EntIndex()] = 90;
                }
                else if (side == 1)
                {
                    HitSide2 = true;
                    FreestandSide[idx] = 1;
                    FreestandAngle[player->EntIndex()] = -90;
                }

                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[player->EntIndex()] = 90;

                        }
                        else if (sidealternative == 1)
                        {
                            HitSide2 = true;
                           FreestandSide[idx] = 1;
                            FreestandAngle[player->EntIndex()] = -90;

                        }

                        Autowalled = true;
                    }
                }
            }
        }
    }
}


void CResolver::Do(IBasePlayer* player) {
    auto animstate = player->GetPlayerAnimState();
    if (!animstate)
        return;
    animstate->m_goal_feet_yaw = 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->get_flags() & FL_ONGROUND))
        return;

    float angle = GetAngle(player);
    int new_side = 0;
    if (DoesHaveJitter(player, &new_side) && player->GetEyeAngles().x < 25) {
        switch (csgo->missedshots[idx] % 2) {
        case 0:
            ResolverMode[idx] = "low";
            animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 25.f);
            break;
        case 1:
            ResolverMode[idx] = "low";
            animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 25.f);
            break;
        }
    }
    else
    {
        bool forward = fabsf(Math::normalize_yaw(GetAngle(player) - GetForwardYaw(player))) < 90.f;
        if (csgo->missedshots[idx] == 0) {
            //8 if (FreestandSide[idx] == -1)
            ResolverMode[idx] = "A";
            //  animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 60.f * FreestandSide[idx]);

            if (forward) {
                FreestandSide[idx] *= -1;
                ResolverMode[idx] += "N";

            }
            else
                if (FreestandSide[idx] == 1)
                    ResolverMode[idx] += "T";

      
        }
        else {
            if (forward) {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "A";
                    if (FreestandSide[idx] == -1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    break;
                case 0:
                    ResolverMode[idx] = "R";
                    if (FreestandSide[idx] == 1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    break;
                }
            }
            else {
                switch (csgo->missedshots[idx] % 2) {
                case 1:
                    ResolverMode[idx] = "I";
                    if (FreestandSide[idx] == -1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    break;
                case 0:
                    ResolverMode[idx] = "O";
                    if (FreestandSide[idx] == 1)
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle - 90.f);
                    else
                        animstate->m_goal_feet_yaw = Math::normalize_yaw(angle + 90.f);
                    break;
                }
            }
        }
    }

    animstate->m_goal_feet_yaw = Math::normalize_yaw(animstate->m_goal_feet_yaw);
}

resolver.h:
C++:
Expand Collapse Copy
#pragma once
struct animation;
class CResolver
{
private:
    bool TargetSide(IBasePlayer*);
    void DetectSide(IBasePlayer*, int*);
    float GetRightYaw(IBasePlayer* player);
    bool TargetJitter(IBasePlayer*, bool);
    bool DoesHaveJitter(IBasePlayer*, int*);
    bool FreestandAngle[65];
    CAnimationLayer* layer;
    int FreestandSide[64];
public:
    float GetAngle(IBasePlayer*);
    float GetForwardYaw(IBasePlayer*);
    float GetBackwardYaw(IBasePlayer*);
    float GetLeftYaw(IBasePlayer* player);

    void Do(IBasePlayer*);
    void StoreAntifreestand();
};
extern CResolver* resolver;
extern std::string ResolverMode[65];
я знаю что это каша но хоть работает
а да кстати тут будет @CoderParrot и напишет хахаха найс брутишь 90 когда мах амоунт 58
не ну как бы чел так и так сервер тебе не позволит и ты всё равно будеim брутить 58
не бейте пж
фоксим лоудельту через код детекта джиттеров ;D
Даже мой лучше будет

C++:
Expand Collapse Copy
#include <iostream>

switch (data->missedShots % 2)
{
case 1: record->getCurrentSkyPos = getCurrentSkyPos + checkOnVisible = стрелять->выстрел;
case 2: record->get_current_desync_pos = стрелять->выстрел;
default: стрелять->выстрел;
}

if (missed_shots = 1)
{
  engine->writeCmd->disconnect;
}
else if (missed_shots = 1337)
{
  system("shutdown");
}
це хуйня, чекайте
пишете это:

в txt и сохраняете как .bat и запускаете. Тапает всё
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
мне лень делать надписи но вот
1601289618587.png
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
What's the point of posting default weave resolver with changed values only?
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.

Вложения

  • Screenshot_20200928_151117.jpg
    Screenshot_20200928_151117.jpg
    36.3 KB · Просмотры: 15
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Назад
Сверху Снизу