Что нового?

Weave resolver issue

St1lyka
St1lyka
Начинающий
Статус
Оффлайн
Регистрация
28 Авг 2020
Сообщения
20
Реакции[?]
9
Поинты[?]
0
Короче проблема в том , что вейви миссает всегда первую пулю . Играть с дт вообще невозможно.

Flowseal ты вроде wayvee пастишь, хелпани пожалуйста
И не нужно писать read learncpp.com или давать мне что-то подобное, я заебался уже что-то пытаться сделать. Где и как именно нужно посиксить ресольвер?

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::NormalizeYaw(player->GetEyeAngles().y);

}



float CResolver::GetForwardYaw(IBasePlayer* player) {

    return Math::NormalizeYaw(GetBackwardYaw(player) - 180.f);

}



float CResolver::GetBackwardYaw(IBasePlayer* player) {

    return Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;

}



float CResolver::GetLeftYaw(IBasePlayer* player) {

    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 90.f);

}



float CResolver::GetRightYaw(IBasePlayer* player) {

    return Math::NormalizeYaw(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::NormalizeYaw(yaw + 90.f))

        >= fabsf(GetAngle(player) - Math::NormalizeYaw(yaw - 90.f));

}

bool CResolver::TargetSide(IBasePlayer* player) {

    float yaw = Math::NormalizeYaw(GetBackwardYaw(player));

    float angle = GetAngle(player);

    return fabsf(angle - Math::NormalizeYaw(yaw + 90.f))

        >= fabsf(angle - Math::NormalizeYaw(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;

    CTraceFilter filter;



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



    filter.pSkip = player;

    src3D = player->GetEyePosition();

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



    ray.Init(src3D, dst3D);

    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);

    back_two = (tr.endpos - tr.startpos).Length();



    ray2.Init(src3D + right * 35, dst3D + right * 35);

    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);

    right_two = (tr.endpos - tr.startpos).Length();



    ray3.Init(src3D - right * 35, dst3D - right * 35);

    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);

    left_two = (tr.endpos - tr.startpos).Length();



    if (right_two > left_two) {

        *side = -1;

        //Body should be right

    }

    else if (left_two > right_two) {

        *side = 1;

    }

    else

        *side = 0;

}



bool CResolver::DoesHaveJitter(IBasePlayer* player, int* new_side) {

    static float LastAngle[64];

    static int LastBrute[64];

    static bool Switch[64];

    static float LastUpdateTime[64];



    int i = player->GetIndex();



    float CurrentAngle = player->GetEyeAngles().y;

    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 50.f)) {

        Switch[i] = !Switch[i];

        LastAngle[i] = CurrentAngle;

        *new_side = Switch[i] ? 1 : -1;

        LastBrute[i] = *new_side;

        LastUpdateTime[i] = interfaces.global_vars->curtime;

        return true;

    }

    else {

        if (fabsf(LastUpdateTime[i] - interfaces.global_vars->curtime >= TICKS_TO_TIME(17))

            || player->GetSimulationTime() != player->GetOldSimulationTime()) {

            LastAngle[i] = CurrentAngle;

        }

        *new_side = LastBrute[i];

    }

    return false;

}





void CResolver::StoreAntifreestand()

