Помогите, в xy0 поменять ресольвер

[egorqa]

Вопрос выше, а ресольвер вот:

Помогите пожалуйста

resolver.hpp :

#pragma once
#include <deque>

#include "../../helpers/singleton.hpp"
#include "../../valve_sdk/csgostructs.hpp"

struct AASimulationStruct
{
    bool CanUseFreestanding = false;
    float FreestandAng = 0.f;
    bool CanUseEdge = false;
    float EdgeAngle = 0.f;
    bool GotWallDistance = false;
    float WallDistance = 0.f;
    bool CanUseBackwards = false;
    float BackwardsAng = 0.f;
};

struct CurrentStandAADataStruct
{
    bool UsedEdge = false;
    int LastEdgeShots = 0;
    int FreestandShots = 0;
};

struct ResolverAnimDataStorage
{
    void UpdateAnimationLayers(C_BasePlayer* player)
    {
        m_iLayerCount = player->GetNumAnimOverlays();
        for (int i = 0; i < m_iLayerCount; i++)
        {
            animationLayer[i] = player->GetAnimOverlays()[i];
        }
    };
    int32_t m_iLayerCount;
    AnimationLayer animationLayer[15];
};

struct SavedResolverData
{
    bool WasDormantBetweenMoving = true;
    float LastMovingLby = 0.f;
    float LastCycle = 0.f;
    bool Flip = false;
    float LastSimtime = 0.f;
    float LastResolvedYaw = 0.f;
    bool LastResolved = true;
    bool WasLastMoving = false;
    float LastStandingLby = 0.f;
    float MoveStandDelta = 0.f;
    bool CanUseMoveStandDelta = false;
    bool WasFakeWalking = false;
    //CanUseLbyPrediction
    float LastLby = 0.f;
    float LegitTestLastSimtime = 0.f;
    float lastLbyUpdateTime = 0.f;
    bool UsingAA = false;
    float LastWasUsingAA = 0.f;
    Vector LastPos = Vector(0, 0, 0);
    float FakeYaw = 0.f;
    float LastVel = 0.f;
};

enum class DetectionModes : int
{
    None,
    Spinning,
    Static,
    Random
};
struct ResolverDetectionData
{
    std::deque<float> AllLbys;
    std::deque<float> LastAddSimtime;
    float LastSimtime = 0.f;;
    float SpinSpeed = 0.f;
    DetectionModes mode = DetectionModes::None;
    DetectionModes BeforeMoving = DetectionModes::None;
    bool WasMoving = false;
};

enum class ResolverModes : int
{
    NONE,
    FREESTANDING,
    BACKWARDS,
    EDGE,
    MOVE_STAND_DELTA,
    FORCE_LAST_MOVING_LBY,
    FORCE_FREESTANDING,
    FORCE_BACKWARDS,
    BRUTFORCE_ALL_DISABLED, //todo
    BRUTFORCE,
    FORCE_MOVE_STAND_DELTA,
    FORCE_LBY,
    MOVING,
    LBY_BREAK,
    SPINBOT,
    AIR_FREESTANDING,
    AIR_BRUTFORCE,
    FAKEWALK_FREESTANDING,
    FAKEWALK_BRUTFORCE,
    PREDICT_FREESTANDING,
    PREDICT_BRUTFORCE,
    MAX
};

enum class ResolverDetections : int
{
    NONE,
    FAKEWALKING,
    AIR,
    MOVING,
    STANDING
};

enum class BacktrackPriorities : int
{
    none,
    good_prediction,
    normal_prediction,
    lby_prediction,
    lby_update,
    moving
};

#ifdef FakeAnglesEnabled
struct GlobalResolverDataStruct
{
    bool Resolved = false;
    bool ForceBaim = false;
    int Shots = 0;
    int ResolverState = 0; // bad, resolved, lby update, moving
    ResolverModes mode = ResolverModes::NONE;
    ResolverDetections detection = ResolverDetections::NONE;
    //Shots counter
    //int ShotsAtMoveStandDelta = 0;
    int FakeWalkShots = 0;
    bool InFakelag = false;
    bool Fake = true;
    bool Moving = false;
    bool InAir = false;
    int ShotsAtMode[(int)ResolverModes::MAX];
    int OverallShotsAtMode[(int)ResolverModes::MAX];
    int OverallShots = 0;
    float ResolvedYaw = 0.f;
    BacktrackPriorities BacktrackPriority = BacktrackPriorities::none;
    bool BreakingLC = false; //g_Saver.LCbroken = (Globals::LocalPlayer->m_vecOrigin() - g_Saver.FakelagData.pos).LengthSqr() > 4096.f;
    bool CanuseLbyPrediction = false;
    float NextPredictedLbyBreak = 0.f;
};
#else
struct GlobalResolverDataStruct
{
    bool Resolved = false;
    bool ForceBaim = false;
    int Shots = 0;
    int ResolverState = 0; // bad, resolved, lby update, moving
    ResolverModes mode = ResolverModes::NONE;
    ResolverDetections detection = ResolverDetections::NONE;
    //Shots counter
    //int ShotsAtMoveStandDelta = 0;
    int FakeWalkShots = 0;
    bool InFakelag = false;
    bool Fake = true;
    bool Moving = false;
    bool InAir = false;
    int ShotsAtMode[(int)ResolverModes::MAX];
    int OverallShotsAtMode[(int)ResolverModes::MAX];
    int OverallShots = 0;
    //float ResolvedYaw = 0.f;
    //BacktrackPriorities BacktrackPriority = BacktrackPriorities::none;
    bool BreakingLC = false; //g_Saver.LCbroken = (Globals::LocalPlayer->m_vecOrigin() - g_Saver.FakelagData.pos).LengthSqr() > 4096.f;
    bool CanuseLbyPrediction = false;
    float NextPredictedLbyBreak = 0.f;
};
#endif

extern bool InLc;
extern bool InLbyUpdate;
extern bool Moving;

class Resolver : public Singleton<Resolver>
{
public:
    void OnCreateMove(QAngle OrgViewang);
    void OnFramestageNotify();
    void OnFireEvent(IGameEvent* event);
    std::array<GlobalResolverDataStruct, 128> GResolverData;
    std::array<CurrentStandAADataStruct, 128> StandAAData;
private:
    std::array<AASimulationStruct, 128> SimulatedAAs;
    std::array<SavedResolverData, 128> SavedResolverData;

#ifdef FakeAnglesEnabled
    /* gives back if the angle is valid */
    bool IsValidAngle(C_BasePlayer* player, float angle);

    /* get wall distance */
    bool GetWallDistance(C_BasePlayer* player, float& val);

    /* is fakewalking */
    bool InFakeWalk(C_BasePlayer* player, ResolverAnimDataStorage store);
    bool InFakeWalkOld(C_BasePlayer* player, ResolverAnimDataStorage store);

    /* is in big flick */
    bool Is979(C_BasePlayer* player, ResolverAnimDataStorage store, AnimationLayer& layer);

    /* freestand simulation */
    bool FreestandingSim(C_BasePlayer* player, float& ang);

    /* good freestand angles other than main simulation */
    bool GetOkFreestandingOrdered(C_BasePlayer* player, float& ang);

    /* backwards ang */
    bool BackwardsSim(C_BasePlayer* player, float& ang);

    /* at target ang || backwards emulation */
    bool AtTargetSim(C_BasePlayer* player, float& ang);

    /*
        Detections
    */
    std::array<ResolverDetectionData, 128> DetectionData;
    void UpdateDetectionData(C_BasePlayer* player, int i);
    /* Spinbot detections */
    bool IsUsingSpinbot(C_BasePlayer* player, int i, float min_range = 35.f, float tolerance = 25.f);
    /* Static detection */
    bool IsStaticAngle(C_BasePlayer* player, int i, float tolerance = 10.f);
    /* Static jitter or switch detection */
    bool IsStaticSwitchOrJitter(C_BasePlayer* player, int i, float tolerance = 90.f);
    /* Random detection */
    bool IsRandomAngle(C_BasePlayer* player, int i, float tolerance = 25.f);
#else
    std::deque<float> LastYaws[128];
    void AddCurrentYaw(C_BasePlayer* pl, int i);
    bool IsStaticYaw(int i);
    bool GetAverageYaw(int i, float& ang);
#endif
};

