Что нового?



  • Ищем качественного (не новичок) разработчиков Xenforo для этого форума! В идеале, чтобы ты был фулл стек программистом. Если у тебя есть что показать, то свяжись с нами по контактным данным: https://t.me/DREDD

Вопрос Чит отбрасывает камеру при стрельбе [cs:go]

Yesgoter
Пользователь
Yesgoter
Пользователь
Статус
Оффлайн
Регистрация
5 Июл 2022
Сообщения
1,001
Реакции
86
Добрый вечер! Случилась такая проблема. У меня отбрасывает камеру при стрельбе в кс го. Подскажите пожалуйста, как это исправить. Видео с проблемой:
Пожалуйста, авторизуйтесь для просмотра ссылки.
м ПРОСЬБА МОДЕРАМ, НЕ СНОСИТЬ ДАННУЮ ТЕМУ!!!!!!!!!!!!!!!!!!
код:
Код:
Expand Collapse Copy 
#include "aimbot.hpp"
#include "../helpers/math.hpp"
#include "../menu.hpp"
#include "../helpers/input.hpp"
#include "autowall.hpp"

#include <chrono>
std::map<const char*, HMODULE> modules;


HMODULE GetModule(const char* name)
{
    if (!modules.count(name) || !modules[name])
        modules[name] = GetModuleHandleA(name);

    return modules[name];
}

std::uint8_t* PatternScan2(const char* module_name, const char* signature)
{
    auto module = GetModule(module_name);

    static auto pattern_to_byte = [](const char* pattern) {
        auto bytes = std::vector<int>{};
        auto start = const_cast<char*>(pattern);
        auto end = const_cast<char*>(pattern) + strlen(pattern);

        for (auto current = start; current < end; ++current) {
            if (*current == '?') {
                ++current;
                if (*current == '?')
                    ++current;
                bytes.push_back(-1);
            }
            else {
                bytes.push_back(strtoul(current, &current, 16));
            }
        }
        return bytes;
    };

    auto dosHeader = (PIMAGE_DOS_HEADER)module;
    auto ntHeaders = (PIMAGE_NT_HEADERS)((std::uint8_t*)module + dosHeader->e_lfanew);

    auto sizeOfImage = ntHeaders->OptionalHeader.SizeOfImage;
    auto patternBytes = pattern_to_byte(signature);
    auto scanBytes = reinterpret_cast<std::uint8_t*>(module);

    auto s = patternBytes.size();
    auto d = patternBytes.data();

    for (auto i = 0ul; i < sizeOfImage - s; ++i) {
        bool found = true;
        for (auto j = 0ul; j < s; ++j) {
            if (scanBytes[i + j] != d[j] && d[j] != -1) {
                found = false;
                break;
            }
        }
        if (found) {
            return &scanBytes[i];
        }
    }
    return nullptr;
}

float CLegitbot::GetFovToPlayer(QAngle viewAngle, QAngle aimAngle)
{
    QAngle delta = aimAngle - viewAngle;
    Math::FixAngles(delta);
    return sqrtf(powf(delta.x, 2.0f) + powf(delta.y, 2.0f)); /// (powf(delta.x, 2.0f) + powf(delta.y, 2.0f));
}

bool CLegitbot::IsLineGoesThroughSmoke(Vector startPos, Vector endPos)
{
    static auto LineGoesThroughSmokeFn = (bool(*)(Vector, Vector))PatternScan2("client.dll", "55 8B EC 83 EC 08 8B 15 ? ? ? ? 0F 57 C0");
    return LineGoesThroughSmokeFn(startPos, endPos);
}

bool CLegitbot::IsRcs()
{
    if (!g_LocalPlayer) return false;
    return g_LocalPlayer->m_iShotsFired() >= settings.rcs.start + 1;
}

