Что нового?

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

Yesgoter
Yesgoter
Пользователь
Статус
Оффлайн
Регистрация
5 Июл 2022
Сообщения
993
Реакции[?]
86
Поинты[?]
23K
Добрый вечер! Случилась такая проблема. У меня отбрасывает камеру при стрельбе в кс го. Подскажите пожалуйста, как это исправить. Видео с проблемой:
Пожалуйста, авторизуйтесь для просмотра ссылки.
м ПРОСЬБА МОДЕРАМ, НЕ СНОСИТЬ ДАННУЮ ТЕМУ!!!!!!!!!!!!!!!!!!
код:
Код: 
#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;
    }
}
 
SandF0xy
Ушастый
SandF0xy
Забаненный
Статус
Оффлайн
Регистрация
23 Ноя 2021
Сообщения
371
Реакции[?]
56
Поинты[?]
10K
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Сносите тему:
Это механика игры как бы
 
P0Z1T1V4iK28
Nike.lua
P0Z1T1V4iK28
Олдфаг
Статус
Оффлайн
Регистрация
13 Окт 2020
Сообщения
2,748
Реакции[?]
1,466
Поинты[?]
2K
Yesgoter написал(а):
бля, дядь, это ркс чуть чуть
Нажмите для раскрытия...
Ну ты проблему нормально опиши, чудик.
Ты кидаешь просто кусок аим файла, не понимая, где у тебя проблема.
ты думаешь, что каждый, кто будет тебе помогать возьмет и впастит твой код для теста?
Я хуй знает, если обычным дебаггером не можешь пользоваться, пользуйся примитивными дебаг средствами - коменти каждую функу и все ее депенды и запускай. Пойми уже наконец в чем проблема, а не в тупую пасти
 
Abybachup
Трахов
Abybachup
Пользователь
Статус
Оффлайн
Регистрация
6 Фев 2020
Сообщения
490
Реакции[?]
87
Поинты[?]
2K
Yesgoter написал(а):
бля, дядь, это ркс чуть чуть
Нажмите для раскрытия...
Дядя помоему тут только ты, РКС и есть вся суть проблемы...

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

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

C++: 
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;
    }
    //--------------------------------------------------------------------------------
}
 
Abybachup
Трахов
Abybachup
Пользователь
Статус
Оффлайн
Регистрация
6 Фев 2020
Сообщения
490
Реакции[?]
87
Поинты[?]
2K
Yesgoter написал(а):
Вроде понял где проблема, попытаюсь объяснить доступно. Вот смотри, когда игрок видет, кого он может убить, аим не откидует пушку. Но как только перед игроком нет целей, происхходит откид
Нажмите для раскрытия...
If (target == nullptr || target.origin.IsZero)
continue;

Как пример, но очень тупо.
Сделай сортировку игроков, если все игроки не валидны то отключай доводку и все
 
Yesgoter
Yesgoter
Пользователь
Статус
Оффлайн
Регистрация
5 Июл 2022
Сообщения
993
Реакции[?]
86
Поинты[?]
23K
Abybachup написал(а):
If (target == nullptr || target.origin.IsZero)
continue;

Как пример, но очень тупо.
Сделай сортировку игроков, если все игроки не валидны то отключай доводку и все
Нажмите для раскрытия...
Можешь пожалуйста показать как делать проверку?
 
Abybachup
Трахов
Abybachup
Пользователь
Статус
Оффлайн
Регистрация
6 Фев 2020
Сообщения
490
Реакции[?]
87
Поинты[?]
2K
Yesgoter написал(а):
Можешь пожалуйста показать как делать проверку?
Нажмите для раскрытия...
Всем пока.
Мне вот интересно, сидишь с челами сарказмом отвечаешь, а потом еще и спунфид просишь?
Зайди в симпл или killaura и другие легит сурсы и посмотри.
Yesgoter написал(а):
Вроде понял где проблема, попытаюсь объяснить доступно. Вот смотри, когда игрок видет, кого он может убить, аим не откидует пушку. Но как только перед игроком нет целей, происхходит откид

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

C++: 
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 координату.
 
Войдите или зарегистрируйтесь для ответа.
Немного о главном
Полезные мелочи
О нас

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

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