extern Resolver g_Resolver;

И resolver.cpp

#include "Resolver.hpp"
#include "../autowall/autowall.hpp"
#include "../../valve_sdk/csgostructs.hpp"
#include "../../helpers\math.hpp"

/*
is fakelag --> set first tick angle
*/

bool InLc = false;
bool InLbyUpdate = false;
bool Moving = false;

void Resolver::OnCreateMove(QAngle OrgViewang)
{
    return;
}

void Resolver::OnFramestageNotify()
{
    for (int i = 1; i < g_EngineClient->GetMaxClients(); i++)
    {
        auto entity = static_cast<C_BasePlayer*> (g_EntityList->GetClientEntity(i));

        if (!entity || !Globals::LocalPlayer || !entity->IsPlayer() || entity == Globals::LocalPlayer || entity->IsDormant()
            || !entity->IsAlive() || entity->IsTeammate())
        {
            g_Resolver.StandAAData[i].UsedEdge = false;
            SavedResolverData[i].WasDormantBetweenMoving = true;
            SavedResolverData[i].CanUseMoveStandDelta = false;
            continue;
        }

        bool InFakeLag = true;

        if (SavedResolverData[i].LastSimtime != entity->m_flSimulationTime())
            InFakeLag = false;

        SavedResolverData[i].LastPos = entity->m_vecOrigin();

        if (InFakeLag)
            g_Resolver.GResolverData[i].BreakingLC = (entity->m_vecOrigin() - SavedResolverData[i].LastPos).LengthSqr() > 4096.f;

        SavedResolverData[i].LastSimtime = entity->m_flSimulationTime();

        //SavedResolverData[i].UsingAA

        //entity->SetAbsOriginal(entity->m_vecOrigin()); //xD

        //entity->SetAbsOriginal(entity->m_vecOrigin()); //fix possition

        g_Resolver.GResolverData[i].InFakelag = InFakeLag;

        ResolverAnimDataStorage AnimationStorage;
        AnimationStorage.UpdateAnimationLayers(entity);

        bool Moving = entity->m_vecVelocity().Length2D() > 0.1f;
        bool SlowWalk = Moving && entity->m_vecVelocity().Length2D() < 52.f && fabs(SavedResolverData[i].LastVel - entity->m_vecVelocity().Length2D()) < 4.f;
        bool InAir = !(entity->m_fFlags() & FL_ONGROUND);
        bool Standing = !Moving && !InAir;

        SavedResolverData[i].LastVel = entity->m_vecVelocity().Length2D();

        if (!InFakeLag)
            AddCurrentYaw(entity, i);

        float avgang = 0.f;
        bool b = GetAverageYaw(i, avgang);

        if (Moving && !SlowWalk && !InAir)
            g_Resolver.GResolverData[i].Resolved = true;
        else if (Moving && SlowWalk && !InAir)
        {
            if (IsStaticYaw(i) && b)
            {
                if (g_Resolver.GResolverData[i].Shots >= 1)
                {
                    switch (g_Resolver.GResolverData[i].Shots % 4)
                    {
                    case 0:
                        entity->m_angEyeAngles().yaw += 58.f;
                        break;

                    case 1:
                        entity->m_angEyeAngles().yaw -= 58.f;
                        break;

                    case 2:
                        entity->m_angEyeAngles().yaw += 29.f;
                        break;

                    case 3:
                        entity->m_angEyeAngles().yaw -= 29.f;
                        break;
                    }
                }
            }

            g_Resolver.GResolverData[i].Resolved = false;

        }
        else if (InAir)
            g_Resolver.GResolverData[i].Resolved = true;
        else
        {
            g_Resolver.GResolverData[i].Resolved = true;
            float fl_ang = fabs(fabs(entity->m_flLowerBodyYawTarget()) - fabs(entity->m_angEyeAngles().yaw));
            bool fake = (fl_ang >= 45.f && fl_ang <= 85.f) || !IsStaticYaw(i);
            float Yaw = entity->m_angEyeAngles().yaw;

            if (fake)
            {
                g_Resolver.GResolverData[i].Resolved = false;

                if (!IsStaticYaw(i) && b)
                    Yaw = avgang;
            }

            if (fake && g_Resolver.GResolverData[i].Shots >= 1)
            {
                switch (g_Resolver.GResolverData[i].Shots % 4)
                {
                case 0:
                    entity->m_angEyeAngles().yaw = Yaw + 58.f;
                    break;

                case 1:
                    entity->m_angEyeAngles().yaw = Yaw - 58.f;
                    break;

                case 2:
                    entity->m_angEyeAngles().yaw = Yaw + 29;
                    break;

                case 3:
                    entity->m_angEyeAngles().yaw = Yaw - 29;
                    break;
                }
            }
        }

        g_Resolver.GResolverData[i].Fake = !g_Resolver.GResolverData[i].Resolved;
    }
}

void Resolver::OnFireEvent(IGameEvent* event)
{
    if (!Globals::LocalPlayer)
        return;

    static float LastPlayerHurt = 0.f;

    if (!strcmp(event->GetName(), "player_hurt"))
    {
        if (g_GlobalVars->curtime == LastPlayerHurt)
            return;

        LastPlayerHurt = g_GlobalVars->curtime;

        int i = g_EngineClient->GetPlayerForUserID(event->GetInt("userid"));
        //C_BasePlayer* p = g_EntityList->GetClientEntity(i);
        //C_BasePlayer* p = static_cast<C_BasePlayer*>(g_EntityList->GetClientEntity(i));
        int attacker = g_EngineClient->GetPlayerForUserID(event->GetInt("attacker"));

        if (attacker != Globals::LocalPlayer->EntIndex())
            return;

        C_BasePlayer* user = static_cast<C_BasePlayer*> (g_EntityList->GetClientEntity(i));

        if (!user)
            return;

        std::string hitgroup = "";

        switch (event->GetInt("hitgroup"))
        {
        case HITBOX_HEAD:
            hitgroup = "HEAD";
            break;

        case HITBOX_NECK:
            hitgroup = "NECK";
            break;

        case HITBOX_PELVIS:
            hitgroup = "PELVIS";
            break;

        case HITBOX_STOMACH:
            hitgroup = "STOMACH";
            break;

        case HITBOX_LOWER_CHEST:
        case HITBOX_CHEST:
        case HITBOX_UPPER_CHEST:
            hitgroup = "CHEST";
            break;

        case HITBOX_RIGHT_THIGH:
        case HITBOX_LEFT_THIGH:
            hitgroup = "THIGH";
            break;

        case HITBOX_RIGHT_CALF:
        case HITBOX_LEFT_CALF:
            hitgroup = "CALF";
            break;

        case HITBOX_RIGHT_FOOT:
        case HITBOX_LEFT_FOOT:
            hitgroup = "FOOT";
            break;

        case HITBOX_RIGHT_HAND:
        case HITBOX_LEFT_HAND:
            hitgroup = "HAND";
            break;

        case HITBOX_RIGHT_UPPER_ARM:
        case HITBOX_RIGHT_FOREARM:
        case HITBOX_LEFT_UPPER_ARM:
        case HITBOX_LEFT_FOREARM:
            hitgroup = "ARM";
            break;
        }

        //std::string InLbyUpdate = g_Saver.RbotShotInfo.InLbyUpdate ? "TRUE" : "FALSE";

        if (!InLbyUpdate)
        {
            g_Resolver.GResolverData[i].ShotsAtMode[(int)g_Resolver.GResolverData[i].mode]--;
            g_Resolver.GResolverData[i].Shots--;

            if (g_Resolver.GResolverData[i].Shots < 0)
                g_Resolver.GResolverData[i].Shots = 0;
        }
    }

    if (!strcmp(event->GetName(), "player_death"))
    {
        int i = g_EngineClient->GetPlayerForUserID(event->GetInt("userid"));
        g_Resolver.GResolverData[i].Shots = 0;
        SavedResolverData[i].MoveStandDelta = 0.f;

        for (int i2 = 0; i2 < (int)ResolverModes::MAX; i2++)
            g_Resolver.GResolverData[i].ShotsAtMode[i2] = 0;
    }

    static std::string lastName = "";
    static std::string lastWeapon = "";

    if (!strcmp(event->GetName(), "item_purchase"))
    {
        int i = g_EngineClient->GetPlayerForUserID(event->GetInt("userid"));
        C_BasePlayer* user = static_cast<C_BasePlayer*> (g_EntityList->GetClientEntity(i));

        if (!user)
            return;

        if (lastName == user->GetPlayerInfo().szName && lastWeapon == event->GetString("weapon"))
            return;

        lastName = user->GetPlayerInfo().szName;
        lastWeapon = event->GetString("weapon");
    }

    if (!strcmp(event->GetName(), "round_end"))
    {
        for (int i = 1; i < g_EngineClient->GetMaxClients(); i++)
        {
            g_Resolver.GResolverData[i].Shots = 0;
            SavedResolverData[i].MoveStandDelta = 0.f;

            for (int i2 = 0; i2 < (int)ResolverModes::MAX; i2++)
                g_Resolver.GResolverData[i].ShotsAtMode[i2] = 0;
        }
    }

    if (!strcmp(event->GetName(), "player_disconnect"))
    {
        int i = g_EngineClient->GetPlayerForUserID(event->GetInt("userid"));

        if (i == g_EngineClient->GetLocalPlayer())
            return;

        g_Resolver.GResolverData[i].Shots = 0;
        SavedResolverData[i].MoveStandDelta = 0.f;

        for (int i2 = 0; i2 < (int)ResolverModes::MAX; i2++)
            g_Resolver.GResolverData[i].ShotsAtMode[i2] = 0;
    }
}