bool CLegitbot::IsEnabled(CUserCmd* cmd)
{
    if (!g_EngineClient->IsInGame() || !g_LocalPlayer)
        return false;

    if (!g_LocalPlayer->IsAlive())
        return false;

    auto weapon = g_LocalPlayer->m_hActiveWeapon();
    if (!weapon || !weapon->IsGun())
        return false;

    settings = g_Options.aim_settings[weapon->m_iItemDefinitionIndex()].legit;

    if (!settings.enabled)
        return false;

    //if (!settings.enabled || !(cmd->buttons & IN_ATTACK)) {
        //return false;

    if (!weapon->HasBullets())
        return false;

    return (cmd->buttons & IN_ATTACK);

    return (cmd->buttons & IN_ATTACK) || (settings.autofire.enabled && GetAsyncKeyState(settings.autofire.hotkey));
}

void CLegitbot::Smooth(QAngle currentAngle, QAngle aimAngle, QAngle& angle)
{
    auto smooth_value = max(1.0f, settings.smooth);

    Vector current, aim;

    Math::AngleVectors(currentAngle, current);
    Math::AngleVectors(aimAngle, aim);

    const Vector delta = aim - current;
    const Vector smoothed = current + delta / smooth_value;

    Math::VectorAngles(smoothed, angle);
}

void CLegitbot::RCS(QAngle& angle, C_BasePlayer* target, CUserCmd* cmd)
{
    if (!settings.rcs.enabled || shotsFired < settings.rcs.start - 30)
        return;

    if (!settings.rcs.x && !settings.rcs.y)
        return;

    auto x = settings.rcs.x;
    auto y = settings.rcs.y;

    static auto weapon_recoil_scale = g_CVar->FindVar("weapon_recoil_scale");
    float scale = weapon_recoil_scale->GetFloat();

    if (scale != 2.f)
    {
        x = scale * x / 2.f;
        y = scale * y / 2.f;
    }

    x = scale *= 1.26f;
    y = scale;

    if (x <= 0 && y <= 0)
        return;

    QAngle punch = { };

    if (target)
        punch = { current_punch.x * x,  current_punch.y * y, 0 };
    else if (settings.rcs.type == 0)
        punch = { (current_punch.x - last_punch.x) * x, (current_punch.y - last_punch.y) * y, 0 };

    if ((punch.x != 0.f || punch.y != 0.f) && g_LocalPlayer->m_aimPunchAngle().z == 0.f)
    {
        angle -= punch;
        angle.Normalized();
    }

    last_corrected = punch;
}

/*void CLegitbot::RCS(QAngle& angle, C_BasePlayer* target)
{
    if (!settings.rcs.enabled || !IsRcs()) {
        return;
    }
    if (settings.rcs.x == 0 && settings.rcs.y == 0) {
        return;
    }
    if (target) {
        QAngle punch = g_LocalPlayer->m_aimPunchAngle();
        angle.x -= punch.x * (settings.rcs.x / 50.f);
        angle.y -= punch.y * (settings.rcs.y / 50.f);
    }
    else if (settings.rcs.type == 0) {
        QAngle NewPunch = { current_punch.x - last_punch.x, current_punch.y - last_punch.y, 0 };
        angle.x -= NewPunch.x * (settings.rcs.x / 50.f);
        angle.y -= NewPunch.y* (settings.rcs.y / 50.f);
    }
    Math::FixAngles(angle);
}*/

/*void CLegitbot::RCS(QAngle& angle, C_BasePlayer* target)
{
    if (!g_LocalPlayer)
        return;
    if (!settings.rcs.enabled || !IsRcs()) {
        return;
    }
    if (settings.rcs.x == 0 && settings.rcs.y == 0) {
        return;
    }
    if (target) {
        QAngle punch = g_LocalPlayer->m_aimPunchAngle();
        float x = settings.rcs.x * 0.02f;
        float y = settings.rcs.y * 0.02f;

        angle.x -= punch.x * x;
        angle.y -= punch.y * y;
    }
    Math::Normalize3(angle);
    Math::ClampAngles(angle);
}*/

bool CLegitbot::IsSilent()
{
    if (settings.silent2 == 2)
        return !(shotsFired > 0 || !settings.silent2 || !settings.silent_fov);
    if (settings.silent2 == 1)
        return !(!settings.silent2 || !settings.silent_fov);
    if (settings.silent2 == 0)
        return !(shotsFired > 0 || !settings.silent2 || !settings.silent_fov);
}

float CLegitbot::GetFov()
{
    if (IsSilent())
        return settings.silent_fov;

    return settings.fov;
}

