phys.c File Reference

#include "phys.h"
#include "quakedef.h"
#include "cl_collision.h"

Include dependency graph for phys.c:

Go to the source code of this file.

Macros
#define	EPSILON   (1.0f / 32.0f)

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)
static trace_t	PHYS_TraceBox (prvm_prog_t *prog, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend, qbool hitnetworkbrushmodels, qbool hitnetworkplayers, int *hitnetworkentity, qbool hitcsqcentities)
unstickresult_t	PHYS_UnstickEntityReturnOffset (prvm_prog_t *prog, prvm_edict_t *ent, vec3_t offset)

Variables
static float	unstickoffsets []

Macro Definition Documentation

EPSILON

#define EPSILON   (1.0f / 32.0f)

Referenced by PHYS_TestEntityPosition().

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_TraceBox()

static trace_t PHYS_TraceBox ( prvm_prog_t * prog, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t * passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend, qbool hitnetworkbrushmodels, qbool hitnetworkplayers, int * hitnetworkentity, qbool hitcsqcentities )

inlinestatic

Definition at line 10 of file phys.c.

{
    return (prog == SVVM_prog)
        ? SV_TraceBox(start, mins, maxs, end, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend)
        : CL_TraceBox(start, mins, maxs, end, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend, hitnetworkbrushmodels, hitnetworkplayers, hitnetworkentity, hitcsqcentities);
}

References CL_TraceBox(), maxs, mins, SV_TraceBox(), SVVM_prog, and type.

Referenced by PHYS_NudgeOutOfSolid(), and PHYS_TestEntityPosition().

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;
}

References i, int(), maxs, mins, offset, PHYS_TestEntityPosition(), PRVM_serveredictvector, UNSTICK_GOOD, UNSTICK_STUCK, UNSTICK_UNSTUCK, unstickoffsets, vec3_origin, VectorClear, and VectorCopy.

Referenced by PHYS_NudgeOutOfSolid(), and SV_UnstickEntity().

Variable Documentation

unstickoffsets

float unstickoffsets[]

static

Initial value:

=
{
    
     0,  0,  -1,
     0,  0,  1,
     
    -1,  0,  0,
     1,  0,  0,
     0, -1,  0,
     0,  1,  0,
     
    -1, -1,  0,
     1, -1,  0,
    -1,  1,  0,
     1,  1,  0,
}

Definition at line 85 of file phys.c.

{
    // poutting -/+z changes first as they are least weird
     0,  0,  -1,
     0,  0,  1,
     // x or y changes
    -1,  0,  0,
     1,  0,  0,
     0, -1,  0,
     0,  1,  0,
     // x and y changes
    -1, -1,  0,
     1, -1,  0,
    -1,  1,  0,
     1,  1,  0,
};

Referenced by PHYS_UnstickEntityReturnOffset().