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

How do I improove this weave.su resolver?

  • Автор темы Автор темы deok
  • Дата начала Дата начала
deok
Забаненный
D
Забаненный
Статус
Оффлайн
Регистрация
20 Мар 2020
Сообщения
116
Реакции
33
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Hi, i downloaded this weave source, that was posted yesterday, and I wanted to improve the resolver, but im not so good in doing so with weave, so pls help. Here's the resovler.

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


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

float CResolver::GetAngle(IBasePlayer* player) {
    return Math::NormalizeYaw(player->GetEyeAngles().y); // 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, ray4, ray5;
    CTraceFilter filter;

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

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

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

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

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

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

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

    int i = player->GetIndex();

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


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

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


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

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

        bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        auto idx = player->GetIndex();
        float angToLocal = Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;
        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);
        Vector2D Side1 = { (45 * sin(DEG2RAD(angToLocal))),(45 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side2 = { (45 * sin(DEG2RAD(angToLocal + 180))) ,(45 * cos(DEG2RAD(angToLocal + 180))) };

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

        Vector Origin = player->GetOrigin();

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

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

        float niggaangle = GetAngle(player);

        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 (niggaangle >= 45.f) // niggaangle >= 45.f || niggaangle <= -45.f
                {
                    if (side == 0)
                    {
                        HitSide1 = true;
                        FreestandSide[idx] = 1; // -1
                    }
                    else if (side == 1)
                    {
                        HitSide2 = true;
                        FreestandSide[idx] = -1; // 1
                    }
                }
                else {
                    if (side == 0)
                    {
                        HitSide1 = true;
                        FreestandSide[idx] = -1; // -1
                    }
                    else if (side == 1)
                    {
                        HitSide2 = true;
                        FreestandSide[idx] = 1; // 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 (niggaangle >= 45.f)
                        {
                            if (sidealternative == 0)
                            {
                                HitSide1 = true;
                                FreestandSide[idx] = 1;
                            }
                            else if (sidealternative == 1)
                            {
                                HitSide2 = true;
                                FreestandSide[idx] = -1;

                            }
                        }
                        else {
                            if (sidealternative == 0)
                            {
                                HitSide1 = true;
                                FreestandSide[idx] = -1;
                            }
                            else if (sidealternative == 1)
                            {
                                HitSide2 = true;
                                FreestandSide[idx] = 1;

                            }
                        }

                        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 dumbynigga = GetAngle(player);
        int* dumbnigga = &dumbynigga;

        DoesHaveJitter(player, dumbnigga);

        if (angle >= 45.f) { // angle >= 45.f
            switch (csgo->missedshots[player->GetIndex()] % 3) {
            case 0:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = 90.f;
                    if (feet_yaw <= 90)
                    {
                        if (-90 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = 90.f; resol_delta < -90.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                        {
                            for (int resol_delta = 90.f; resol_delta < -90.f; resol_delta = resol_delta - 60.f)
                            {
                                player->GetEyeAngles().y == resol_delta;
                            }
                        }
                    }
                }
                break;
            case 1:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = 19.f;
                    if (feet_yaw <= 19)
                    {
                        if (-19 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = 19.f; resol_delta < -19.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = 19.f; resol_delta < -19.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }
                break;
            case 2:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = 119.f;
                    if (feet_yaw <= 119)
                    {
                        if (-119 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = 119.f; resol_delta < -119.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = 119.f; resol_delta < -119.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }

            case 3:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = 119.f;
                    if (feet_yaw <= 119)
                    {
                        if (-119 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = 57.f; resol_delta < -57.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = 57.f; resol_delta < -57.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }
                break;
            default:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = 90.f;
                    if (feet_yaw <= 90)
                    {
                        if (-90 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = 90.f; resol_delta < -90.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = 90.f; resol_delta < -90.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }
                break;
            }
        }
        else {
            switch (csgo->missedshots[player->GetIndex()] % 3) {
            case 0:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = -90.f;
                    if (feet_yaw <= -90)
                    {
                        if (90 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = -90.f; resol_delta < 90.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = -90.f; resol_delta < 90.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }
                break;
            case 1:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = -19.f;
                    if (feet_yaw <= -19)
                    {
                        if (19 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = -19.f; resol_delta < 19.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = -19.f; resol_delta < 19.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }
                break;
            case 2:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = -119.f;
                    if (feet_yaw <= -119)
                    {
                        if (119 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = -119.f; resol_delta < 119.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        {
                            for (int resol_delta = -119.f; resol_delta < 119.f; resol_delta = resol_delta - 60.f)
                            {
                                player->GetEyeAngles().y == resol_delta;
                            }
                        }
                    }
                    break;
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = -90.f;
                    if (feet_yaw <= -90)
                    {
                        if (90 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = -90.f; resol_delta < 90.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        for (int resol_delta = -90.f; resol_delta < 90.f; resol_delta = resol_delta - 60.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                    }
                }
                }
            case 3:
                for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                {
                    auto player = csgo->local;
                    if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                        continue;
                    auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                    auto body_max_rotation = -119.f;
                    if (feet_yaw <= -119)
                    {
                        if (119 > feet_yaw)
                            player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                    }
                    else
                    {
                        player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                    }
                    if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                    {
                        for (int resol_delta = -57.f; resol_delta < 57.f; resol_delta = resol_delta - 20.f)
                        {
                            player->GetEyeAngles().y == resol_delta;
                        }
                        {
                            for (int resol_delta = -57.f; resol_delta < 57.f; resol_delta = resol_delta - 60.f)
                            {
                                player->GetEyeAngles().y == resol_delta;
                            }
                        }
                    }
                    break;
                    for (int i = 1; i <= interfaces.global_vars->maxClients; i++)
                    {
                        auto player = csgo->local;
                        if (!player || !player->isAlive() || player->IsDormant() || player == csgo->local)
                            continue;
                        auto feet_yaw = player->GetAnimOverlay(3)->m_flCycle > 0.9f && player->GetAnimOverlay(3)->m_flWeight > 0.9f && player->GetVelocity().Length2D() < 0.1f;
                        auto body_max_rotation = -90.f;
                        if (feet_yaw <= -90)
                        {
                            if (90 > feet_yaw)
                                player->GetEyeAngles().y == body_max_rotation + player->GetEyeAngles().y;
                        }
                        else
                        {
                            player->GetEyeAngles().y == body_max_rotation - player->GetEyeAngles().y;
                        }
                        if (player->GetAnimOverlay(3)->m_flCycle > 0.9)
                        {
                            for (int resol_delta = -57.f; resol_delta < 57.f; resol_delta = resol_delta - 20.f)
                            {
                                player->GetEyeAngles().y == resol_delta;
                            }
                            for (int resol_delta = -57.f; resol_delta < 57.f; resol_delta = resol_delta - 60.f)
                            {
                                player->GetEyeAngles().y == resol_delta;
                            }
                        }
                    }
                }

                break;
            }
        }

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

Resolver.h
C++:
Expand Collapse Copy 
#pragma once
struct animation;
class CResolver
{
private:
    float GetLeftYaw(IBasePlayer*);
    float GetRightYaw(IBasePlayer*);
    bool TargetSide(IBasePlayer*);
    void DetectSide(IBasePlayer*, int*);
    bool TargetJitter(IBasePlayer*, bool);
    bool DoesHaveJitter(IBasePlayer*, int*);
    int FreestandSide[64];
public:
    float GetAngle(IBasePlayer*);
    float GetForwardYaw(IBasePlayer*);
    float GetBackwardYaw(IBasePlayer*);
    void Do(IBasePlayer*);
    void StoreAntifreestand();
};
extern CResolver* resolver;
extern std::string ResolverMode[65];
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
cut and return the old one :CoolStoryBob:
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.

Похожие темы

K
Вопрос How to make resolver better?
Ответы
4
Просмотры
868
kralondon11
K
mercury997
Исходник Nemesis Resolver // supremacy c+p ready
Ответы
1
Просмотры
810
veinedhvhs
veinedhvhs
K
Вопрос Can anyone help me with code so i can hit defensive and break lc
Ответы
4
Просмотры
456
x64penguin
X
mercury997
Исходник Supremacy Rebuilt Animations // supremacy c+p ready
Ответы
5
Просмотры
873
FunTimesWithZustin
F
K
Вопрос How to make prediction better?
Ответы
5
Просмотры
739
spidergng
spidergng
Немного о главном
Полезные мелочи
О нас

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

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