bool CLegitbot::autoweapon() {
    if (!g_LocalPlayer->m_hActiveWeapon())
        return false;
    if (!g_LocalPlayer->IsNotTarget())
        return false;
    if (g_LocalPlayer->m_hActiveWeapon()->IsGrenade())
        return false;
    if (g_LocalPlayer->m_hActiveWeapon()->IsKnife())
        return false;
    if (g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_TASER ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_FISTS ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_BREACHCHARGE ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_TABLET ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_MELEE ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_AXE ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_HAMMER ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_KNIFE_GHOST ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_FIREBOMB ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_DIVERSION ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_FRAG_GRENADE ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_C4 ||
        g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex() == WEAPON_HEALTHSHOT
        )
        return false;

    Weapon::current_weapon = g_LocalPlayer->m_hActiveWeapon()->m_iItemDefinitionIndex();
    return true;
}

C_BasePlayer* CLegitbot::GetClosestPlayer(CUserCmd* cmd, int& bestBone, float& bestFov, QAngle& bestAngles)
{
    if (target && !kill_delay && settings.kill_delay > 0 && !target->IsAlive())
    {
        target = nullptr;
        kill_delay = true;
        kill_delay_time = int(GetTickCount()) + settings.kill_delay;
    }
    if (kill_delay)
    {
        if (kill_delay_time <= int(GetTickCount()))
            kill_delay = false;
        else
            return nullptr;
    }

    target = nullptr;

    std::vector<int> hitboxes;


    if (settings.hitboxes.head) {
        hitboxes.push_back(HITBOX_HEAD);
    }
    /////////////////////////////

    if (settings.hitboxes.neck)

        hitboxes.push_back(HITBOX_NECK);

    if (settings.hitboxes.belly)
        hitboxes.push_back(HITBOX_STOMACH);

    if (settings.hitboxes.chest)
    {
        hitboxes.push_back(HITBOX_CHEST);
        hitboxes.push_back(HITBOX_LOWER_CHEST);
        hitboxes.push_back(HITBOX_UPPER_CHEST);
    }

    /*if (settings.hitboxes.chest)
    {
        hitboxes.emplace_back(HITBOX_UPPER_CHEST);
        hitboxes.emplace_back(HITBOX_CHEST);
        hitboxes.emplace_back(HITBOX_LOWER_CHEST);
    }*/

    if (settings.hitboxes.hands)
    {
        hitboxes.push_back(HITBOX_RIGHT_UPPER_ARM);
        hitboxes.push_back(HITBOX_RIGHT_FOREARM);

        hitboxes.push_back(HITBOX_LEFT_UPPER_ARM);
        hitboxes.push_back(HITBOX_LEFT_FOREARM);

        hitboxes.push_back(HITBOX_RIGHT_HAND);
        hitboxes.push_back(HITBOX_LEFT_HAND);
    }

    /*if (settings.hitboxes.hands)
    {
        hitboxes.emplace_back(HITBOX_LEFT_FOREARM);
        hitboxes.emplace_back(HITBOX_LEFT_HAND);
        hitboxes.emplace_back(HITBOX_LEFT_UPPER_ARM);

        hitboxes.emplace_back(HITBOX_RIGHT_FOREARM);
        hitboxes.emplace_back(HITBOX_RIGHT_HAND);
        hitboxes.emplace_back(HITBOX_RIGHT_UPPER_ARM);
    }*/

    if (settings.hitboxes.legs)
    {
        hitboxes.push_back(HITBOX_LEFT_FOOT);
        hitboxes.push_back(HITBOX_RIGHT_FOOT);

        hitboxes.push_back(HITBOX_LEFT_THIGH);
        hitboxes.push_back(HITBOX_RIGHT_THIGH);

        hitboxes.push_back(HITBOX_LEFT_CALF);
        hitboxes.push_back(HITBOX_RIGHT_CALF);
    }

    /*if (settings.hitboxes.legs)
    {
        hitboxes.emplace_back(HITBOX_LEFT_FOOT);
        hitboxes.emplace_back(HITBOX_LEFT_CALF);
        hitboxes.emplace_back(HITBOX_LEFT_THIGH);

        hitboxes.emplace_back(HITBOX_RIGHT_FOOT);
        hitboxes.emplace_back(HITBOX_LEFT_CALF);
        hitboxes.emplace_back(HITBOX_LEFT_THIGH);
    }*/
    

    const Vector eyePos = g_LocalPlayer->GetEyePos();

    for (auto i = 1; i <= g_GlobalVars->maxClients; i++) //g_GlobalVars->maxClients
    {
        C_BasePlayer* player = C_BasePlayer::GetPlayerByIndex(i);

        if (!player || !player->IsAlive() || !player->IsPlayer() || player->m_bGunGameImmunity())
            continue;

        //if (!player->IsEnemy())
            //continue;

        for (const auto hitbox : hitboxes)
        {
            Vector hitboxPos = player->GetHitboxPos(hitbox);
            QAngle ang;
            Math::VectorAngles(hitboxPos - eyePos, ang);
            const float fov = GetFovToPlayer(cmd->viewangles + last_punch * 2.f, ang);

            if (fov > GetFov())
                continue;

            if (!g_LocalPlayer->CanSeePlayer(player, player->abs_origin()))
                continue;

            if (settings.smoke_check && IsLineGoesThroughSmoke(eyePos, hitboxPos))
                continue;

            if (bestFov > fov)
            {
                bestBone = hitbox;
                bestAngles = ang;
                bestFov = fov;
                target = player;
            }
        }
    }

    return target;
}