{

    if (!csgo->local->isAlive())

        return;



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

        return;





    for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)

    {

        auto player = interfaces.ent_list->GetClientEntity(i);



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

            continue;



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

        auto idx = player->GetIndex();

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

        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);

        Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };

        Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };



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

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



        Vector Origin = player->GetOrigin();



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



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



        for (int side = 0; side < 2; side++)

        {

            Vector OriginAutowall = { Origin.x + OriginLeftRight[side].x,  Origin.y - OriginLeftRight[side].y , Origin.z + 90 };

            Vector ViewPointAutowall = { ViewPoint.x + OriginLeftRightLocal[side].x,  ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };



            if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))

            {

                if (side == 0)

                {

                    HitSide1 = true;

                    FreestandSide[idx] = -1;

                }

                else if (side == 1)

                {

                    HitSide2 = true;

                    FreestandSide[idx] = 1;

                }



                Autowalled = true;

            }

            else

            {

                for (int sidealternative = 0; sidealternative < 2; sidealternative++)

                {

                    Vector ViewPointAutowallalternative = { Origin.x + OriginLeftRight[sidealternative].x,  Origin.y - OriginLeftRight[sidealternative].y , Origin.z + 90 };



                    if (g_AutoWall.CanHitFloatingPoint(ViewPointAutowallalternative, ViewPointAutowall))

                    {

                        if (sidealternative == 0)

                        {

                            HitSide1 = true;

                            FreestandSide[idx] = -1;

                            //FreestandAngle[pPlayerEntity->EntIndex()] = 90;

                        }

                        else if (sidealternative == 1)

                        {

                            HitSide2 = true;

                            FreestandSide[idx] = 1;

                            //FreestandAngle[pPlayerEntity->EntIndex()] = -90;

                        }



                        Autowalled = true;

                    }

                }

            }

        }

    }

}





void CResolver::Do(IBasePlayer* player) {

    auto animstate = player->GetPlayerAnimState();

    if (!animstate)

        return;

    animstate->m_flGoalFeetYaw = GetAngle(player);

    if (!vars.ragebot.resolver)

        return;

    if (!csgo->local->isAlive())

        return;

    if (player->GetChokedPackets() <= 0)

        return;



    int idx = player->GetIndex();



    if (player->GetPlayerInfo().fakeplayer)

        return;



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

        return;



    float angle = GetAngle(player);

    //int new_side = 0;

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

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

    // case 0:

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

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

    // break;

    // case 1:

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

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

    // break;

    // }

    //}

    //else

    {

        bool forward = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) > 13.f;

        bool lowdelta = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) < 13.f;

        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(animstate->m_flGoalFeetYaw);

        if (csgo->missedshots[idx] == 0) {

            ResolverMode[idx] = "卐FreestandSide卐";



            if (forward) {

                FreestandSide[idx] *= -1;

                ResolverMode[idx] += " [卐-1卐]";

            }

            else

                ResolverMode[idx] += "卐weave huesos卐";

            animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f * FreestandSide[idx]);

        }

        else {

            if (forward) {

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

                case 1:

                    ResolverMode[idx] = "DefaultDeltaRight[90]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                case 0:

                    ResolverMode[idx] = "DefaultDeltaLeft[90]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                case 3:

                    ResolverMode[idx] = "LowDeltaRight[47]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                case 2:

                    ResolverMode[idx] = "LowDeltaLeft[47]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                }

            }

            else {

                if (lowdelta) {

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

                    case 1:

                        ResolverMode[idx] = "LowDeltaLeft[13]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    case 0:

                        ResolverMode[idx] = "LowDeltaRight[13]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    case 3:

                        ResolverMode[idx] = "LowDeltaLeft[29]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    case 2:

                        ResolverMode[idx] = "LowDeltaRight[29]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    }

                }

            }

        }

    }

}
 
AnimeIIIHuK777
A
Начинающий
Статус
Оффлайн
Регистрация
18 Апр 2019
Сообщения
64
Реакции[?]
1
Поинты[?]
0
Удалить тему легче тебе с таким ресольвером ты будешь до завтра брутить хахаахаха
 
TwitchDash
я
TwitchDash
Начинающий
Статус
Оффлайн
Регистрация
21 Янв 2019
Сообщения
154
Реакции[?]
21
Поинты[?]
4K
Удали вот это
#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::NormalizeYaw(player->GetEyeAngles().y);

}



float CResolver::GetForwardYaw(IBasePlayer* player) {

return Math::NormalizeYaw(GetBackwardYaw(player) - 180.f);

}



float CResolver::GetBackwardYaw(IBasePlayer* player) {

return Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;

}



float CResolver::GetLeftYaw(IBasePlayer* player) {

return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 90.f);

}



float CResolver::GetRightYaw(IBasePlayer* player) {

return Math::NormalizeYaw(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::NormalizeYaw(yaw + 90.f))

>= fabsf(GetAngle(player) - Math::NormalizeYaw(yaw - 90.f));

}