#ifdef FakeAnglesEnabled
bool Resolver::InFakeWalk(C_BasePlayer* player, ResolverAnimDataStorage store)
{
    /*
    bool
        bFakewalking = false,
        stage1 = false,            // stages needed cause we are iterating all layers, eitherwise won't work :)
        stage2 = false,
        stage3 = false;

    for (int i = 0; i < store.m_iLayerCount; i++)
    {
        if (store.animationLayer[i].m_nSequence == 26 && store.animationLayer[i].m_flWeight < 0.47f)
            stage1 = true;
        if (store.animationLayer[i].m_nSequence == 7 && store.animationLayer[i].m_flWeight > 0.001f)
            stage2 = true;
        if (store.animationLayer[i].m_nSequence == 2 && store.animationLayer[i].m_flWeight == 0)
            stage3 = true;
    }

    if (stage1 && stage2)
        if (stage3 || (player->m_fFlags() & FL_DUCKING)) // since weight from stage3 can be 0 aswell when crouching, we need this kind of check, cause you can fakewalk while crouching, thats why it's nested under stage1 and stage2
            bFakewalking = true;
        else
            bFakewalking = false;
    else
        bFakewalking = false;

    return bFakewalking;
    */
    AnimationLayer anim_layers[15];

    bool check_1 = false, check_2 = false, check_3 = false;

    for (int i = 0; i < store.m_iLayerCount; i++)
    {
        anim_layers[i] = store.animationLayer[i];

        if (anim_layers[i].m_nSequence == 8 && anim_layers[i].m_flWeight == 1)
            check_1 = true;

        if (anim_layers[i].m_nSequence == 7 && anim_layers[i].m_flWeight > 0.f && anim_layers[i].m_flWeight < 0.003f)
            check_2 = true;

        if (anim_layers[i].m_nSequence == 26 && anim_layers[i].m_flWeight > 0.f && anim_layers[i].m_flWeight < 0.3f  && anim_layers[i].m_flPlaybackRate > 0.f && anim_layers[i].m_flPlaybackRate < 0.001f)
            check_3 = true;

    }

    if ((check_1 && check_2 && check_3))
        return true;
    else
        return false;

    return false;
}

bool Resolver::InFakeWalkOld(C_BasePlayer* player, ResolverAnimDataStorage store)
{
    bool
        bFakewalking = false,
        stage1 = false,            // stages needed cause we are iterating all layers, eitherwise won't work :)
        stage2 = false,
        stage3 = false;

    for (int i = 0; i < store.m_iLayerCount; i++)
    {
        if (store.animationLayer[i].m_nSequence == 26 && store.animationLayer[i].m_flWeight < 0.47f)
            stage1 = true;

        if (store.animationLayer[i].m_nSequence == 7 && store.animationLayer[i].m_flWeight > 0.001f)
            stage2 = true;

        if (store.animationLayer[i].m_nSequence == 2 && store.animationLayer[i].m_flWeight == 0)
            stage3 = true;
    }

    if (stage1 && stage2)
        if (stage3 || (player->m_fFlags() & FL_DUCKING)) // since weight from stage3 can be 0 aswell when crouching, we need this kind of check, cause you can fakewalk while crouching, thats why it's nested under stage1 and stage2
            bFakewalking = true;
        else
            bFakewalking = false;
    else
        bFakewalking = false;

    return bFakewalking;
}

bool Resolver::IsValidAngle(C_BasePlayer* player, float angle)
{
    return fabs(player->m_flLowerBodyYawTarget() - angle) > 30.f;
}

bool Resolver::GetWallDistance(C_BasePlayer* player, float& val)
{
    if (!player)
        return false;

    Vector position = player->m_vecOrigin() + player->m_vecViewOffset();
    float closest_distance = 250.f;
    float radius = 250.f;
    float step = M_PI * 2.0 / 18;

    for (float a = 0; a < (M_PI * 2.0); a += step)
    {
        Vector location(radius * cos(a) + position.x, radius * sin(a) + position.y, position.z);
        Ray_t ray;
        trace_t tr;
        ray.Init(position, location);
        CTraceFilter traceFilter;
        traceFilter.pSkip = player;
        g_EngineTrace->TraceRay(ray, 0x4600400B, &traceFilter, &tr);

        float distance = position.DistTo(tr.endpos);

        if (distance < closest_distance)
        {
            closest_distance = distance;
            //angle.yaw = RAD2DEG(a);
        }
    }

    if (closest_distance >= radius)
        return false;

    val = closest_distance;
    return true;
}

bool Resolver::Is979(C_BasePlayer* player, ResolverAnimDataStorage store, AnimationLayer& layer)
{
    int layers = store.m_iLayerCount;

    for (int i = 0; i < layers; i++)
    {
        const int activity = player->GetSequenceActivity(store.animationLayer[i].m_nSequence);

        if (activity == ACT_CSGO_IDLE_TURN_BALANCEADJUST)
        {
            layer = store.animationLayer[i];
            return true;
        }
    }

    return false;
}