void CLegitbot::Run(CUserCmd* cmd)
{
    if (int(GetTickCount()) > lastShotTick + 50)
        shotsFired = 0;

    if (!IsEnabled(cmd))
    {
        last_punch = { 0, 0, 0 };
        shot_delay = false;
        kill_delay = false;
        target = nullptr;
        return;
    }

    auto weapon = g_LocalPlayer->m_hActiveWeapon().Get();
    if (!weapon)
        return;

    auto weapon_data = weapon->GetCSWeaponData();
    if (!weapon_data)
        return;

    if (settings.flash_check && g_LocalPlayer->IsFlashed())
        return;

    auto angles = cmd->viewangles;
    const auto current = angles;

    float fov = FLT_MAX;

    int bestBone = -1;

    if (GetClosestPlayer(cmd, bestBone, fov, angles))
    {
        if ((!settings.silent2 || settings.silent2 == 2) && !shot_delay && settings.shot_delay > 0 && !shotsFired)
        {
            shot_delay = true;
            shot_delay_time = int(GetTickCount()) + settings.shot_delay;
        }

        if (fov <= .5)
            shot_delay = false;

        if (shot_delay && shot_delay_time <= int(GetTickCount()))
            shot_delay = false;

        if (shot_delay)
            cmd->buttons &= ~IN_ATTACK;

        if (settings.autofire.enabled && GetAsyncKeyState(settings.autofire.hotkey))
            cmd->buttons |= IN_ATTACK;
    }

    current_punch = g_LocalPlayer->m_aimPunchAngle();
    {
        if (cmd->buttons & IN_ATTACK)
            RCS(angles, target ,cmd);
    }
    last_punch = current_punch;

    if (!IsSilent() && target)
        Smooth(current, angles, angles);

    Math::FixAngles(angles);
    cmd->viewangles = angles;
    if (!IsSilent())
        g_EngineClient->SetViewAngles(&angles);

    if (g_LocalPlayer->m_hActiveWeapon()->IsPistol() && settings.autopistol)
    {
        const float server_time = g_LocalPlayer->m_nTickBase() * g_GlobalVars->interval_per_tick;
        const float next_shot = g_LocalPlayer->m_hActiveWeapon()->m_flNextPrimaryAttack() - server_time;

        if (next_shot > 0)
            cmd->buttons &= ~IN_ATTACK;
    }

    if (cmd->buttons & IN_ATTACK)
    {
        lastShotTick = GetTickCount();
        shotsFired + 3;
    }
}
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Сносите тему:
Это механика игры как бы
 