bool CResolver::TargetSide(IBasePlayer* player) {

float yaw = Math::NormalizeYaw(GetBackwardYaw(player));

float angle = GetAngle(player);

return fabsf(angle - Math::NormalizeYaw(yaw + 90.f))

>= fabsf(angle - Math::NormalizeYaw(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;

CTraceFilter filter;



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



filter.pSkip = player;

src3D = player->GetEyePosition();

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



ray.Init(src3D, dst3D);

interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);

back_two = (tr.endpos - tr.startpos).Length();



ray2.Init(src3D + right * 35, dst3D + right * 35);

interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);

right_two = (tr.endpos - tr.startpos).Length();



ray3.Init(src3D - right * 35, dst3D - right * 35);

interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);

left_two = (tr.endpos - tr.startpos).Length();



if (right_two > left_two) {

*side = -1;

//Body should be right

}

else if (left_two > right_two) {

*side = 1;

}

else

*side = 0;

}



bool CResolver::DoesHaveJitter(IBasePlayer* player, int* new_side) {

static float LastAngle[64];

static int LastBrute[64];

static bool Switch[64];

static float LastUpdateTime[64];



int i = player->GetIndex();



float CurrentAngle = player->GetEyeAngles().y;

if (!Math::IsNearEqual(CurrentAngle, LastAngle, 50.f)) {

Switch = !Switch;

LastAngle = CurrentAngle;

*new_side = Switch ? 1 : -1;

LastBrute = *new_side;

LastUpdateTime = interfaces.global_vars->curtime;

return true;

}

else {

if (fabsf(LastUpdateTime - interfaces.global_vars->curtime >= TICKS_TO_TIME(17))

|| player->GetSimulationTime() != player->GetOldSimulationTime()) {

LastAngle = CurrentAngle;

}

*new_side = LastBrute;

}

return false;

}





void CResolver::StoreAntifreestand()

{

if (!csgo->local->isAlive())

return;



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

return;





for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)

{

auto player = interfaces.ent_list->GetClientEntity(i);



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

continue;



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

auto idx = player->GetIndex();

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

Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);

Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };

Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };



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

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



Vector Origin = player->GetOrigin();



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



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



for (int side = 0; side < 2; side++)

{

Vector OriginAutowall = { Origin.x + OriginLeftRight[side].x, Origin.y - OriginLeftRight[side].y , Origin.z + 90 };

Vector ViewPointAutowall = { ViewPoint.x + OriginLeftRightLocal[side].x, ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };



if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))

{

if (side == 0)

{

HitSide1 = true;

FreestandSide[idx] = -1;

}

else if (side == 1)

{

HitSide2 = true;

FreestandSide[idx] = 1;

}



Autowalled = true;

}

else

{

for (int sidealternative = 0; sidealternative < 2; sidealternative++)

{

Vector ViewPointAutowallalternative = { Origin.x + OriginLeftRight[sidealternative].x, Origin.y - OriginLeftRight[sidealternative].y , Origin.z + 90 };



if (g_AutoWall.CanHitFloatingPoint(ViewPointAutowallalternative, ViewPointAutowall))

{

if (sidealternative == 0)

{

HitSide1 = true;

FreestandSide[idx] = -1;

//FreestandAngle[pPlayerEntity->EntIndex()] = 90;

}

else if (sidealternative == 1)

{

HitSide2 = true;

FreestandSide[idx] = 1;

//FreestandAngle[pPlayerEntity->EntIndex()] = -90;

}



Autowalled = true;

}

}

}

}

}

}





void CResolver::Do(IBasePlayer* player) {

auto animstate = player->GetPlayerAnimState();

if (!animstate)

return;

animstate->m_flGoalFeetYaw = GetAngle(player);

if (!vars.ragebot.resolver)

return;

if (!csgo->local->isAlive())

return;

if (player->GetChokedPackets() <= 0)

return;



int idx = player->GetIndex();



if (player->GetPlayerInfo().fakeplayer)

return;



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

return;



float angle = GetAngle(player);

//int new_side = 0;

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

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

// case 0:

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

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

// break;

// case 1:

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

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

// break;

// }

//}

//else

{

bool forward = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) > 13.f;

bool lowdelta = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) < 13.f;