bool Resolver::FreestandingSim(C_BasePlayer* player, float& ang)
{
    if (!player || !player->IsAlive() || !Globals::LocalPlayer)
        return false;

    bool no_active = true;
    static float hold = 0.f;
    Vector besthead;

    auto leyepos = player->m_vecOrigin() + player->m_vecViewOffset();
    auto headpos = player->GetHitboxPos(0); //GetHitboxPosition(local_player, 0);
    auto origin = player->m_vecOrigin();

    auto checkWallThickness = [&](C_BasePlayer * pPlayer, Vector newhead) -> float
    {

        Vector endpos1, endpos2;

        Vector eyepos = pPlayer->m_vecOrigin() + pPlayer->m_vecViewOffset();
        Ray_t ray;
        ray.Init(newhead, eyepos);
        CTraceFilterSkipTwoEntities filter(pPlayer, player);

        trace_t trace1, trace2;
        g_EngineTrace->TraceRay(ray, MASK_SHOT_BRUSHONLY | MASK_OPAQUE_AND_NPCS, &filter, &trace1);

        if (trace1.DidHit())
            endpos1 = trace1.endpos;
        else
            return 0.f;

        ray.Init(eyepos, newhead);
        g_EngineTrace->TraceRay(ray, MASK_SHOT_BRUSHONLY | MASK_OPAQUE_AND_NPCS, &filter, &trace2);

        if (trace2.DidHit())
            endpos2 = trace2.endpos;

        float add = newhead.DistTo(eyepos) - leyepos.DistTo(eyepos) + 3.f;
        return endpos1.DistTo(endpos2) + add / 3;

    };

    //int index = GetNearestPlayerToCrosshair();
    //static C_BasePlayer* entity;

    if (!player->IsAlive())
        hold = 0.f;


    float radius = Vector(headpos - origin).Length2D();

    auto CheckAllAnglesForEntity = [&](C_BasePlayer * pPlayer, bool & CanUse) -> float
    {
        CanUse = false;

        if (!pPlayer)
            return 0.f;

        float cbestrotation = 0.f;
        float chighestthickness = 0.f;

        float step = (M_PI * 2) / 90;

        for (float besthead = 0; besthead < (M_PI * 2); besthead += step)
        {
            Vector newhead(radius * cos(besthead) + leyepos.x, radius * sin(besthead) + leyepos.y, leyepos.z);
            float totalthickness = 0.f;
            totalthickness += checkWallThickness(pPlayer, newhead);

            if (totalthickness > chighestthickness && fabs(pPlayer->m_flLowerBodyYawTarget() - RAD2DEG(besthead)) > 20.f
                && fabs(SavedResolverData[pPlayer->EntIndex()].FakeYaw - RAD2DEG(besthead)) > 20.f)
            {
                chighestthickness = totalthickness;
                cbestrotation = besthead;
                CanUse = true;
            }
        }

        return cbestrotation;
    };


    float r = 0.f;
    int c = 0;

    if (!Globals::LocalPlayer || !Globals::LocalPlayer->IsAlive())
    {
        std::vector<C_BasePlayer*> enemies;

        for (int i = 1; i < g_EngineClient->GetMaxClients(); i++)
        {
            auto entity = static_cast<C_BasePlayer*> (g_EntityList->GetClientEntity(i));

            if (!entity || !Globals::LocalPlayer || !entity->IsPlayer() || entity == player || entity->IsDormant()
                || !entity->IsAlive() || !entity->IsEnemy())
                continue;

            enemies.push_back(entity);
        }

        if (enemies.size() != 0)
            no_active = false;

        for (auto enemy = enemies.begin(); enemy != enemies.end(); enemy++)
        {
            bool b = false;
            float t = RAD2DEG(CheckAllAnglesForEntity(*enemy, b));

            if (b)
            {
                c++;
                r += t;
            }
        }
    }
    else
    {
        c = 1;
        bool b = false;
        r = RAD2DEG(CheckAllAnglesForEntity(Globals::LocalPlayer, b));

        if (!b)
            return false;

        no_active = false;
    }

    if (no_active)
        return false;
    else
    {
        ang = r / c;
        return true;
    }

    return false;
}

bool Resolver::GetOkFreestandingOrdered(C_BasePlayer* player, float& ang)
{
    return false;
}

bool Resolver::BackwardsSim(C_BasePlayer* player, float& ang)
{
    return false;
}

bool Resolver::AtTargetSim(C_BasePlayer* player, float& ang)
{
    if (!Globals::LocalPlayer || !Globals::LocalPlayer->IsAlive())
        return false;

    Vector eye_position = Globals::LocalPlayer->GetEyePos();

    Vector target_position = player->GetEyePos();
    ang = Math::CalcAngle(target_position, eye_position).yaw - 180.f;

    return true;
}

void Resolver::UpdateDetectionData(C_BasePlayer* player, int i)
{
    DetectionData[i].AllLbys.push_back(player->m_flLowerBodyYawTarget());
    DetectionData[i].LastAddSimtime.push_back(player->m_flSimulationTime());
    DetectionData[i].LastSimtime = player->m_flSimulationTime();

    if (DetectionData[i].AllLbys.size() >= 2)
        DetectionData[i].WasMoving = false;

    if ((int)DetectionData[i].AllLbys.size() > 4)
        DetectionData[i].AllLbys.erase(DetectionData[i].AllLbys.begin());
}

bool Resolver::IsUsingSpinbot(C_BasePlayer* player, int i, float min_range, float tolerance)
{
    if (DetectionData[i].WasMoving)
        return DetectionData[i].BeforeMoving == DetectionModes::Spinning;

    if (DetectionData[i].AllLbys.size() < 2 || IsStaticAngle(player, i))
        return false;

    //bool IsSpin = false;
    float LastLby = 0.f;
    float AverageChange = 0.f;
    float LastChange = 0.f;

    for (auto lby = DetectionData[i].AllLbys.begin(); lby != DetectionData[i].AllLbys.end(); lby++)
    {
        if (LastLby == 0.f)
        {
            LastLby = *lby;
            continue;
        }

        float CurrentChange = LastLby - *lby;
        AverageChange += CurrentChange;

        if (LastChange == 0.f)
        {
            LastChange = CurrentChange;
            continue;
        }

        if (fabs(LastChange - CurrentChange) > tolerance)
            return false;
    }

    AverageChange /= DetectionData[i].AllLbys.size();

    DetectionData[i].SpinSpeed = AverageChange;

    if (fabs(AverageChange) > min_range)
        return true;

    return false;
}

bool Resolver::IsStaticAngle(C_BasePlayer* player, int i, float tolerance)
{
    if (DetectionData[i].WasMoving)
        return DetectionData[i].BeforeMoving == DetectionModes::Static;

    if (DetectionData[i].AllLbys.size() < 2)
        return true;

    bool IsStatic = true;
    float LastLby = 0.f;

    for (auto lby = DetectionData[i].AllLbys.begin(); lby != DetectionData[i].AllLbys.end(); lby++)
    {
        if (!IsStatic)
            continue;

        if (LastLby == 0.f)
            LastLby = *lby;

        if (fabs(LastLby - *lby) > tolerance)
            IsStatic = false;
    }

    return IsStatic;
}

bool Resolver::IsStaticSwitchOrJitter(C_BasePlayer* player, int i, float tolerance)
{
    //if (DetectionData[i].WasMoving) return DetectionData[i].BeforeMoving == DetectionModes::Random;
    if (DetectionData[i].AllLbys.size() < 2 || IsStaticAngle(player, i))
        return false;

    /*
    bool IsStatic = true;
    float LastLby = 0.f;
    for (auto lby = DetectionData[i].AllLbys.begin(); lby != DetectionData[i].AllLbys.end(); lby++)
    {
        if (!IsStatic) continue;
        if (LastLby == 0.f) LastLby = *lby;

        if (fabs(LastLby - *lby) > tolerance) IsStatic = false;
    }
    */

    return false;
}

bool Resolver::IsRandomAngle(C_BasePlayer* player, int i, float tolerance)
{
    if (DetectionData[i].WasMoving)
        return DetectionData[i].BeforeMoving == DetectionModes::Random;

    return !IsStaticAngle(player, i) && !IsUsingSpinbot(player, i, 35.f, tolerance);
}
#else
void Resolver::AddCurrentYaw(C_BasePlayer* pl, int i)
{
    LastYaws[i].push_back(pl->m_angEyeAngles().yaw);

    if (LastYaws[i].size() > 8)
        LastYaws[i].erase(LastYaws[i].begin());
}
bool Resolver::IsStaticYaw(int i)
{
    if (LastYaws[i].size() < 3)
        return true;

    //float LastYaw = 0.f;
    //float LastYaw2 = 0.f;
    //bool ReturnVal = true;

    float HighestDifference = 0.f;

    for (size_t p = 0; p < LastYaws[i].size(); p++)
    {
        for (size_t p2 = 0; p2 < LastYaws[i].size(); p2++)
        {
            float c = fabs(fabs(LastYaws[i].at(p)) - fabs(LastYaws[i].at(p2)));

            if (c > HighestDifference)
                HighestDifference = c;
        }
    }

    if (HighestDifference > 15.f)
        return false;
    else
        return true;
}
bool Resolver::GetAverageYaw(int i, float& ang)
{
    if (LastYaws[i].size() < 3)
        return true;

    float add = 0.f;

    for (size_t p = 0; p < LastYaws[i].size(); p++)
        add += LastYaws[i].at(p);

    ang = add / LastYaws[i].size();
    return true;
}
#endif// FakeAnglesEnabled

Resolver g_Resolver;

 

[egorqa]

Это ресольвер nixware.cc, а я его хочу вставить в xy0

 

[slayergod]

Это ресольвер nixware.cc, а я его хочу вставить в xy0

Очень плохая идея

 

[Dreammm]

а вот причина миссов в никсваре

 

[egorqa]

У меня еще есть ресольвер, только я ньюкамер в визуалке, и не умею, помоги пожалуйста

 

[egorqa]

а вот причина миссов в никсваре

Помоги

 

[Onesell]