Yesgoter написал(а):
бля, дядь, это ркс чуть чуть
Нажмите для раскрытия...
Ну ты проблему нормально опиши, чудик.
Ты кидаешь просто кусок аим файла, не понимая, где у тебя проблема.
ты думаешь, что каждый, кто будет тебе помогать возьмет и впастит твой код для теста?
Я хуй знает, если обычным дебаггером не можешь пользоваться, пользуйся примитивными дебаг средствами - коменти каждую функу и все ее депенды и запускай. Пойми уже наконец в чем проблема, а не в тупую пасти
 
Yesgoter написал(а):
бля, дядь, это ркс чуть чуть
Нажмите для раскрытия...
Дядя помоему тут только ты, РКС и есть вся суть проблемы...

UPD: или же твой убогий аим берет пустой вектор позиции игрока и доводит камеру в нулевые координаты.
 
maksimka3362 написал(а):
Ну ты проблему нормально опиши, чудик.
Ты кидаешь просто кусок аим файла, не понимая, где у тебя проблема.
ты думаешь, что каждый, кто будет тебе помогать возьмет и впастит твой код для теста?
Я хуй знает, если обычным дебаггером не можешь пользоваться, пользуйся примитивными дебаг средствами - коменти каждую функу и все ее депенды и запускай. Пойми уже наконец в чем проблема, а не в тупую пасти
Нажмите для раскрытия...
Вроде понял где проблема, попытаюсь объяснить доступно. Вот смотри, когда игрок видет, кого он может убить, аим не откидует пушку. Но как только перед игроком нет целей, происхходит откид
Abybachup написал(а):
Дядя помоему тут только ты, РКС и есть вся суть проблемы...

UPD: или же твой убогий аим берет пустой вектор позиции игрока и доводит камеру в нулевые координаты.
Нажмите для раскрытия...
Вроде с вектором все нормально, если что то не так, то вот код, может я чего - то не вижу.