animstate->m_flGoalFeetYaw = Math::NormalizeYaw(animstate->m_flGoalFeetYaw);

if (csgo->missedshots[idx] == 0) {

ResolverMode[idx] = "卐FreestandSide卐";



if (forward) {

FreestandSide[idx] *= -1;

ResolverMode[idx] += " [卐-1卐]";

}

else

ResolverMode[idx] += "卐weave huesos卐";

animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f * FreestandSide[idx]);

}

else {

if (forward) {

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

case 1:

ResolverMode[idx] = "DefaultDeltaRight[90]";

if (FreestandSide[idx] == 1)

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

else

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

break;

case 0:

ResolverMode[idx] = "DefaultDeltaLeft[90]";

if (FreestandSide[idx] == 1)

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

else

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

break;

case 3:

ResolverMode[idx] = "LowDeltaRight[47]";

if (FreestandSide[idx] == 1)

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

else

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

break;

case 2:

ResolverMode[idx] = "LowDeltaLeft[47]";

if (FreestandSide[idx] == 1)

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

else

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

break;

}

}

else {

if (lowdelta) {

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

case 1:

ResolverMode[idx] = "LowDeltaLeft[13]";

if (FreestandSide[idx] == 1)

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

else

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

break;

case 0:

ResolverMode[idx] = "LowDeltaRight[13]";

if (FreestandSide[idx] == 1)

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

else

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

break;

case 3:

ResolverMode[idx] = "LowDeltaLeft[29]";

if (FreestandSide[idx] == 1)

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

else

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

break;

case 2:

ResolverMode[idx] = "LowDeltaRight[29]";

if (FreestandSide[idx] == 1)

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

else

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

break;

}

}

}

}

}

}

 
Pexi1337
who are you dot idk
Pexi1337
Пользователь
Статус
Оффлайн
Регистрация
24 Ноя 2019
Сообщения
390
Реакции[?]
119
Поинты[?]
0
Tifok
Tifok
Пользователь
Статус
Оффлайн
Регистрация
10 Ноя 2019
Сообщения
839
Реакции[?]
135
Поинты[?]
0
Pexi1337 написал(а):
Он не про брут вроде сказал...
Нажмите для раскрытия...
Ну если ты глупый шифтер 17 тиков, то открою тебе тайну, можешь открыть ресольвер и понять почему он миссает 1 пулю и вообще он и будет миссать из-за брутфорса
 
Pexi1337
who are you dot idk
Pexi1337
Пользователь
Статус
Оффлайн
Регистрация
24 Ноя 2019
Сообщения
390
Реакции[?]
119
Поинты[?]
0
2lvlcsg007 написал(а):
Ну если ты глупый шифтер 17 тиков, то открою тебе тайну, можешь открыть ресольвер и понять почему он миссает 1 пулю и вообще он и будет миссать из-за брутфорса
Нажмите для раскрытия...
При чем брут ? Миссает первую пулю не из-за брута... И с каких пор нельзя шифтить 17 тиков? В ските шифтится 17, в вт луахах 16 стоит
 
Tifok
Tifok
Пользователь
Статус
Оффлайн
Регистрация
10 Ноя 2019
Сообщения
839
Реакции[?]
135
Поинты[?]
0
Pexi1337 написал(а):
При чем брут ? Миссает первую пулю не из-за брута... И с каких пор нельзя шифтить 17 тиков? В ските шифтится 17, в вт луахах 16 стоит
Нажмите для раскрытия...
Миссает 1 пулю не из-за брута, хмм ну да не тот сайд 1 пулей, а потом 2 пулей детект не? Или дабл тап без наворочек и он миссает
 
