#include "quakedef.h"

Include dependency graph for phys.h:

This graph shows which files directly or indirectly include this file:

Enumerations
enum	unstickresult_t { UNSTICK_STUCK = 0 , UNSTICK_GOOD = -1 , UNSTICK_UNSTUCK = 1 }

Functions
unstickresult_t	PHYS_NudgeOutOfSolid (prvm_prog_t prog, prvm_edict_t ent)

qbool	PHYS_TestEntityPosition (prvm_prog_t prog, prvm_edict_t ent, vec3_t offset)

unstickresult_t	PHYS_UnstickEntityReturnOffset (prvm_prog_t prog, prvm_edict_t ent, vec3_t offset)

Variables
cvar_t	cl_gameplayfix_nudgeoutofsolid_separation

Enumeration Type Documentation

◆ unstickresult_t

enum unstickresult_t

Enumerator
UNSTICK_STUCK
UNSTICK_GOOD	didn't need to be unstuck
UNSTICK_UNSTUCK

Definition at line 9 of file phys.h.

{
    // matching the DP_QC_NUDGEOUTOFSOLID return values
    UNSTICK_STUCK = 0,
    UNSTICK_GOOD = -1, 
    UNSTICK_UNSTUCK = 1
}

Function Documentation

◆ PHYS_NudgeOutOfSolid()

unstickresult_t PHYS_NudgeOutOfSolid	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent )

move an entity that is stuck out of the surface it is stuck in (can move large amounts) with consideration to the properties of the surface and support for multiple surfaces. returns 1 if it found a better place, 0 if it remains stuck, -1 if it wasn't stuck. Replaces PHYS_UnstickEntityReturnOffset() but falls back to it when using cliphulls.

Definition at line 136 of file phys.c.

{
    int bump, pass;
    trace_t stucktrace;
    vec3_t testorigin, targetorigin;
    vec3_t stuckmins, stuckmaxs;
    vec_t separation;
    model_t *worldmodel;
 
    if (prog == SVVM_prog)
    {
        worldmodel = sv.worldmodel;
        separation = sv_gameplayfix_nudgeoutofsolid_separation.value;
    }
    else if (prog == CLVM_prog)
    {
        worldmodel = cl.worldmodel;
        separation = cl_gameplayfix_nudgeoutofsolid_separation.value;
    }
    else
        Sys_Error("PHYS_NudgeOutOfSolid: cannot be called from %s VM\n", prog->name);
 
    VectorCopy(PRVM_serveredictvector(ent, mins), stuckmins);
    VectorCopy(PRVM_serveredictvector(ent, maxs), stuckmaxs);
    if (worldmodel && worldmodel->TraceBox != Mod_CollisionBIH_TraceBox)
    {
        separation = 0.0f; // when using hulls, it can not be enlarged
 
        // FIXME: Mod_Q1BSP_TraceBox() doesn't support startdepth and startdepthnormal
        return PHYS_UnstickEntityReturnOffset(prog, ent, testorigin); // fallback
    }
    else
    {
        stuckmins[0] -= separation;
        stuckmins[1] -= separation;
        stuckmins[2] -= separation;
        stuckmaxs[0] += separation;
        stuckmaxs[1] += separation;
        stuckmaxs[2] += separation;
    }
 
    // first pass we try to get it out of brush entities
    // second pass we try to get it out of world only (can't win them all)
    for (pass = 0;pass < 2;pass++)
    {
        VectorCopy(PRVM_serveredictvector(ent, origin), testorigin);
        for (bump = 0;bump < 10;bump++)
        {
            stucktrace = PHYS_TraceBox(prog, testorigin, stuckmins, stuckmaxs, testorigin, pass ? MOVE_WORLDONLY : MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, pass ? false : true, false, NULL, false);
 
            // Separation compared here to ensure a good location will be recognised reliably.
            if (-stucktrace.startdepth <= separation
            || (!stucktrace.bmodelstartsolid && !stucktrace.worldstartsolid)
            || (pass && !stucktrace.worldstartsolid))
            {
                // found a good location, use it
                VectorCopy(testorigin, PRVM_serveredictvector(ent, origin));
                return bump || pass ? UNSTICK_UNSTUCK : UNSTICK_GOOD;
            }
 
            VectorMA(testorigin, -stucktrace.startdepth, stucktrace.startdepthnormal, targetorigin);
            // Trace to targetorigin so we don't set it out of the world in complex cases.
            stucktrace = PHYS_TraceBox(prog, testorigin, stuckmins, stuckmaxs, targetorigin, pass ? MOVE_WORLDONLY : MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, pass ? false : true, false, NULL, false);
            if (stucktrace.fraction)
                VectorCopy(stucktrace.endpos, testorigin);
            else
                break; // Can't move it so no point doing more iterations on this pass.
        }
    }
    return UNSTICK_STUCK;
}

References trace_t::bmodelstartsolid, cl, cl_gameplayfix_nudgeoutofsolid_separation, CLVM_prog, collision_extendmovelength, trace_t::endpos, trace_t::fraction, maxs, mins, Mod_CollisionBIH_TraceBox(), MOVE_NOMONSTERS, MOVE_WORLDONLY, prvm_prog_t::name, NULL, origin, PHYS_TraceBox(), PHYS_UnstickEntityReturnOffset(), PRVM_serveredictvector, trace_t::startdepth, trace_t::startdepthnormal, sv, sv_gameplayfix_nudgeoutofsolid_separation, SV_GenericHitSuperContentsMask(), SVVM_prog, Sys_Error(), model_t::TraceBox, UNSTICK_GOOD, UNSTICK_STUCK, UNSTICK_UNSTUCK, cvar_t::value, VectorCopy, VectorMA, client_state_t::worldmodel, server_t::worldmodel, and trace_t::worldstartsolid.