C++:
Expand Collapse Copy 
namespace Math
{
    void FixAngles(QAngle& angles)
    {
        Normalize3(angles);
        ClampAngles(angles);
    }
    //--------------------------------------------------------------------------------
    float VectorDistance(const Vector& v1, const Vector& v2)
    {
        return FASTSQRT(pow(v1.x - v2.x, 2) + pow(v1.y - v2.y, 2) + pow(v1.z - v2.z, 2));
    }
    //--------------------------------------------------------------------------------
    QAngle CalcAngle(const Vector& src, const Vector& dst)
    {
        QAngle vAngle;
        Vector delta((src.x - dst.x), (src.y - dst.y), (src.z - dst.z));
        double hyp = sqrt(delta.x*delta.x + delta.y*delta.y);

        vAngle.x = float(atanf(float(delta.z / hyp)) * 57.295779513082f);
        vAngle.y = float(atanf(float(delta.y / delta.x)) * 57.295779513082f);
        vAngle.z = 0.0f;

        if (delta.x >= 0.0)
            vAngle.y += 180.0f;

        return vAngle;
    }
    //--------------------------------------------------------------------------------
    float GetFOV(const QAngle& viewAngle, const QAngle& aimAngle)
    {
        Vector ang, aim;

        AngleVectors(viewAngle, aim);
        AngleVectors(aimAngle, ang);

        return RAD2DEG(acos(aim.Dot(ang) / aim.LengthSqr()));
    }
    //--------------------------------------------------------------------------------
    void ClampAngles(QAngle& angles)
    {
        if (angles.x > 89.0f) angles.x = 89.0f;
        else if (angles.x < -89.0f) angles.x = -89.0f;

        if (angles.y > 180.0f) angles.y = 180.0f;
        else if (angles.y < -180.0f) angles.y = -180.0f;

        angles.z = 0;
    }
    //--------------------------------------------------------------------------------
    void VectorTransform(const Vector& in1, const matrix3x4_t& in2, Vector& out)
    {
        out[0] = in1.Dot(in2[0]) + in2[0][3];
        out[1] = in1.Dot(in2[1]) + in2[1][3];
        out[2] = in1.Dot(in2[2]) + in2[2][3];
    }
    //--------------------------------------------------------------------------------
    void AngleVectors(const QAngle &angles, Vector& forward)
    {
        float    sp, sy, cp, cy;

        DirectX::XMScalarSinCos(&sp, &cp, DEG2RAD(angles[0]));
        DirectX::XMScalarSinCos(&sy, &cy, DEG2RAD(angles[1]));

        forward.x = cp * cy;
        forward.y = cp * sy;
        forward.z = -sp;
    }
    //--------------------------------------------------------------------------------
    void TraceLine(const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask, C_BasePlayer* ignore, trace_t* ptr)
    {
        Ray_t ray;
        ray.Init(vecAbsStart, vecAbsEnd);
        CTraceFilter filter;
        filter.pSkip = ignore;

        g_EngineTrace->TraceRay(ray, mask, &filter, ptr);
    }
    //--------------------------------------------------------------------------------
    void AngleVectors(const QAngle &angles, Vector& forward, Vector& right, Vector& up)
    {
        float sr, sp, sy, cr, cp, cy;

        DirectX::XMScalarSinCos(&sp, &cp, DEG2RAD(angles[0]));
        DirectX::XMScalarSinCos(&sy, &cy, DEG2RAD(angles[1]));
        DirectX::XMScalarSinCos(&sr, &cr, DEG2RAD(angles[2]));

        forward.x = (cp * cy);
        forward.y = (cp * sy);
        forward.z = (-sp);
        right.x = (-1 * sr * sp * cy + -1 * cr * -sy);
        right.y = (-1 * sr * sp * sy + -1 * cr *  cy);
        right.z = (-1 * sr * cp);
        up.x = (cr * sp * cy + -sr * -sy);
        up.y = (cr * sp * sy + -sr * cy);
        up.z = (cr * cp);
    }
    //--------------------------------------------------------------------------------
    void VectorAngles(const Vector& forward, QAngle& angles)
    {
        float    tmp, yaw, pitch;

        if (forward[1] == 0 && forward[0] == 0) {
            yaw = 0;
            if (forward[2] > 0)
                pitch = 270;
            else
                pitch = 90;
        }
        else {
            yaw = (atan2(forward[1], forward[0]) * 180 / DirectX::XM_PI);
            if (yaw < 0)
                yaw += 360;

            tmp = sqrt(forward[0] * forward[0] + forward[1] * forward[1]);
            pitch = (atan2(-forward[2], tmp) * 180 / DirectX::XM_PI);
            if (pitch < 0)
                pitch += 360;
        }

        angles[0] = pitch;
        angles[1] = yaw;
        angles[2] = 0;
    }
    //--------------------------------------------------------------------------------
    static bool screen_transform(const Vector& in, Vector& out)
    {
        static auto& w2sMatrix = g_EngineClient->WorldToScreenMatrix();

        out.x = w2sMatrix.m[0][0] * in.x + w2sMatrix.m[0][1] * in.y + w2sMatrix.m[0][2] * in.z + w2sMatrix.m[0][3];
        out.y = w2sMatrix.m[1][0] * in.x + w2sMatrix.m[1][1] * in.y + w2sMatrix.m[1][2] * in.z + w2sMatrix.m[1][3];
        out.z = 0.0f;

        float w = w2sMatrix.m[3][0] * in.x + w2sMatrix.m[3][1] * in.y + w2sMatrix.m[3][2] * in.z + w2sMatrix.m[3][3];

        if (w < 0.001f) {
            out.x *= 100000;
            out.y *= 100000;
            return false;
        }

        out.x /= w;
        out.y /= w;

        return true;
    }
    //--------------------------------------------------------------------------------
    bool WorldToScreen(const Vector& in, Vector& out)
    {
        if (screen_transform(in, out)) {
            int w, h;
            g_EngineClient->GetScreenSize(w, h);

            out.x = (w / 2.0f) + (out.x * w) / 2.0f;
            out.y = (h / 2.0f) - (out.y * h) / 2.0f;

            return true;
        }
        return false;
    }
    //--------------------------------------------------------------------------------
}
 
Yesgoter написал(а):
Вроде понял где проблема, попытаюсь объяснить доступно. Вот смотри, когда игрок видет, кого он может убить, аим не откидует пушку. Но как только перед игроком нет целей, происхходит откид
Нажмите для раскрытия...
If (target == nullptr || target.origin.IsZero)
continue;

