[Depresie]

As i said, it is a solution for the example... i can't find a work around if i don't know how the entity is behaving exactly

Basically all you have to do is detect when the entity gets suck at the start of a ramp and make it hop over without breaking it's actual behavior

[Hedgehog Fog]

Depresie
Here is not good way to detect If entity gets stuck start of a ramp and I have no idea how to make hop over.

[Depresie]

It is a good way to detect if the entity it's stuck on the start of the ramp, just that you have to perform couple more checks, depending on the entity's actual behavior

You can either make the hop over by either setting it's velocity on Z vector or it's origin ( but this may result into unpleasant issues, which will need additional checks to be fixed )

As i said, i cannot provide the right solution unless i know exactly how the entity actually behave

[Hedgehog Fog]

It is a good way to detect if the entity it's stuck on the start of the ramp, just that you have to perform couple more checks, depending on the entity's actual behavior

I see only one way, traces.

As i said, i cannot provide the right solution unless i know exactly how the entity actually behaves

I can't change Z velocity and must set previous Z value all time, because it's reserved for a gravity. Velocity sets during Think call, here is fast and bad solution: Add 0.1 to Z velocity before think and substract 0.1 from Z velocity after. But I have no way to use this solution, because I limited in the number of hooks.

Anyway it's undefined strange behavior. As we can see, NPC can move to the sloped surfaces.

[Depresie]

There is always a way, you just have to think it through

[Hedgehog Fog]

Depresie
I can't make some tests now and show full code, because I'm working. I'll write later.
Thanks.

[Depresie]

No problem

[Hedgehog Fog]

I have no idea why, but it's works. On default maps... But some algorithm didn't work on my map earlier:

PHP Code:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>
#include <xs>

new g_allocClassname;

new g_testEnt;
new g_mdlTest;

public plugin_init()
{
    register_plugin("", "", "");
    
    register_clcmd("ent_spawn", "clcmd_ent_spawn");
    
    RegisterHam(Ham_Think, "info_target", "OnThink");
    
    g_allocClassname = engfunc(EngFunc_AllocString, "info_target");
}

public plugin_precache()
{
    g_mdlTest = precache_model("models/gman.mdl");
}

public clcmd_ent_spawn(id)
{
    if (g_testEnt > 0) {
        engfunc(EngFunc_RemoveEntity, g_testEnt);
    }

    static Float:fOrigin[3];
    GetAimOrigin(id, fOrigin);
    
    g_testEnt = engfunc(EngFunc_CreateNamedEntity, g_allocClassname);
    dllfunc(DLLFunc_Spawn, g_testEnt);
        
    engfunc(EngFunc_SetSize, g_testEnt, Float:{-16.0, -16.0, 0.0}, Float:{16.0, 16.0, 64.0});
    engfunc(EngFunc_SetOrigin, g_testEnt, fOrigin);
    engfunc(EngFunc_DropToFloor, g_testEnt);
    
    set_pev(g_testEnt, pev_classname, "test_ent");
    set_pev(g_testEnt, pev_solid, SOLID_BBOX);
    set_pev(g_testEnt, pev_movetype, MOVETYPE_PUSHSTEP);
    set_pev(g_testEnt, pev_gravity, 1.0);    
    set_pev(g_testEnt, pev_iuser4, id);
    set_pev(g_testEnt, pev_modelindex, g_mdlTest);
    
    dllfunc(DLLFunc_Think, g_testEnt);
}

public OnThink(ent)
{
    static classname[32];
    pev(ent, pev_classname, classname, charsmax(classname));
    
    if (!equal(classname, "test_ent")) {
        return;
    }
    
    new target = pev(ent, pev_iuser4);
    if (target > 0) {
        static Float:fTarget[3];
        pev(target, pev_origin, fTarget);
        
        TurnTo(fTarget);
        MoveForward(200.0);
    }


    DrawBox(ent)

    set_pev(ent, pev_nextthink, get_gametime() + 0.1);
}

MoveForward(Float:fSpeed)
{
    if (g_testEnt <= 0) {
        return;
    }

    static Float:fDirection[3];
    GetDirectionVector(g_testEnt, fDirection);
    xs_vec_mul_scalar(fDirection, fSpeed, fDirection);
    
    static Float:fVelocity[3];
    pev(g_testEnt, pev_velocity, fVelocity);
    fDirection[2] = fVelocity[2];
    
    set_pev(g_testEnt, pev_velocity, fDirection);
}

TurnTo(const Float:fTarget[3]) 
{
    static Float:fOrigin[3];
    pev(g_testEnt, pev_origin, fOrigin);
    
    xs_vec_sub(fTarget, fOrigin, fOrigin);

    static Float:fAngles[3];
    engfunc(EngFunc_VecToAngles, fOrigin, fAngles);
    fAngles[0] = 0.0;
    fAngles[2] = 0.0; 
    
    set_pev(g_testEnt, pev_angles, fAngles);
    set_pev(g_testEnt, pev_v_angle, fAngles);
}

stock GetDirectionVector(ent, Float:fOut[3])
{
    static Float:fAngles[3];
    pev(ent, pev_angles, fAngles);
    angle_vector(fAngles, ANGLEVECTOR_FORWARD, fOut);
    xs_vec_normalize(fOut, fOut);
}

stock GetAimOrigin(id, Float:fOut[3], Float:fDistance = 1024.0)
{
    static Float:fStart[3];    
    pev(id, pev_origin, fStart);
    
    static Float:view_ofs[3];
    pev(id, pev_view_ofs, view_ofs);
    
    xs_vec_add(fStart, view_ofs, fStart);

    static Float:fEnd[3];
    pev(id, pev_v_angle, fEnd);
    engfunc(EngFunc_MakeVectors, fEnd);
    global_get(glb_v_forward, fEnd);
    xs_vec_mul_scalar(fEnd, fDistance, fEnd);
    xs_vec_add(fStart, fEnd, fEnd);

    engfunc(EngFunc_TraceLine, fStart, fEnd, 0, id, 0);
    get_tr2(0, TR_vecEndPos, fOut);
}

stock DrawBox(ent)
{
    new Float:fMins[3];
    pev(ent, pev_absmin, fMins);
    
    new Float:fMaxs[3];       
    pev(ent, pev_absmax, fMaxs);  
    
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
    write_byte(TE_BOX);
    engfunc(EngFunc_WriteCoord, fMins[0]);
    engfunc(EngFunc_WriteCoord, fMins[1]);
    engfunc(EngFunc_WriteCoord, fMins[2]);
    engfunc(EngFunc_WriteCoord, fMaxs[0]);
    engfunc(EngFunc_WriteCoord, fMaxs[1]);
    engfunc(EngFunc_WriteCoord, fMaxs[2]);
    write_short(1);
    write_byte(255);
    write_byte(255);
    write_byte(255);
    message_end();
} 


[Depresie]

Probably because there was a negative value on velocity Z.. can't go up if it's going down lol

[Hedgehog Fog]

Depresie
Nope, Z velocity is equal to 0. I think it's just a magic surface.