Чел твоя паста с этим резольвером хуже фейка скита

 

[egorqa]

А как мне другой ресольвер поставить?

 

[egorqa]

Чел твоя паста с этим резольвером хуже фейка скита

?

 

[idesync]

короче ищи в своем коде вот эти кейсы

                        entity->m_angEyeAngles().yaw += 58.f;
                        break;

                    case 1:
                        entity->m_angEyeAngles().yaw -= 58.f;
                        break;

                    case 2:
                        entity->m_angEyeAngles().yaw += 29.f;
                        break;

                    case 3:
                        entity->m_angEyeAngles().yaw -= 29.f;
                        break;
                    }

И меняй: 58 на 360, -58 на -360, 29 на 180, -29 на -180 ну или какие у тебя там цифры сам поймешь
это даже лучше чем ресик никсвара

 

[egorqa]

Фенкс мужик

 

[egorqa]

короче ищи в своем коде вот эти кейсы

                        entity->m_angEyeAngles().yaw += 58.f;
                        break;

                    case 1:
                        entity->m_angEyeAngles().yaw -= 58.f;
                        break;

                    case 2:
                        entity->m_angEyeAngles().yaw += 29.f;
                        break;

                    case 3:
                        entity->m_angEyeAngles().yaw -= 29.f;
                        break;
                    }

И меняй: 58 на 360, -58 на -360, 29 на 180, -29 на -180 ну или какие у тебя там цифры сам поймешь
это даже лучше чем ресик никсвара

За что так грубо?( я же сказал спасибо

 

[public-enemy]

короче ищи в своем коде вот эти кейсы

                        entity->m_angEyeAngles().yaw += 58.f;
                        break;

                    case 1:
                        entity->m_angEyeAngles().yaw -= 58.f;
                        break;

                    case 2:
                        entity->m_angEyeAngles().yaw += 29.f;
                        break;

                    case 3:
                        entity->m_angEyeAngles().yaw -= 29.f;
                        break;
                    }

И меняй: 58 на 360, -58 на -360, 29 на 180, -29 на -180 ну или какие у тебя там цифры сам поймешь
это даже лучше чем ресик никсвара

Ну как бы m_flGoalFeetYaw ок да

 

[public-enemy]

Ну а вообще если знаний у тебя как таковых нету то лучше сделай так :
1) Найди функцию самого ресольвера
2) Удали всё к ебеням
3) Спасти это :

auto restore = player->m_angEyeAngles().y; // нужен будет их постоянный рестор объяснять почему думаю не стоит
animstate->m_flGoalFeetYaw = missed_shot < 1 ? restore - 60 : restore + 60;
// можешь добавить мидляв (ака дефолт бэквард в свой ресольвер)
// auto midle_yaw = player->m_angEyeAngles().y;

Если что этот код будет куда лучше,чище,полезнее чем все твои овердохуя строчек и ломанных моментов в игре..
Да и работать он будет а это важно

 

[egorqa]

Ну а вообще если знаний у тебя как таковых нету то лучше сделай так :
1) Найди функцию самого ресольвера
2) Удали всё к ебеням
3) Спасти это :

auto restore = player->m_angEyeAngles().y; // нужен будет их постоянный рестор объяснять почему думаю не стоит
animstate->m_flGoalFeetYaw = missed_shot < 1 ? restore - 60 : restore + 60;
// можешь добавить мидляв (ака дефолт бэквард в свой ресольвер)
// auto midle_yaw = player->m_angEyeAngles().y;

Если что этот код будет куда лучше,чище,полезнее чем все твои овердохуя строчек и ломанных моментов в игре..
Да и работать он будет а это важно

просто удалить из resolver.cpp все и вставить этот код?

 

[public-enemy]

Незнаю что не понравилось этому клоуну @BladeMight aka 12y.o kid paster
Но вводить в людей в заблуждения скидывая ресольверы по eyeAng дело гнилое...
Если ты настолько туп и незнаешь как вообще работает ресольвер и какие углы рассинхронизированы на сервере могу скинуть тебе пару дампов,реверс кодов как с игры так и с вантапа luul

 

[ItsFaiter]

просто удалить из resolver.cpp все и вставить этот код?

#include "Resolver.h"
#include "..\Aimbot\Aimbot.h"
#include "..\Aimbot\Autowall.h"
#include "..\Aimbot\LagComp.h"
#include "..\..\Utils\Utils.h"
#include "..\..\SDK\IVEngineClient.h"
#include "..\..\SDK\Hitboxes.h"
#include "..\..\SDK\PlayerInfo.h"
#include "..\..\Utils\Math.h"
#include "..\..\Menu\Menu.h"
#include "..\..\Menu\config.h"
#include "..\..\SDK\CEntity.h"
#include "..\..\SDK\IBaseClientDll.h"

Resolver g_Resolver;

template<class T, class U>
inline T clamp(T in, U low, U high)
{
    if (in <= low)
        return low;
    else if (in >= high)
        return high;
    else
        return in;
}

void BotCheck(C_BaseEntity* ent)
{

}

static auto GetSmoothedVelocity = [](float min_delta, Vector a, Vector b) {
    Vector delta = a - b;
    float delta_length = delta.Length();

    if (delta_length <= min_delta) {
        Vector result;
        if (-min_delta <= delta_length) {
            return a;
        }
        else {
            float iradius = 1.0f / (delta_length + FLT_EPSILON);
            return b - ((delta * iradius) * min_delta);
        }
    }
    else {
        float iradius = 1.0f / (delta_length + FLT_EPSILON);
        return b + ((delta * iradius) * min_delta);
    }
};

float AngleNormalize(float angle)
{
    angle = fmodf(angle, 360.0f);
    if (angle > 180)
    {
        angle -= 360;
    }
    if (angle < -180)
    {
        angle += 360;
    }
    return angle;
}

float ApproachAngle(float target, float value, float speed)
{
    target = (target * 182.04445f) * 0.0054931641f;
    value = (value * 182.04445f) * 0.0054931641f;

    float delta = target - value;

    // Speed is assumed to be positive
    if (speed < 0)
        speed = -speed;

    if (delta < -180.0f)
        delta += 360.0f;
    else if (delta > 180.0f)
        delta -= 360.0f;

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

    return value;
}