Как пример, но очень тупо.
Сделай сортировку игроков, если все игроки не валидны то отключай доводку и все
 
Abybachup написал(а):
If (target == nullptr || target.origin.IsZero)
continue;

Как пример, но очень тупо.
Сделай сортировку игроков, если все игроки не валидны то отключай доводку и все
Нажмите для раскрытия...
Можешь пожалуйста показать как делать проверку?
 
Yesgoter написал(а):
Можешь пожалуйста показать как делать проверку?
Нажмите для раскрытия...
Всем пока.
Мне вот интересно, сидишь с челами сарказмом отвечаешь, а потом еще и спунфид просишь?
Зайди в симпл или killaura и другие легит сурсы и посмотри.
Yesgoter написал(а):
Вроде понял где проблема, попытаюсь объяснить доступно. Вот смотри, когда игрок видет, кого он может убить, аим не откидует пушку. Но как только перед игроком нет целей, происхходит откид

Вроде с вектором все нормально, если что то не так, то вот код, может я чего - то не вижу.

C++:
Expand Collapse Copy 
namespace Math
{
    void FixAngles(QAngle& angles)
    {
        Normalize3(angles);
        ClampAngles(angles);
    }
    //--------------------------------------------------------------------------------
    float VectorDistance(const Vector& v1, const Vector& v2)
    {
        return FASTSQRT(pow(v1.x - v2.x, 2) + pow(v1.y - v2.y, 2) + pow(v1.z - v2.z, 2));
    }
    //--------------------------------------------------------------------------------
    QAngle CalcAngle(const Vector& src, const Vector& dst)
    {
        QAngle vAngle;
        Vector delta((src.x - dst.x), (src.y - dst.y), (src.z - dst.z));
        double hyp = sqrt(delta.x*delta.x + delta.y*delta.y);

        vAngle.x = float(atanf(float(delta.z / hyp)) * 57.295779513082f);
        vAngle.y = float(atanf(float(delta.y / delta.x)) * 57.295779513082f);
        vAngle.z = 0.0f;

        if (delta.x >= 0.0)
            vAngle.y += 180.0f;

        return vAngle;
    }
    //--------------------------------------------------------------------------------
    float GetFOV(const QAngle& viewAngle, const QAngle& aimAngle)
    {
        Vector ang, aim;

        AngleVectors(viewAngle, aim);
        AngleVectors(aimAngle, ang);

        return RAD2DEG(acos(aim.Dot(ang) / aim.LengthSqr()));
    }
    //--------------------------------------------------------------------------------
    void ClampAngles(QAngle& angles)
    {
        if (angles.x > 89.0f) angles.x = 89.0f;
        else if (angles.x < -89.0f) angles.x = -89.0f;

        if (angles.y > 180.0f) angles.y = 180.0f;
        else if (angles.y < -180.0f) angles.y = -180.0f;

        angles.z = 0;
    }
    //--------------------------------------------------------------------------------
    void VectorTransform(const Vector& in1, const matrix3x4_t& in2, Vector& out)
    {
        out[0] = in1.Dot(in2[0]) + in2[0][3];
        out[1] = in1.Dot(in2[1]) + in2[1][3];
        out[2] = in1.Dot(in2[2]) + in2[2][3];
    }
    //--------------------------------------------------------------------------------
    void AngleVectors(const QAngle &angles, Vector& forward)
    {
        float    sp, sy, cp, cy;

        DirectX::XMScalarSinCos(&sp, &cp, DEG2RAD(angles[0]));
        DirectX::XMScalarSinCos(&sy, &cy, DEG2RAD(angles[1]));

        forward.x = cp * cy;
        forward.y = cp * sy;
        forward.z = -sp;
    }
    //--------------------------------------------------------------------------------
    void TraceLine(const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask, C_BasePlayer* ignore, trace_t* ptr)
    {
        Ray_t ray;
        ray.Init(vecAbsStart, vecAbsEnd);
        CTraceFilter filter;
        filter.pSkip = ignore;

        g_EngineTrace->TraceRay(ray, mask, &filter, ptr);
    }
    //--------------------------------------------------------------------------------
    void AngleVectors(const QAngle &angles, Vector& forward, Vector& right, Vector& up)
    {
        float sr, sp, sy, cr, cp, cy;

        DirectX::XMScalarSinCos(&sp, &cp, DEG2RAD(angles[0]));
        DirectX::XMScalarSinCos(&sy, &cy, DEG2RAD(angles[1]));
        DirectX::XMScalarSinCos(&sr, &cr, DEG2RAD(angles[2]));

        forward.x = (cp * cy);
        forward.y = (cp * sy);
        forward.z = (-sp);
        right.x = (-1 * sr * sp * cy + -1 * cr * -sy);
        right.y = (-1 * sr * sp * sy + -1 * cr *  cy);
        right.z = (-1 * sr * cp);
        up.x = (cr * sp * cy + -sr * -sy);
        up.y = (cr * sp * sy + -sr * cy);
        up.z = (cr * cp);
    }
    //--------------------------------------------------------------------------------
    void VectorAngles(const Vector& forward, QAngle& angles)
    {
        float    tmp, yaw, pitch;

        if (forward[1] == 0 && forward[0] == 0) {
            yaw = 0;
            if (forward[2] > 0)
                pitch = 270;
            else
                pitch = 90;
        }
        else {
            yaw = (atan2(forward[1], forward[0]) * 180 / DirectX::XM_PI);
            if (yaw < 0)
                yaw += 360;

            tmp = sqrt(forward[0] * forward[0] + forward[1] * forward[1]);
            pitch = (atan2(-forward[2], tmp) * 180 / DirectX::XM_PI);
            if (pitch < 0)
                pitch += 360;
        }

        angles[0] = pitch;
        angles[1] = yaw;
        angles[2] = 0;
    }
    //--------------------------------------------------------------------------------
    static bool screen_transform(const Vector& in, Vector& out)
    {
        static auto& w2sMatrix = g_EngineClient->WorldToScreenMatrix();

        out.x = w2sMatrix.m[0][0] * in.x + w2sMatrix.m[0][1] * in.y + w2sMatrix.m[0][2] * in.z + w2sMatrix.m[0][3];
        out.y = w2sMatrix.m[1][0] * in.x + w2sMatrix.m[1][1] * in.y + w2sMatrix.m[1][2] * in.z + w2sMatrix.m[1][3];
        out.z = 0.0f;

        float w = w2sMatrix.m[3][0] * in.x + w2sMatrix.m[3][1] * in.y + w2sMatrix.m[3][2] * in.z + w2sMatrix.m[3][3];

        if (w < 0.001f) {
            out.x *= 100000;
            out.y *= 100000;
            return false;
        }

        out.x /= w;
        out.y /= w;

        return true;
    }
    //--------------------------------------------------------------------------------
    bool WorldToScreen(const Vector& in, Vector& out)
    {
        if (screen_transform(in, out)) {
            int w, h;
            g_EngineClient->GetScreenSize(w, h);

            out.x = (w / 2.0f) + (out.x * w) / 2.0f;
            out.y = (h / 2.0f) - (out.y * h) / 2.0f;

            return true;
        }
        return false;
    }
    //--------------------------------------------------------------------------------
}
Нажмите для раскрытия...
Проблема не в самой математике, а то как твой легитбот выбирает цели.
Насколько я понял твой аим выбирает не существующий таргет у которого почти все данные равны 0 как и его позиция из-за чего тебя доводит на 0 координату.
 
Войдите или зарегистрируйтесь для ответа.

Похожие темы

K
Вопрос How to fix revolver not shoot in ground?
Ответы
1
Просмотры
254
zDrip
zDrip
K
Вопрос How to make prediction better?
Ответы
5
Просмотры
630
spidergng
spidergng
mercury997
Исходник Nemesis Resolver // supremacy c+p ready
Ответы
2
Просмотры
419
veinedhvhs
veinedhvhs
spidergng
Вопрос EV0LVE HOOKING METHOD
2
Ответы
36
Просмотры
2K
spidergng
spidergng
M
Вопрос Нужна помощь с CreateMove Hook
Ответы
2
Просмотры
250
marselshowssss
M
Немного о главном
Полезные мелочи
О нас

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

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