Referenced by SV_UnstickEntity(), VM_nudgeoutofsolid(), and VM_SV_droptofloor().

◆ PHYS_TestEntityPosition()

qbool PHYS_TestEntityPosition	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent,
		vec3_t	offset )

Definition at line 24 of file phys.c.

{
    int hitsupercontentsmask = SV_GenericHitSuperContentsMask(ent);
    int skipsupercontentsmask = 0;
    int skipmaterialflagsmask = 0;
    vec3_t org, entorigin, entmins, entmaxs;
    trace_t trace;
 
    VectorAdd(PRVM_serveredictvector(ent, origin), offset, org);
    VectorCopy(PRVM_serveredictvector(ent, origin), entorigin);
    VectorCopy(PRVM_serveredictvector(ent, mins), entmins);
    VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs);
    trace = PHYS_TraceBox(prog, org, entmins, entmaxs, entorigin, ((PRVM_serveredictfloat(ent, movetype) == MOVETYPE_FLY_WORLDONLY) ? MOVE_WORLDONLY : MOVE_NOMONSTERS), ent, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value, true, false, NULL, false);
    if (trace.startsupercontents & hitsupercontentsmask)
        return true;
    else
    {
        if (sv.worldmodel->brushq1.numclipnodes && !VectorCompare(PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs)))
        {
            // q1bsp/hlbsp use hulls and if the entity does not exactly match
            // a hull size it is incorrectly tested, so this code tries to
            // 'fix' it slightly...
            // FIXME: this breaks entities larger than the hull size
            int i;
            vec3_t v, m1, m2, s;
            VectorAdd(org, entmins, m1);
            VectorAdd(org, entmaxs, m2);
            VectorSubtract(m2, m1, s);
#define EPSILON (1.0f / 32.0f)
            if (s[0] >= EPSILON*2) {m1[0] += EPSILON;m2[0] -= EPSILON;}
            if (s[1] >= EPSILON*2) {m1[1] += EPSILON;m2[1] -= EPSILON;}
            if (s[2] >= EPSILON*2) {m1[2] += EPSILON;m2[2] -= EPSILON;}
            for (i = 0;i < 8;i++)
            {
                v[0] = (i & 1) ? m2[0] : m1[0];
                v[1] = (i & 2) ? m2[1] : m1[1];
                v[2] = (i & 4) ? m2[2] : m1[2];
                if (SV_PointSuperContents(v) & hitsupercontentsmask)
                    return true;
            }
        }
    }
    // if the trace found a better position for the entity, move it there
    if (VectorDistance2(trace.endpos, PRVM_serveredictvector(ent, origin)) >= 0.0001)
    {
#if 0
        // please switch back to this code when trace.endpos sometimes being in solid bug is fixed
        VectorCopy(trace.endpos, PRVM_serveredictvector(ent, origin));
#else
        // verify if the endpos is REALLY outside solid
        VectorCopy(trace.endpos, org);
        trace = PHYS_TraceBox(prog, org, entmins, entmaxs, org, MOVE_NOMONSTERS, ent, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value, true, false, NULL, false);
        if(trace.startsolid)
            Con_Printf("PHYS_TestEntityPosition: trace.endpos detected to be in solid. NOT using it.\n");
        else
            VectorCopy(org, PRVM_serveredictvector(ent, origin));
#endif
    }
    return false;
}

References collision_extendmovelength, Con_Printf(), trace_t::endpos, EPSILON, i, maxs, mins, MOVE_NOMONSTERS, MOVE_WORLDONLY, movetype, MOVETYPE_FLY_WORLDONLY, NULL, offset, origin, PHYS_TraceBox(), PRVM_serveredictfloat, PRVM_serveredictvector, trace_t::startsolid, trace_t::startsupercontents, sv, SV_GenericHitSuperContentsMask(), SV_PointSuperContents(), v, cvar_t::value, VectorAdd, VectorCompare, VectorCopy, VectorDistance2, VectorSubtract, and server_t::worldmodel.

Referenced by PHYS_UnstickEntityReturnOffset(), and SV_UnstickEntity().

◆ PHYS_UnstickEntityReturnOffset()

unstickresult_t PHYS_UnstickEntityReturnOffset	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent,
		vec3_t	offset )

move an entity that is stuck by small amounts in various directions to try to nudge it back into the collision hull returns 1 if it found a better place, 0 if it remains stuck, -1 if it wasn't stuck. Replaces SV_TryUnstick() and SV_CheckStuck() which in Quake applied to players only.

Definition at line 102 of file phys.c.

{
    int i, maxunstick;
 
    // if not stuck in a bmodel, just return
    if (!PHYS_TestEntityPosition(prog, ent, vec3_origin))
        return UNSTICK_GOOD;
 
    for (i = 0;i < (int)(sizeof(unstickoffsets) / sizeof(unstickoffsets[0]));i += 3)
    {
        if (!PHYS_TestEntityPosition(prog, ent, unstickoffsets + i))
        {
            VectorCopy(unstickoffsets + i, offset);
            return UNSTICK_UNSTUCK;
        }
    }
 
    maxunstick = (int) ((PRVM_serveredictvector(ent, maxs)[2] - PRVM_serveredictvector(ent, mins)[2]) * 0.36);
    // magic number 0.36 allows unsticking by up to 17 units with the largest supported bbox
 
    for(i = 2; i <= maxunstick; ++i)
    {
        VectorClear(offset);
        offset[2] = -i;
        if (!PHYS_TestEntityPosition(prog, ent, offset))
            return UNSTICK_UNSTUCK;
        offset[2] = i;
        if (!PHYS_TestEntityPosition(prog, ent, offset))
            return UNSTICK_UNSTUCK;
    }
 
    return UNSTICK_STUCK;
}