void proper_brute(C_BaseEntity* ent)
{
    if (!Globals::LocalPlayer->IsAlive())
        return;

    auto animState = ent->AnimState();
    float m_flFakeGoalFeetYaw[65];
    // Rebuild setup velocity to receive flMinBodyYaw and flMaxBodyYaw
    Vector velocity = ent->GetVelocity();
    float spd = velocity.LengthSqr();
    if (spd > std::powf(1.2f * 260.0f, 2.f)) {
        Vector velocity_normalized = velocity.Normalize();
        velocity = velocity_normalized * (1.2f * 260.0f);
    }

    float v25 = clamp(ent->m_fDuckSpeed() + animState->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
    float v26 = animState->m_fDuckAmount;
    float v27 = g_pClientState->m_nChokedCommands * 6.0f;
    float v28;

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

    float flDuckAmount = clamp(v28, 0.0f, 1.0f);

    Vector animationVelocity = GetSmoothedVelocity(g_pClientState->m_nChokedCommands * 2000.0f, velocity, ent->GetVelocity());
    float speed = std::fminf(animationVelocity.Length(), 260.0f);

    auto weapon = ent->GetActiveWeapon();

    float flMaxMovementSpeed = 260.0f;
    if (weapon) {
        flMaxMovementSpeed = std::fmaxf(weapon->GetCSWpnData()->max_speed, 0.001f);
    }
    float m_flGroundFraction = *(float*)(animState + 0x11C);
    float flRunningSpeed = speed / (flMaxMovementSpeed * 0.520f);
    float flDuckingSpeed = speed / (flMaxMovementSpeed * 0.340f);

    flRunningSpeed = clamp(flRunningSpeed, 0.0f, 1.0f);

    float flYawModifier = (((m_flGroundFraction * -0.3f) - 0.2f) * flRunningSpeed) + 1.0f;
    if (flDuckAmount > 0.0f) {
        float flDuckingSpeed = clamp(flDuckingSpeed, 0.0f, 1.0f);
        flYawModifier += (flDuckAmount * flDuckingSpeed) * (0.5f - flYawModifier);
    }

    float flMinBodyYaw = std::fabsf(((float)(uintptr_t(animState) + 0x330)) * flYawModifier);
    float flMaxBodyYaw = std::fabsf(((float)(uintptr_t(animState) + 0x334)) * flYawModifier);

    float flEyeYaw = ent->GetEyeAngles().y;
    float flEyeDiff = std::remainderf(flEyeYaw - m_flFakeGoalFeetYaw[ent->EntIndex()], 360.f);

    if (flEyeDiff <= flMaxBodyYaw) {
        if (flMinBodyYaw > flEyeDiff)
            m_flFakeGoalFeetYaw[ent->EntIndex()] = fabs(flMinBodyYaw) + flEyeYaw;
    }
    else {
        m_flFakeGoalFeetYaw[ent->EntIndex()] = flEyeYaw - fabs(flMaxBodyYaw);
    }

    m_flFakeGoalFeetYaw[ent->EntIndex()] = std::remainderf(m_flFakeGoalFeetYaw[ent->EntIndex()], 360.f);

    if (speed > 0.1f || fabs(velocity.z) > 100.0f) {
        m_flFakeGoalFeetYaw[ent->EntIndex()] = ApproachAngle(
            flEyeYaw,
            m_flFakeGoalFeetYaw[ent->EntIndex()],
            ((m_flGroundFraction * 20.0f) + 30.0f)
            * g_pClientState->m_nChokedCommands);
    }
    else {
        m_flFakeGoalFeetYaw[ent->EntIndex()] = ApproachAngle(
            ent->GetLowerBodyYaw(),
            m_flFakeGoalFeetYaw[ent->EntIndex()],
            g_pClientState->m_nChokedCommands * 100.0f);
    }

    float Left = flEyeYaw + flMinBodyYaw;
    float Right = flEyeYaw + flMaxBodyYaw;

    float resolveYaw;

    switch (Globals::MissedShots[ent->EntIndex()] % 3) {
    case 0: // brute left side
        resolveYaw = Left;
        break;
    case 1: // brute fake side
        resolveYaw = m_flFakeGoalFeetYaw[ent->EntIndex()];
        break;
    case 2: // brute right side
        resolveYaw = Right;
        break;
    default:
        break;
    }

    animState->m_flGoalFeetYaw = resolveYaw;
}

void Resolver::AnimationFix(C_BaseEntity* pEnt)
{
    if (!pEnt || !pEnt->IsAlive() || pEnt == Globals::LocalPlayer || pEnt->GetTeam() == Globals::LocalPlayer->GetTeam())
        return;

    if (!Globals::LocalPlayer || !Globals::LocalPlayer->IsAlive() || !Globals::LocalPlayer->GetActiveWeapon() || Globals::LocalPlayer->GetActiveWeapon()->GetAmmo() == 0)
        return;

    float* PosParams = (float*)((uintptr_t)pEnt + 0x2774);
    auto* AnimState = pEnt->AnimState();
    if (!AnimState || !pEnt->AnimOverlays() || !PosParams)
        return;

    // backup
    const float curtime = g_pGlobalVars->curtime;
    const float frametime = g_pGlobalVars->frametime;

    g_pGlobalVars->frametime = g_pGlobalVars->intervalPerTick;
    g_pGlobalVars->curtime = pEnt->GetSimulationTime();

    int backup_eflags = pEnt->m_iEFlags();

    // SetLocalVelocity
    pEnt->m_iEFlags() &= ~0x1000; // InvalidatePhysicsRecursive(VELOCITY_CHANGED); EFL_DIRTY_ABSVELOCITY = 0x1000
    pEnt->SetAbsVelocity(pEnt->GetVelocity());

    // invalidates prior animations
    if (AnimState->m_iLastClientSideAnimationUpdateFramecount == g_pGlobalVars->framecount)
        AnimState->m_iLastClientSideAnimationUpdateFramecount = g_pGlobalVars->framecount - 1;

    pEnt->ClientAnimations(true);

    // updates local animations + poses + calculates new abs angle based on eyeangles and other stuff
    // call resolver
    proper_brute(pEnt);
    pEnt->UpdateClientAnimation();

    pEnt->ClientAnimations(false);

    // restore
    pEnt->m_iEFlags() = backup_eflags;

    g_pGlobalVars->curtime = curtime;
    g_pGlobalVars->frametime = frametime;

    pEnt->InvalidateBoneCache();
    pEnt->SetupBones(nullptr, -1, 0x7FF00, g_pGlobalVars->curtime);
}

void HandleHits(C_BaseEntity* pEnt)
{
    auto NetChannel = g_pEngine->GetNetChannelInfo();

    if (!NetChannel)
        return;

    static float predTime[65];
    static bool init[65];

    if (Globals::Shot[pEnt->EntIndex()])
    {
        if (init[pEnt->EntIndex()])
        {
            g_Resolver.pitchHit[pEnt->EntIndex()] = pEnt->GetEyeAngles().x;
            predTime[pEnt->EntIndex()] = g_pGlobalVars->curtime + NetChannel->GetAvgLatency(FLOW_INCOMING) + NetChannel->GetAvgLatency(FLOW_OUTGOING) + TICKS_TO_TIME(1) + TICKS_TO_TIME(g_pEngine->GetNetChannel()->m_nChokedPackets);
            init[pEnt->EntIndex()] = false;
        }

        if (g_pGlobalVars->curtime > predTime[pEnt->EntIndex()] && !Globals::Hit[pEnt->EntIndex()])
        {
            Globals::MissedShots[pEnt->EntIndex()] += 1;
            Globals::Shot[pEnt->EntIndex()] = false;
        }
        else if (g_pGlobalVars->curtime <= predTime[pEnt->EntIndex()] && Globals::Hit[pEnt->EntIndex()])
            Globals::Shot[pEnt->EntIndex()] = false;

    }
    else
        init[pEnt->EntIndex()] = true;

    Globals::Hit[pEnt->EntIndex()] = false;
}

void Resolver::OnCreateMove() // cancer v2
{
    if (!c_config::get().aimbot_resolver)
        return;

    if (!Globals::LocalPlayer->IsAlive())
        return;

    if (!Globals::LocalPlayer->GetActiveWeapon() || Globals::LocalPlayer->IsKnifeorNade())
        return;


    for (int i = 1; i < g_pEngine->GetMaxClients(); ++i)
    {
        C_BaseEntity* pPlayerEntity = g_pEntityList->GetClientEntity(i);

        if (!pPlayerEntity
            || !pPlayerEntity->IsAlive()
            || pPlayerEntity->IsDormant()
            || pPlayerEntity == Globals::LocalPlayer
            || pPlayerEntity->GetTeam() == Globals::LocalPlayer->GetTeam())
        {
            UseFreestandAngle[i] = false;
            continue;
        }

        if (abs(pPlayerEntity->GetVelocity().Length2D()) > 29.f)
            UseFreestandAngle[pPlayerEntity->EntIndex()] = false;

        if (abs(pPlayerEntity->GetVelocity().Length2D()) <= 29.f && !UseFreestandAngle[pPlayerEntity->EntIndex()])
        {
            bool Autowalled = false, HitSide1 = false, HitSide2 = false;

            float angToLocal = g_Math.CalcAngle(Globals::LocalPlayer->GetOrigin(), pPlayerEntity->GetOrigin()).y;
            Vector ViewPoint = Globals::LocalPlayer->GetOrigin() + Vector(0, 0, 90);

            Vector2D Side1 = { (45 * sin(g_Math.GRD_TO_BOG(angToLocal))),(45 * cos(g_Math.GRD_TO_BOG(angToLocal))) };
            Vector2D Side2 = { (45 * sin(g_Math.GRD_TO_BOG(angToLocal + 180))) ,(45 * cos(g_Math.GRD_TO_BOG(angToLocal + 180))) };

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

            Vector Origin = pPlayerEntity->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 OriginAutowall2 = { ViewPoint.x + OriginLeftRightLocal[side].x,  ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };

                if (g_Autowall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
                {
                    if (side == 0)
                    {
                        HitSide1 = true;
                        FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                    }
                    else if (side == 1)
                    {
                        HitSide2 = true;
                        FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                    }

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

                        if (g_Autowall.CanHitFloatingPoint(OriginAutowall222, OriginAutowall2))
                        {
                            if (side222 == 0)
                            {
                                HitSide1 = true;
                                FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                            }
                            else if (side222 == 1)
                            {
                                HitSide2 = true;
                                FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                            }

                            Autowalled = true;
                        }
                    }
                }
            }

            if (Autowalled)
            {
                if (HitSide1 && HitSide2)
                    UseFreestandAngle[pPlayerEntity->EntIndex()] = false;
                else
                    UseFreestandAngle[pPlayerEntity->EntIndex()] = true;
            }
        }
    }
}