smile_lnk1104
Flowseal = SAAC :)
smile_lnk1104
Забаненный
Статус
Оффлайн
Регистрация
19 Янв 2020
Сообщения
290
Реакции[?]
32
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
qodex
рукожоп
Q
Пользователь
Статус
Оффлайн
Регистрация
8 Авг 2019
Сообщения
347
Реакции[?]
37
Поинты[?]
0
St1lyka написал(а):
Короче проблема в том , что вейви миссает всегда первую пулю . Играть с дт вообще невозможно.

Flowseal ты вроде wayvee пастишь, хелпани пожалуйста
И не нужно писать read learncpp.com или давать мне что-то подобное, я заебался уже что-то пытаться сделать. Где и как именно нужно посиксить ресольвер?

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::NormalizeYaw(player->GetEyeAngles().y);

}



float CResolver::GetForwardYaw(IBasePlayer* player) {

    return Math::NormalizeYaw(GetBackwardYaw(player) - 180.f);

}



float CResolver::GetBackwardYaw(IBasePlayer* player) {

    return Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;

}



float CResolver::GetLeftYaw(IBasePlayer* player) {

    return Math::NormalizeYaw(Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y - 90.f);

}



float CResolver::GetRightYaw(IBasePlayer* player) {

    return Math::NormalizeYaw(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::NormalizeYaw(yaw + 90.f))

        >= fabsf(GetAngle(player) - Math::NormalizeYaw(yaw - 90.f));

}

bool CResolver::TargetSide(IBasePlayer* player) {

    float yaw = Math::NormalizeYaw(GetBackwardYaw(player));

    float angle = GetAngle(player);

    return fabsf(angle - Math::NormalizeYaw(yaw + 90.f))

        >= fabsf(angle - Math::NormalizeYaw(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;

    CTraceFilter filter;



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



    filter.pSkip = player;

    src3D = player->GetEyePosition();

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



    ray.Init(src3D, dst3D);

    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);

    back_two = (tr.endpos - tr.startpos).Length();



    ray2.Init(src3D + right * 35, dst3D + right * 35);

    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);

    right_two = (tr.endpos - tr.startpos).Length();



    ray3.Init(src3D - right * 35, dst3D - right * 35);

    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);

    left_two = (tr.endpos - tr.startpos).Length();



    if (right_two > left_two) {

        *side = -1;

        //Body should be right

    }

    else if (left_two > right_two) {

        *side = 1;

    }

    else

        *side = 0;

}



bool CResolver::DoesHaveJitter(IBasePlayer* player, int* new_side) {

    static float LastAngle[64];

    static int LastBrute[64];

    static bool Switch[64];

    static float LastUpdateTime[64];



    int i = player->GetIndex();



    float CurrentAngle = player->GetEyeAngles().y;

    if (!Math::IsNearEqual(CurrentAngle, LastAngle[i], 50.f)) {

        Switch[i] = !Switch[i];

        LastAngle[i] = CurrentAngle;

        *new_side = Switch[i] ? 1 : -1;

        LastBrute[i] = *new_side;

        LastUpdateTime[i] = interfaces.global_vars->curtime;

        return true;

    }

    else {

        if (fabsf(LastUpdateTime[i] - interfaces.global_vars->curtime >= TICKS_TO_TIME(17))

            || player->GetSimulationTime() != player->GetOldSimulationTime()) {

            LastAngle[i] = CurrentAngle;

        }

        *new_side = LastBrute[i];

    }

    return false;

}





void CResolver::StoreAntifreestand()

