Вопрос Не работает Jump bug даже по трассировке

[ayi]

как мне сказали в предыдущей теме, мне нужно делать джампбаг либо по предикту, либо по предиктфлагам, либо по трассировке. первые 2 отпадают так как я не знаю как делать по ним, и получается еще хуже. вообщем, дело в том что у меня иногда промахи по таймингам, откуда я уже только не пастил, unknowncheats не помог. не получается сделать, те кто смогут помочь буду рад =)

#define M_PI 3.14159265358979323846
#define MAX_TRACE_LENGTH 128.0f

void F::MISC::MOVEMENT::JumpBug(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn)
{
    if (!C_GET(bool, Vars.bJumpBug) || !pLocalPawn || !pLocalPawn->IsAlive())
        return;

    if (const int32_t moveType = pLocalPawn->GetMoveType(); moveType == MOVETYPE_LADDER || moveType == MOVETYPE_NOCLIP)
        return;

    static bool unduck = false;
    const float max_radias = 2.0f * M_PI;
    const float step = max_radias / 128.0f;
    const float xThick = 23.0f;

    CGameSceneNode* pGameSceneNode = pLocalPawn->GetGameSceneNode();
    if (!pGameSceneNode)
        return;

    CCollisionProperty* pCollision = pLocalPawn->GetCollision();
    if (!pCollision)
        return;

    Vector_t vecOrigin = pGameSceneNode->GetAbsOrigin();
    Vector_t vecVelocity = pLocalPawn->GetAbsVelocity();

    if (pLocalPawn->GetFlags() & FL_ONGROUND)
    {
        if (unduck)
        {
            pCmd->nButtons.nValue &= ~IN_DUCK;
            pCmd->nButtons.nValue |= IN_JUMP;
            unduck = false;
            return;
        }

        trace_data_t trace_data = {};
        trace_data.m_arr_pointer = &trace_data.m_arr;
        trace_data.m_start = vecOrigin;
        trace_data.m_end = Vector_t(vecOrigin.x, vecOrigin.y, vecOrigin.z - MAX_TRACE_LENGTH);

        TraceFilter_t filter = {};
        static CGameTraceManager traceManager;
        static bool traceInitialized = traceManager.TraceHook();
        if (!traceInitialized)
            return;

        traceManager.Init(filter, pLocalPawn, 0x1, 0, 0); // MASK_SOLID_BRUSHONLY = 0x1

        traceManager.CreateTrace(&trace_data, vecOrigin, trace_data.m_end, filter, 1);

        if (trace_data.m_num_update > 0)
        {
            for (int i = 0; i < trace_data.m_num_update; i++)
            {
                auto* value = reinterpret_cast<UpdateValueT*>(
                    reinterpret_cast<uintptr_t>(trace_data.m_pointer_update_value) + i * sizeof(UpdateValueT));

                game_trace_t game_trace = {};
                traceManager.init_trace_info(&game_trace);
                traceManager.get_trace_info(
                    &trace_data, &game_trace, 0.0f,
                    reinterpret_cast<void*>(
                        reinterpret_cast<uintptr_t>(trace_data.m_arr.data()) + sizeof(trace_arr_element_t) * (value->handleIdx & 0x7fffu)));

                if (game_trace.Fraction < 1.0f && game_trace.Fraction > 0.0f && vecVelocity.z < -200.f)
                {
                    float distanceToGround = (vecOrigin.z - game_trace.m_end_pos.z);
                    float timeToLand = distanceToGround / fabsf(vecVelocity.z);

                    if (timeToLand < 0.15f)
                    {
                        pCmd->nButtons.nValue |= IN_DUCK;
                        pCmd->nButtons.nValue &= ~IN_JUMP;
                        unduck = true;
                        return;
                    }
                }
            }
        }

        for (int i = 0; i < 3; i++)
        {
            float radius = xThick;
            if (i == 1) radius -= 2.0f;
            if (i == 2) radius -= 20.0f;

            for (float a = 0.0f; a < max_radias; a += step)
            {
                Vector_t pt;
                pt.x = (radius * cos(a)) + vecOrigin.x;
                pt.y = (radius * sin(a)) + vecOrigin.y;
                pt.z = vecOrigin.z;

                Vector_t pt2 = pt;
                pt2.z -= 6.0f;

                trace_data_t circle_trace_data = {};
                circle_trace_data.m_arr_pointer = &circle_trace_data.m_arr;
                circle_trace_data.m_start = pt;
                circle_trace_data.m_end = pt2;

                traceManager.CreateTrace(&circle_trace_data, pt, pt2, filter, 1);

                if (circle_trace_data.m_num_update > 0)
                {
                    auto* value = reinterpret_cast<UpdateValueT*>(
                        reinterpret_cast<uintptr_t>(circle_trace_data.m_pointer_update_value) + 0 * sizeof(UpdateValueT));

                    game_trace_t circle_trace = {};
                    traceManager.init_trace_info(&circle_trace);
                    traceManager.get_trace_info(
                        &circle_trace_data, &circle_trace, 0.0f,
                        reinterpret_cast<void*>(
                            reinterpret_cast<uintptr_t>(circle_trace_data.m_arr.data()) + sizeof(trace_arr_element_t) * (value->handleIdx & 0x7fffu)));

                    if (circle_trace.Fraction < 1.0f && circle_trace.Fraction > 0.0f && vecVelocity.z < -200.f)
                    {
                        pCmd->nButtons.nValue |= IN_DUCK;
                        pCmd->nButtons.nValue &= ~IN_JUMP;
                        unduck = true;
                        return;
                    }
                }
            }
        }
    }
    else
    {
        if (pCmd->nButtons.nValue & IN_DUCK)
        {
            pCmd->nButtons.nValue &= ~IN_DUCK;
        }
    }
}

 

[f33nRy]

Ну во первых ты делаешь какую-то шляпу по скану. Используй TraseShape, этого достаточно. Ну и следовательно тебе нужно правильно настроить лучь и поставить коллизии и маски в фильтре которые тебе нужны. Во вторых без пред мувов у тебя все равно будет неточность(хотя она будет в любом случае, но её можно уменьшить) из-за того, что ты никак не компенсируешь то же положение, скорость и углы.
А вообще в твоем случае у тебя есть вариант вывести себе лог, на пример в консоль по каждому из трейсеров и информации на игрока и смотреть при каких значениях будет правильно срабатывать, а затем скорректировать свои проверки под подходящие значения(это все равно не будет идеальным, но должно работать +- адекватно в твоем случае). Других вариантов нет, ну кроме как купить у кого-нибудь если у самого нет нужных навыков.