void Resolver::FrameStage(ClientFrameStage_t stage)
{
    if (!Globals::LocalPlayer || !g_pEngine->IsInGame())
        return;

    static bool  wasDormant[65];

    for (int i = 1; i < g_pEngine->GetMaxClients(); ++i)
    {
        C_BaseEntity* pPlayerEntity = g_pEntityList->GetClientEntity(i);

        if (!pPlayerEntity
            || !pPlayerEntity->IsAlive())
            continue;
        if (pPlayerEntity->IsDormant())
        {
            wasDormant[i] = true;
            continue;
        }

        if (stage == FRAME_RENDER_START)
        {
            HandleHits(pPlayerEntity);
            proper_brute(pPlayerEntity);
            AnimationFix(pPlayerEntity);
        }

        if (stage == FRAME_NET_UPDATE_END && pPlayerEntity != Globals::LocalPlayer)
        {
            auto VarMap = reinterpret_cast<uintptr_t>(pPlayerEntity) + 36;
            auto VarMapSize = *reinterpret_cast<int*>(VarMap + 20);

            for (auto index = 0; index < VarMapSize; index++)
                *reinterpret_cast<uintptr_t*>(*reinterpret_cast<uintptr_t*>(VarMap) + index * 12) = 0;
        }

        wasDormant[i] = false;
    }//
}

 

[Danzil2]

плохая идея, не советую на xy0 менять

 

[PasterAlmir]

#include "Resolver.h"
#include "..\Aimbot\Aimbot.h"
#include "..\Aimbot\Autowall.h"
#include "..\Aimbot\LagComp.h"
#include "..\..\Utils\Utils.h"
#include "..\..\SDK\IVEngineClient.h"
#include "..\..\SDK\Hitboxes.h"
#include "..\..\SDK\PlayerInfo.h"
#include "..\..\Utils\Math.h"
#include "..\..\Menu\Menu.h"
#include "..\..\Menu\config.h"
#include "..\..\SDK\CEntity.h"
#include "..\..\SDK\IBaseClientDll.h"

Resolver g_Resolver;

template<class T, class U>
inline T clamp(T in, U low, U high)
{
    if (in <= low)
        return low;
    else if (in >= high)
        return high;
    else
        return in;
}

void BotCheck(C_BaseEntity* ent)
{

}

static auto GetSmoothedVelocity = [](float min_delta, Vector a, Vector b) {
    Vector delta = a - b;
    float delta_length = delta.Length();

    if (delta_length <= min_delta) {
        Vector result;
        if (-min_delta <= delta_length) {
            return a;
        }
        else {
            float iradius = 1.0f / (delta_length + FLT_EPSILON);
            return b - ((delta * iradius) * min_delta);
        }
    }
    else {
        float iradius = 1.0f / (delta_length + FLT_EPSILON);
        return b + ((delta * iradius) * min_delta);
    }
};

float AngleNormalize(float angle)
{
    angle = fmodf(angle, 360.0f);
    if (angle > 180)
    {
        angle -= 360;
    }
    if (angle < -180)
    {
        angle += 360;
    }
    return angle;
}

float ApproachAngle(float target, float value, float speed)
{
    target = (target * 182.04445f) * 0.0054931641f;
    value = (value * 182.04445f) * 0.0054931641f;

    float delta = target - value;

    // Speed is assumed to be positive
    if (speed < 0)
        speed = -speed;

    if (delta < -180.0f)
        delta += 360.0f;
    else if (delta > 180.0f)
        delta -= 360.0f;

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

    return value;
}

void proper_brute(C_BaseEntity* ent)
{
    if (!Globals::LocalPlayer->IsAlive())
        return;

    auto animState = ent->AnimState();
    float m_flFakeGoalFeetYaw[65];
    // Rebuild setup velocity to receive flMinBodyYaw and flMaxBodyYaw
    Vector velocity = ent->GetVelocity();
    float spd = velocity.LengthSqr();
    if (spd > std::powf(1.2f * 260.0f, 2.f)) {
        Vector velocity_normalized = velocity.Normalize();
        velocity = velocity_normalized * (1.2f * 260.0f);
    }

    float v25 = clamp(ent->m_fDuckSpeed() + animState->m_fLandingDuckAdditiveSomething, 0.0f, 1.0f);
    float v26 = animState->m_fDuckAmount;
    float v27 = g_pClientState->m_nChokedCommands * 6.0f;
    float v28;

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

    float flDuckAmount = clamp(v28, 0.0f, 1.0f);

    Vector animationVelocity = GetSmoothedVelocity(g_pClientState->m_nChokedCommands * 2000.0f, velocity, ent->GetVelocity());
    float speed = std::fminf(animationVelocity.Length(), 260.0f);

    auto weapon = ent->GetActiveWeapon();

    float flMaxMovementSpeed = 260.0f;
    if (weapon) {
        flMaxMovementSpeed = std::fmaxf(weapon->GetCSWpnData()->max_speed, 0.001f);
    }
    float m_flGroundFraction = *(float*)(animState + 0x11C);
    float flRunningSpeed = speed / (flMaxMovementSpeed * 0.520f);
    float flDuckingSpeed = speed / (flMaxMovementSpeed * 0.340f);

    flRunningSpeed = clamp(flRunningSpeed, 0.0f, 1.0f);

    float flYawModifier = (((m_flGroundFraction * -0.3f) - 0.2f) * flRunningSpeed) + 1.0f;
    if (flDuckAmount > 0.0f) {
        float flDuckingSpeed = clamp(flDuckingSpeed, 0.0f, 1.0f);
        flYawModifier += (flDuckAmount * flDuckingSpeed) * (0.5f - flYawModifier);
    }

    float flMinBodyYaw = std::fabsf(((float)(uintptr_t(animState) + 0x330)) * flYawModifier);
    float flMaxBodyYaw = std::fabsf(((float)(uintptr_t(animState) + 0x334)) * flYawModifier);

    float flEyeYaw = ent->GetEyeAngles().y;
    float flEyeDiff = std::remainderf(flEyeYaw - m_flFakeGoalFeetYaw[ent->EntIndex()], 360.f);

    if (flEyeDiff <= flMaxBodyYaw) {
        if (flMinBodyYaw > flEyeDiff)
            m_flFakeGoalFeetYaw[ent->EntIndex()] = fabs(flMinBodyYaw) + flEyeYaw;
    }
    else {
        m_flFakeGoalFeetYaw[ent->EntIndex()] = flEyeYaw - fabs(flMaxBodyYaw);
    }

    m_flFakeGoalFeetYaw[ent->EntIndex()] = std::remainderf(m_flFakeGoalFeetYaw[ent->EntIndex()], 360.f);

    if (speed > 0.1f || fabs(velocity.z) > 100.0f) {
        m_flFakeGoalFeetYaw[ent->EntIndex()] = ApproachAngle(
            flEyeYaw,
            m_flFakeGoalFeetYaw[ent->EntIndex()],
            ((m_flGroundFraction * 20.0f) + 30.0f)
            * g_pClientState->m_nChokedCommands);
    }
    else {
        m_flFakeGoalFeetYaw[ent->EntIndex()] = ApproachAngle(
            ent->GetLowerBodyYaw(),
            m_flFakeGoalFeetYaw[ent->EntIndex()],
            g_pClientState->m_nChokedCommands * 100.0f);
    }

    float Left = flEyeYaw + flMinBodyYaw;
    float Right = flEyeYaw + flMaxBodyYaw;

    float resolveYaw;

    switch (Globals::MissedShots[ent->EntIndex()] % 3) {
    case 0: // brute left side
        resolveYaw = Left;
        break;
    case 1: // brute fake side
        resolveYaw = m_flFakeGoalFeetYaw[ent->EntIndex()];
        break;
    case 2: // brute right side
        resolveYaw = Right;
        break;
    default:
        break;
    }

    animState->m_flGoalFeetYaw = resolveYaw;
}