{

    if (!csgo->local->isAlive())

        return;



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

        return;





    for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)

    {

        auto player = interfaces.ent_list->GetClientEntity(i);



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

            continue;



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

        auto idx = player->GetIndex();

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

        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);

        Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };

        Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };



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

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



        Vector Origin = player->GetOrigin();



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



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



        for (int side = 0; side < 2; side++)

        {

            Vector OriginAutowall = { Origin.x + OriginLeftRight[side].x,  Origin.y - OriginLeftRight[side].y , Origin.z + 90 };

            Vector ViewPointAutowall = { ViewPoint.x + OriginLeftRightLocal[side].x,  ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };



            if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))

            {

                if (side == 0)

                {

                    HitSide1 = true;

                    FreestandSide[idx] = -1;

                }

                else if (side == 1)

                {

                    HitSide2 = true;

                    FreestandSide[idx] = 1;

                }



                Autowalled = true;

            }

            else

            {

                for (int sidealternative = 0; sidealternative < 2; sidealternative++)

                {

                    Vector ViewPointAutowallalternative = { Origin.x + OriginLeftRight[sidealternative].x,  Origin.y - OriginLeftRight[sidealternative].y , Origin.z + 90 };



                    if (g_AutoWall.CanHitFloatingPoint(ViewPointAutowallalternative, ViewPointAutowall))

                    {

                        if (sidealternative == 0)

                        {

                            HitSide1 = true;

                            FreestandSide[idx] = -1;

                            //FreestandAngle[pPlayerEntity->EntIndex()] = 90;

                        }

                        else if (sidealternative == 1)

                        {

                            HitSide2 = true;

                            FreestandSide[idx] = 1;

                            //FreestandAngle[pPlayerEntity->EntIndex()] = -90;

                        }



                        Autowalled = true;

                    }

                }

            }

        }

    }

}





void CResolver::Do(IBasePlayer* player) {

    auto animstate = player->GetPlayerAnimState();

    if (!animstate)

        return;

    animstate->m_flGoalFeetYaw = GetAngle(player);

    if (!vars.ragebot.resolver)

        return;

    if (!csgo->local->isAlive())

        return;

    if (player->GetChokedPackets() <= 0)

        return;



    int idx = player->GetIndex();



    if (player->GetPlayerInfo().fakeplayer)

        return;



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

        return;



    float angle = GetAngle(player);

    //int new_side = 0;

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

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

    // case 0:

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

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

    // break;

    // case 1:

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

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

    // break;

    // }

    //}

    //else

    {

        bool forward = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) > 13.f;

        bool lowdelta = fabsf(Math::NormalizeYaw(GetAngle(player) - GetForwardYaw(player))) < 13.f;

        animstate->m_flGoalFeetYaw = Math::NormalizeYaw(animstate->m_flGoalFeetYaw);

        if (csgo->missedshots[idx] == 0) {

            ResolverMode[idx] = "卐FreestandSide卐";



            if (forward) {

                FreestandSide[idx] *= -1;

                ResolverMode[idx] += " [卐-1卐]";

            }

            else

                ResolverMode[idx] += "卐weave huesos卐";

            animstate->m_flGoalFeetYaw = Math::NormalizeYaw(angle - 90.f * FreestandSide[idx]);

        }

        else {

            if (forward) {

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

                case 1:

                    ResolverMode[idx] = "DefaultDeltaRight[90]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                case 0:

                    ResolverMode[idx] = "DefaultDeltaLeft[90]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                case 3:

                    ResolverMode[idx] = "LowDeltaRight[47]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                case 2:

                    ResolverMode[idx] = "LowDeltaLeft[47]";

                    if (FreestandSide[idx] == 1)

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

                    else

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

                    break;

                }

            }

            else {

                if (lowdelta) {

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

                    case 1:

                        ResolverMode[idx] = "LowDeltaLeft[13]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    case 0:

                        ResolverMode[idx] = "LowDeltaRight[13]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    case 3:

                        ResolverMode[idx] = "LowDeltaLeft[29]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    case 2:

                        ResolverMode[idx] = "LowDeltaRight[29]";

                        if (FreestandSide[idx] == 1)

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

                        else

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

                        break;

                    }

                }

            }

        }

    }

}
Нажмите для раскрытия...
ну я думаю тебе норм брутить дельту 90.f 0_o
 
Войдите или зарегистрируйтесь для ответа.
Похожие темы
utkukck11
Вопрос Fakelag and aa doesnt work (weave v2 base)
Ответы
2
Просмотры
656
utkukck11
utkukck11
I
Гайд Most things that you need to know when making or pasting a csgo cheat
Ответы
8
Просмотры
3K
jamharvey
J
Немного о главном
Полезные мелочи
О нас

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

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