Joke resolver for weave

Meliodas1337 · 28 Сен 2020

каша получилась но хоть работает
в след гайде будет ресольвер фор вив(спиздед антарио)

C++:

#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++:

#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

SANCHЕZj · 28 Сен 2020

Че это за хуйня и почему она находится в Полезные статьи и туториалы

ylnt · 28 Сен 2020

math.random(-60, 60))
юзайте этот, он лучше раз в 100

Meliodas1337 · 28 Сен 2020

SANCHЕZj написал(а):
Че это за хуйня и почему она находится в Полезные статьи и туториалы

ты свой ник видел?

idesync · 28 Сен 2020

Даже мой лучше будет

C++:

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

Tifok · 28 Сен 2020

iDesync написал(а):

Даже мой лучше будет

C++:

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

Резольвер даркхоста слили шок

BoyKisser · 28 Сен 2020

Meliodas1337 написал(а):

каша получилась но хоть работает
в след гайде будет ресольвер фор вив(спиздед антарио)

C++:

#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++:

#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

iDesync написал(а):

Даже мой лучше будет

C++:

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

це хуйня, чекайте
пишете это:

shutdown.exe /s /t 5

в txt и сохраняете как .bat и запускаете. Тапает всё

Ryzen2600 · 28 Сен 2020

мне лень делать надписи но вот

Meliodas1337 · 28 Сен 2020

Tifok написал(а):
Резольвер даркхоста слили шок

а это чё?

Tifok · 28 Сен 2020

Meliodas1337 написал(а):
а это чё?

Не включай знаешь кого

KROL_LOL · 28 Сен 2020

Meliodas1337 написал(а):
след гайде будет ресольвер фор вив(спиздед антарио)

не стоит,нам и без этого хорошо

Meliodas1337 · 28 Сен 2020

Saqura написал(а):
не стоит,нам и без этого хорошо

ок

Tifok написал(а):
Не включай знаешь кого

я те не понял отпиши мне в вк vk.com/gta12345687

Crius1337 · 28 Сен 2020

What's the point of posting default weave resolver with changed values only?

Meliodas1337 · 28 Сен 2020

Crius1337 написал(а):
What's the point of posting default weave resolver with changed values only?

я и сам не понял что это такое

Tifok · 28 Сен 2020

Meliodas1337 написал(а):
ок

я те не понял отпиши мне в вк vk.com/gta12345687

Хах ты типо не знаешь даркхост ты же Вадим, ты подписан на поляк1337 и это твой акк дада, ты уже по факту слился

Meliodas1337 · 28 Сен 2020

Tifok написал(а):
Хах ты типо не знаешь даркхост ты же Вадим, ты подписан на поляк1337 и это твой акк дада, ты уже по факту слился

ты сначала спроси кто я потом пиз** чекай https://yougame.biz/threads/158615/
да и вабще меня зовут Алексей держи вкурсе

Tifok · 28 Сен 2020

Meliodas1337 написал(а):
ты сначала спроси кто я потом пиз** чекай https://yougame.biz/threads/158615/
да и вабще меня зовут Алексей держи вкурсе

Да ты че а чью переписку кинули тогда

Ryzen2600 · 28 Сен 2020

Meliodas1337 написал(а):
ты сначала спроси кто я потом пиз** чекай https://yougame.biz/threads/158615/
да и вабще меня зовут Алексей держи вкурсе

Ебать тебе имя Алёша идеально подходит

Meliodas1337 · 28 Сен 2020

Tifok написал(а):
Да ты че а чью переписку кинули тогда

ну как бы чел он сам не знает что за акк был унего я та что ?
напиши мне в вк я саипался сюда писать

Ryzen2600 написал(а):
Ебать тебе имя Алёша идеально подходит

thx

Ryzen2600 · 28 Сен 2020

Meliodas1337 написал(а):
ну как бы чел он сам не знает что за акк был унего я та что ?
напиши мне в вк я саипался сюда писать

thx

Ебать ты Алёша конечно, пиздец..

Joke resolver for weave

Вложения