void Resolver::AnimationFix(C_BaseEntity* pEnt)
{
    if (!pEnt || !pEnt->IsAlive() || pEnt == Globals::LocalPlayer || pEnt->GetTeam() == Globals::LocalPlayer->GetTeam())
        return;

    if (!Globals::LocalPlayer || !Globals::LocalPlayer->IsAlive() || !Globals::LocalPlayer->GetActiveWeapon() || Globals::LocalPlayer->GetActiveWeapon()->GetAmmo() == 0)
        return;

    float* PosParams = (float*)((uintptr_t)pEnt + 0x2774);
    auto* AnimState = pEnt->AnimState();
    if (!AnimState || !pEnt->AnimOverlays() || !PosParams)
        return;

    // backup
    const float curtime = g_pGlobalVars->curtime;
    const float frametime = g_pGlobalVars->frametime;

    g_pGlobalVars->frametime = g_pGlobalVars->intervalPerTick;
    g_pGlobalVars->curtime = pEnt->GetSimulationTime();

    int backup_eflags = pEnt->m_iEFlags();

    // SetLocalVelocity
    pEnt->m_iEFlags() &= ~0x1000; // InvalidatePhysicsRecursive(VELOCITY_CHANGED); EFL_DIRTY_ABSVELOCITY = 0x1000
    pEnt->SetAbsVelocity(pEnt->GetVelocity());

    // invalidates prior animations
    if (AnimState->m_iLastClientSideAnimationUpdateFramecount == g_pGlobalVars->framecount)
        AnimState->m_iLastClientSideAnimationUpdateFramecount = g_pGlobalVars->framecount - 1;

    pEnt->ClientAnimations(true);

    // updates local animations + poses + calculates new abs angle based on eyeangles and other stuff
    // call resolver
    proper_brute(pEnt);
    pEnt->UpdateClientAnimation();

    pEnt->ClientAnimations(false);

    // restore
    pEnt->m_iEFlags() = backup_eflags;

    g_pGlobalVars->curtime = curtime;
    g_pGlobalVars->frametime = frametime;

    pEnt->InvalidateBoneCache();
    pEnt->SetupBones(nullptr, -1, 0x7FF00, g_pGlobalVars->curtime);
}

void HandleHits(C_BaseEntity* pEnt)
{
    auto NetChannel = g_pEngine->GetNetChannelInfo();

    if (!NetChannel)
        return;

    static float predTime[65];
    static bool init[65];

    if (Globals::Shot[pEnt->EntIndex()])
    {
        if (init[pEnt->EntIndex()])
        {
            g_Resolver.pitchHit[pEnt->EntIndex()] = pEnt->GetEyeAngles().x;
            predTime[pEnt->EntIndex()] = g_pGlobalVars->curtime + NetChannel->GetAvgLatency(FLOW_INCOMING) + NetChannel->GetAvgLatency(FLOW_OUTGOING) + TICKS_TO_TIME(1) + TICKS_TO_TIME(g_pEngine->GetNetChannel()->m_nChokedPackets);
            init[pEnt->EntIndex()] = false;
        }

        if (g_pGlobalVars->curtime > predTime[pEnt->EntIndex()] && !Globals::Hit[pEnt->EntIndex()])
        {
            Globals::MissedShots[pEnt->EntIndex()] += 1;
            Globals::Shot[pEnt->EntIndex()] = false;
        }
        else if (g_pGlobalVars->curtime <= predTime[pEnt->EntIndex()] && Globals::Hit[pEnt->EntIndex()])
            Globals::Shot[pEnt->EntIndex()] = false;

    }
    else
        init[pEnt->EntIndex()] = true;

    Globals::Hit[pEnt->EntIndex()] = false;
}

void Resolver::OnCreateMove() // cancer v2
{
    if (!c_config::get().aimbot_resolver)
        return;

    if (!Globals::LocalPlayer->IsAlive())
        return;

    if (!Globals::LocalPlayer->GetActiveWeapon() || Globals::LocalPlayer->IsKnifeorNade())
        return;


    for (int i = 1; i < g_pEngine->GetMaxClients(); ++i)
    {
        C_BaseEntity* pPlayerEntity = g_pEntityList->GetClientEntity(i);

        if (!pPlayerEntity
            || !pPlayerEntity->IsAlive()
            || pPlayerEntity->IsDormant()
            || pPlayerEntity == Globals::LocalPlayer
            || pPlayerEntity->GetTeam() == Globals::LocalPlayer->GetTeam())
        {
            UseFreestandAngle[i] = false;
            continue;
        }

        if (abs(pPlayerEntity->GetVelocity().Length2D()) > 29.f)
            UseFreestandAngle[pPlayerEntity->EntIndex()] = false;

        if (abs(pPlayerEntity->GetVelocity().Length2D()) <= 29.f && !UseFreestandAngle[pPlayerEntity->EntIndex()])
        {
            bool Autowalled = false, HitSide1 = false, HitSide2 = false;

            float angToLocal = g_Math.CalcAngle(Globals::LocalPlayer->GetOrigin(), pPlayerEntity->GetOrigin()).y;
            Vector ViewPoint = Globals::LocalPlayer->GetOrigin() + Vector(0, 0, 90);

            Vector2D Side1 = { (45 * sin(g_Math.GRD_TO_BOG(angToLocal))),(45 * cos(g_Math.GRD_TO_BOG(angToLocal))) };
            Vector2D Side2 = { (45 * sin(g_Math.GRD_TO_BOG(angToLocal + 180))) ,(45 * cos(g_Math.GRD_TO_BOG(angToLocal + 180))) };

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

            Vector Origin = pPlayerEntity->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 OriginAutowall2 = { ViewPoint.x + OriginLeftRightLocal[side].x,  ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };

                if (g_Autowall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
                {
                    if (side == 0)
                    {
                        HitSide1 = true;
                        FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                    }
                    else if (side == 1)
                    {
                        HitSide2 = true;
                        FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                    }

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

                        if (g_Autowall.CanHitFloatingPoint(OriginAutowall222, OriginAutowall2))
                        {
                            if (side222 == 0)
                            {
                                HitSide1 = true;
                                FreestandAngle[pPlayerEntity->EntIndex()] = 90;
                            }
                            else if (side222 == 1)
                            {
                                HitSide2 = true;
                                FreestandAngle[pPlayerEntity->EntIndex()] = -90;
                            }

                            Autowalled = true;
                        }
                    }
                }
            }

            if (Autowalled)
            {
                if (HitSide1 && HitSide2)
                    UseFreestandAngle[pPlayerEntity->EntIndex()] = false;
                else
                    UseFreestandAngle[pPlayerEntity->EntIndex()] = true;
            }
        }
    }
}

void Resolver::FrameStage(ClientFrameStage_t stage)
{
    if (!Globals::LocalPlayer || !g_pEngine->IsInGame())
        return;

    static bool  wasDormant[65];

    for (int i = 1; i < g_pEngine->GetMaxClients(); ++i)
    {
        C_BaseEntity* pPlayerEntity = g_pEntityList->GetClientEntity(i);

        if (!pPlayerEntity
            || !pPlayerEntity->IsAlive())
            continue;
        if (pPlayerEntity->IsDormant())
        {
            wasDormant[i] = true;
            continue;
        }

        if (stage == FRAME_RENDER_START)
        {
            HandleHits(pPlayerEntity);
            proper_brute(pPlayerEntity);
            AnimationFix(pPlayerEntity);
        }

        if (stage == FRAME_NET_UPDATE_END && pPlayerEntity != Globals::LocalPlayer)
        {
            auto VarMap = reinterpret_cast<uintptr_t>(pPlayerEntity) + 36;
            auto VarMapSize = *reinterpret_cast<int*>(VarMap + 20);

            for (auto index = 0; index < VarMapSize; index++)
                *reinterpret_cast<uintptr_t*>(*reinterpret_cast<uintptr_t*>(VarMap) + index * 12) = 0;
        }

        wasDormant[i] = false;
    }//
}

float m_flFakeGoalFeetYaw[65];

пиздец

 

[ItsFaiter]

пиздец

не мой ресольвер, это пропера от ламы