movetypes.qc File Reference

#include "movetypes.qh"

Include dependency graph for movetypes.qc:

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

Go to the source code of this file.

Macros
#define	X(v)   if (_Movetype_TestEntityPosition(v))
#define	X(s)

Functions
void	_Movetype_CheckStuck (entity this)
void	_Movetype_CheckVelocity (entity this)
bool	_Movetype_CheckWater (entity this)
void	_Movetype_CheckWaterTransition (entity ent)
vector	_Movetype_ClipVelocity (vector vel, vector norm, float f)
int	_Movetype_ContentsMask (entity this)
int	_Movetype_FlyMove (entity this, float dt, bool applygravity, bool applystepnormal, float stepheight)
void	_Movetype_Impact (entity this, entity oth)
void	_Movetype_LinkEdict (entity this, bool touch_triggers)
void	_Movetype_LinkEdict_TouchAreaGrid (entity this)
bool	_Movetype_NudgeOutOfSolid_PivotIsKnownGood (entity this, vector pivot)
void	_Movetype_Physics_ClientFrame (entity this, float movedt)
void	_Movetype_Physics_Frame (entity this, float movedt)
bool	_Movetype_PushEntity (entity this, vector push, bool failonstartsolid, bool dolink)
void	_Movetype_PushEntityTrace (entity this, vector push)
bool	_Movetype_TestEntityPosition (vector ofs)
bool	_Movetype_TestEntityPosition_Offset (int offset)
int	_Movetype_UnstickEntity (entity this)
void	_Movetype_WallFriction (entity this, vector stepnormal)
void	Movetype_Physics_MatchServer (entity this, bool sloppy)
void	Movetype_Physics_MatchTicrate (entity this, float tr, bool sloppy)
void	Movetype_Physics_NoMatchServer (entity this)
void	Movetype_Physics_NoMatchTicrate (entity this, float movedt, bool isclient)

Variables
entity	_Movetype_TestEntityPosition_ent
bool	autocvar__movetype_debug = false
vector	planes [MAX_CLIP_PLANES]
vector	tic_angles
vector	tic_avelocity
int	tic_flags
vector	tic_origin
vector	tic_saved_angles
vector	tic_saved_avelocity
int	tic_saved_flags
vector	tic_saved_origin
vector	tic_saved_velocity
vector	tic_velocity

Macro Definition Documentation

X [1/2]

#define X

(

v

)

if (_Movetype_TestEntityPosition(v))

Referenced by _Movetype_UnstickEntity(), and Movetype_Physics_MatchTicrate().

X [2/2]

#define X

(

s

)

Value:

if(this.(s) != this.tic_saved_##s) \
        this.tic_##s = this.(s)

Function Documentation

_Movetype_CheckStuck()

void _Movetype_CheckStuck

(

entity

this

)

Definition at line 649 of file movetypes.qc.

References _Movetype_LinkEdict(), _Movetype_TestEntityPosition(), _Movetype_UnstickEntity(), oldorigin, origin, UNSTICK_FINE, UNSTICK_FIXED, UNSTICK_STUCK, and vector().

Referenced by _Movetype_Physics_ClientFrame(), and _Movetype_Physics_Walk().

{
    int unstick = _Movetype_UnstickEntity(this); // sets test position entity
    switch(unstick)
    {
        case UNSTICK_FINE:
            this.oldorigin = this.origin;
            break;
        case UNSTICK_FIXED:
            break; // already sorted
        case UNSTICK_STUCK:
            vector offset = this.oldorigin - this.origin;
            if(!_Movetype_TestEntityPosition(offset))
                _Movetype_LinkEdict(this, false);
            // couldn't unstick, should we warn about this?
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_CheckVelocity()

void _Movetype_CheckVelocity

(

entity

this

)

Definition at line 339 of file movetypes.qc.

Referenced by _Movetype_Physics_Step(), _Movetype_Physics_Toss(), and _Movetype_Physics_Walk().

{
    // if(vlen(this.velocity) < 0.0001)
    // this.velocity = '0 0 0';
}

Here is the caller graph for this function:

_Movetype_CheckWater()

bool _Movetype_CheckWater

(

entity

this

)

Definition at line 345 of file movetypes.qc.

References CONTENT_EMPTY, DPCONTENTS_LIQUIDSMASK, maxs, mins, origin, vector(), view_ofs, waterlevel, WATERLEVEL_NONE, WATERLEVEL_SUBMERGED, WATERLEVEL_SWIMMING, WATERLEVEL_WETFEET, and watertype.

Referenced by _Movetype_Physics_ClientFrame(), _Movetype_Physics_Frame(), _Movetype_Physics_Walk(), and PM_ClientMovement_UpdateStatus().

{
    vector point = this.origin;
    point.z += this.mins.z + 1;

    int nativecontents = pointcontents(point);
    if(this.watertype && this.watertype != nativecontents)
    {
        // dprintf("_Movetype_CheckWater(): Original: '%d', New: '%d'\n", this.watertype, nativecontents);
        if(this.contentstransition)
            this.contentstransition(this.watertype, nativecontents);
    }

    this.waterlevel = WATERLEVEL_NONE;
    this.watertype = CONTENT_EMPTY;

    int supercontents = Mod_Q1BSP_SuperContentsFromNativeContents(nativecontents);
    if(supercontents & DPCONTENTS_LIQUIDSMASK)
    {
        this.watertype = nativecontents;
        this.waterlevel = WATERLEVEL_WETFEET;
        point.z = this.origin.z + (this.mins.z + this.maxs.z) * 0.5;
        if(Mod_Q1BSP_SuperContentsFromNativeContents(pointcontents(point)) & DPCONTENTS_LIQUIDSMASK)
        {
            this.waterlevel = WATERLEVEL_SWIMMING;
            point.z = this.origin.z + this.view_ofs.z;
            if(Mod_Q1BSP_SuperContentsFromNativeContents(pointcontents(point)) & DPCONTENTS_LIQUIDSMASK)
                this.waterlevel = WATERLEVEL_SUBMERGED;
        }
    }

    return this.waterlevel > 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_CheckWaterTransition()

void _Movetype_CheckWaterTransition

(

entity

ent

)

Definition at line 379 of file movetypes.qc.

References CONTENT_EMPTY, CONTENT_WATER, and GAMEPLAYFIX_WATERTRANSITION.

Referenced by _Movetype_Physics_Step(), and _Movetype_Physics_Toss().

{
    int contents = pointcontents(ent.origin);

    if(!ent.watertype)
    {
        // just spawned here
        if(!GAMEPLAYFIX_WATERTRANSITION(ent))
        {
            ent.watertype = contents;
            ent.waterlevel = 1;
            return;
        }
    }
    else if(ent.watertype != contents)
    {
        // dprintf("_Movetype_CheckWaterTransition(): Origin: %s, Direct: '%d', Original: '%d', New: '%d'\n", vtos(ent.origin), pointcontents(ent.origin), ent.watertype, contents);
        if(ent.contentstransition)
            ent.contentstransition(ent.watertype, contents);
    }

    if(contents <= CONTENT_WATER)
    {
        ent.watertype = contents;
        ent.waterlevel = 1;
    }
    else
    {
        ent.watertype = CONTENT_EMPTY;
        ent.waterlevel = (GAMEPLAYFIX_WATERTRANSITION(ent) ? 0 : contents);
    }
}

Here is the caller graph for this function:

_Movetype_ClipVelocity()

vector _Movetype_ClipVelocity	(	vector	vel,
		vector	norm,
		float	f
	)

Definition at line 668 of file movetypes.qc.

Referenced by _Movetype_FlyMove(), and _Movetype_Physics_Toss().

{
    vel -= ((vel * norm) * norm) * f;

    if(vel.x > -0.1 && vel.x < 0.1) vel.x = 0;
    if(vel.y > -0.1 && vel.y < 0.1) vel.y = 0;
    if(vel.z > -0.1 && vel.z < 0.1) vel.z = 0;

    return vel;
}

Here is the caller graph for this function:

_Movetype_ContentsMask()

int _Movetype_ContentsMask

(

entity

this

)

Definition at line 559 of file movetypes.qc.

References DPCONTENTS_BODY, DPCONTENTS_CORPSE, DPCONTENTS_MONSTERCLIP, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, dphitcontentsmask, FL_MONSTER, flags, solid, SOLID_CORPSE, SOLID_SLIDEBOX, and SOLID_TRIGGER.

Referenced by _Movetype_TestEntityPosition().

{
    if(this)
    {
        if(this.dphitcontentsmask)
            return this.dphitcontentsmask;
        else if(this.solid == SOLID_SLIDEBOX)
        {
            if(this.flags & FL_MONSTER)
                return DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_MONSTERCLIP;
            else
                return DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP;
        }
        else if(this.solid == SOLID_CORPSE)
            return DPCONTENTS_SOLID | DPCONTENTS_BODY;
        else if(this.solid == SOLID_TRIGGER)
            return DPCONTENTS_SOLID | DPCONTENTS_BODY;
        else
            return DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
    }
    else
        return DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
}

Here is the caller graph for this function:

_Movetype_FlyMove()

int _Movetype_FlyMove	(	entity	this,
		float	dt,
		bool	applygravity,
		bool	applystepnormal,
		float	stepheight
	)

Definition at line 124 of file movetypes.qc.

References _Movetype_ClipVelocity(), _Movetype_PushEntity(), cross, dir, fabs(), FL_WATERJUMP, flags, GAMEPLAYFIX_EASIERWATERJUMP, gravity, groundentity, IS_ONGROUND, MAX_CLIP_PLANES, move_didgravity, move_stepnormal, NULL, origin, PHYS_WALLCLIP, pm_time, SET_ONGROUND, sqrt(), trace_allsolid, trace_endpos, trace_ent, trace_fraction, trace_plane_normal, trace_startsolid, vec3, vector(), and velocity.

Referenced by _Movetype_Physics_Step(), and _Movetype_Physics_Walk().

{
    move_stepnormal = '0 0 0';

    if(dt <= 0)
        return 0;

    int blockedflag = 0;
    int i, j, numplanes = 0;
    float time_left = dt, grav = 0;
    vector push;
    vector primal_velocity, original_velocity;
    vector restore_velocity = this.velocity;

    for(i = 0; i < MAX_CLIP_PLANES; ++i)
        planes[i] = '0 0 0';

    if(applygravity)
    {
        this.move_didgravity = 1;
        grav = dt * (this.gravity ? this.gravity : 1) * PHYS_GRAVITY(this);

        if(!GAMEPLAYFIX_NOGRAVITYONGROUND || !IS_ONGROUND(this))
        {
            if(GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
                this.velocity_z -= grav * 0.5;
            else
                this.velocity_z -= grav;
        }
    }

    original_velocity = primal_velocity = this.velocity;

    for(int bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
    {
        if(this.velocity == '0 0 0')
            break;

        push = this.velocity * time_left;
        if(!_Movetype_PushEntity(this, push, true, false))
        {
            // we got teleported by a touch function
            // let's abort the move
            blockedflag |= 8;
            break;
        }

        // this code is used by MOVETYPE_WALK and MOVETYPE_STEP and SV_UnstickEntity
        // abort move if we're stuck in the world (and didn't make it out)
        if(trace_startsolid && trace_allsolid)
        {
            this.velocity = restore_velocity;
            return 3;
        }

        if(trace_fraction == 1)
            break;

        float my_trace_fraction = trace_fraction;
        vector my_trace_plane_normal = trace_plane_normal;

        if(trace_plane_normal.z)
        {
            if(trace_plane_normal.z > 0.7)
            {
                // floor
                blockedflag |= 1;

                if(!trace_ent)
                {
                    //dprint("_Movetype_FlyMove: !trace_ent\n");
                    trace_ent = NULL;
                }

                SET_ONGROUND(this);
                this.groundentity = trace_ent;
            }
        }
        else if(stepheight)
        {
            // step - handle it immediately
            vector org = this.origin;
            vector steppush = '0 0 1' * stepheight;

            if(!_Movetype_PushEntity(this, steppush, true, false))
            {
                blockedflag |= 8;
                break;
            }
            if(!_Movetype_PushEntity(this, push, true, false))
            {
                blockedflag |= 8;
                break;
            }
            float trace2_fraction = trace_fraction;
            steppush = vec3(0, 0, org.z - this.origin_z);
            if(!_Movetype_PushEntity(this, steppush, true, false))
            {
                blockedflag |= 8;
                break;
            }

            // accept the new position if it made some progress...
            if(fabs(this.origin_x - org.x) >= 0.03125 || fabs(this.origin_y - org.y) >= 0.03125)
            {
                trace_endpos = this.origin;
                time_left *= 1 - trace2_fraction;
                numplanes = 0;
                continue;
            }
            else
                this.origin = org;
        }
        else
        {
            // step - return it to caller
            blockedflag |= 2;
            // save the trace for player extrafriction
            if(applystepnormal)
                move_stepnormal = trace_plane_normal;
        }

        if(my_trace_fraction >= 0.001)
        {
            // actually covered some distance
            original_velocity = this.velocity;
            numplanes = 0;
        }

        time_left *= 1 - my_trace_fraction;

        // clipped to another plane
        if(numplanes >= MAX_CLIP_PLANES)
        {
            // this shouldn't really happen
            this.velocity = '0 0 0';
            blockedflag = 3;
            break;
        }

        planes[numplanes] = my_trace_plane_normal;
        numplanes++;

        // modify original_velocity so it parallels all of the clip planes
        vector new_velocity = '0 0 0';
        for (i = 0;i < numplanes;i++)
        {
            new_velocity = _Movetype_ClipVelocity(original_velocity, planes[i], 1);
            for (j = 0;j < numplanes;j++)
            {
                if(j != i)
                {
                    // not ok
                    if((new_velocity * planes[j]) < 0)
                        break;
                }
            }
            if(j == numplanes)
                break;
        }

        if(i != numplanes)
        {
            // go along this plane
            this.velocity = new_velocity;
        }
        else
        {
            // go along the crease
            if(numplanes != 2)
            {
                this.velocity = '0 0 0';
                blockedflag = 7;
                break;
            }
            vector dir = cross(planes[0], planes[1]);
            // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
            float ilength = sqrt((dir * dir));
            if(ilength)
                ilength = 1.0 / ilength;
            dir.x *= ilength;
            dir.y *= ilength;
            dir.z *= ilength;
            float d = (dir * this.velocity);
            this.velocity = dir * d;
        }

        // if current velocity is against the original velocity,
        // stop dead to avoid tiny occilations in sloping corners
        if((this.velocity * primal_velocity) <= 0)
        {
            this.velocity = '0 0 0';
            break;
        }
    }

    // LordHavoc: this came from QW and allows you to get out of water more easily
    if(GAMEPLAYFIX_EASIERWATERJUMP(this) && (this.flags & FL_WATERJUMP) && !(blockedflag & 8))
        this.velocity = primal_velocity;

    if(PHYS_WALLCLIP(this) && this.pm_time && !(this.flags & FL_WATERJUMP) && !(blockedflag & 8))
        this.velocity = primal_velocity;

    if(applygravity)
    {
        if(!GAMEPLAYFIX_NOGRAVITYONGROUND || !IS_ONGROUND(this))
        {
            if(GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
                this.velocity_z -= grav * 0.5f;
        }
    }

    return blockedflag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_Impact()

void _Movetype_Impact	(	entity	this,
		entity	oth
	)

Definition at line 412 of file movetypes.qc.

References entity(), solid, SOLID_NOT, trace_allsolid, trace_dphitcontents, trace_dphitq3surfaceflags, trace_dphittexturename, trace_dpstartcontents, trace_endpos, trace_ent, trace_fraction, trace_inopen, trace_inwater, trace_plane_dist, trace_plane_normal, trace_startsolid, and vector().

Referenced by _Movetype_PushEntity().

{
    if(!this && !oth)
        return;

    // due to a lack of pointers in QC, we must save the trace values and restore them for other functions
    bool save_trace_allsolid = trace_allsolid;
    bool save_trace_startsolid = trace_startsolid;
    float save_trace_fraction = trace_fraction;
    bool save_trace_inwater = trace_inwater;
    bool save_trace_inopen = trace_inopen;
    vector save_trace_endpos = trace_endpos;
    vector save_trace_plane_normal = trace_plane_normal;
    float save_trace_plane_dist = trace_plane_dist;
    entity save_trace_ent = trace_ent;
    int save_trace_dpstartcontents = trace_dpstartcontents;
    int save_trace_dphitcontents = trace_dphitcontents;
    int save_trace_dphitq3surfaceflags = trace_dphitq3surfaceflags;
    string save_trace_dphittexturename = trace_dphittexturename;

    if(this.solid != SOLID_NOT && gettouch(this))
        gettouch(this)(this, oth);

    if(oth.solid != SOLID_NOT && gettouch(oth))
        gettouch(oth)(oth, this);

    trace_allsolid = save_trace_allsolid;
    trace_startsolid = save_trace_startsolid;
    trace_fraction = save_trace_fraction;
    trace_inwater = save_trace_inwater;
    trace_inopen = save_trace_inopen;
    trace_endpos = save_trace_endpos;
    trace_plane_normal = save_trace_plane_normal;
    trace_plane_dist = save_trace_plane_dist;
    trace_ent = save_trace_ent;
    trace_dpstartcontents = save_trace_dpstartcontents;
    trace_dphitcontents = save_trace_dphitcontents;
    trace_dphitq3surfaceflags = save_trace_dphitq3surfaceflags;
    trace_dphittexturename = save_trace_dphittexturename;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_LinkEdict()

void _Movetype_LinkEdict	(	entity	this,
		bool	touch_triggers
	)

Definition at line 512 of file movetypes.qc.

References _Movetype_LinkEdict_TouchAreaGrid(), absmax, absmin, FL_ITEM, flags, maxs, mins, origin, setorigin(), solid, SOLID_BSP, and vector().

Referenced by _Movetype_CheckStuck(), _Movetype_Physics_ClientFrame(), _Movetype_Physics_Follow(), _Movetype_Physics_Frame(), _Movetype_Physics_Step(), _Movetype_Physics_Walk(), _Movetype_PushEntity(), _Movetype_PushMove(), and _Movetype_UnstickEntity().

{
    if(autocvar__movetype_debug)
    {
        vector mi, ma;
        if(this.solid == SOLID_BSP)
        {
            // TODO set the absolute bbox
            mi = this.mins;
            ma = this.maxs;
        }
        else
        {
            mi = this.mins;
            ma = this.maxs;
        }
        mi += this.origin;
        ma += this.origin;

        if(this.flags & FL_ITEM)
        {
            mi -= '15 15 1';
            ma += '15 15 1';
        }
        else
        {
            mi -= '1 1 1';
            ma += '1 1 1';
        }

        this.absmin = mi;
        this.absmax = ma;
    }
    else
    {
        setorigin(this, this.origin); // calls SV_LinkEdict
    #ifdef CSQC
        // NOTE: CSQC's version of setorigin doesn't expand
        this.absmin -= '1 1 1';
        this.absmax += '1 1 1';
    #endif
    }

    if(touch_triggers)
        _Movetype_LinkEdict_TouchAreaGrid(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_LinkEdict_TouchAreaGrid()

void _Movetype_LinkEdict_TouchAreaGrid

(

entity

this

)

Definition at line 453 of file movetypes.qc.

References absmax, absmin, boxesoverlap(), entity(), if(), MOVE_NOMONSTERS, MOVE_WORLDONLY, solid, SOLID_NOT, SOLID_TRIGGER, trace_allsolid, trace_dphitcontents, trace_dphitq3surfaceflags, trace_dphittexturename, trace_dpstartcontents, trace_endpos, trace_ent, trace_fraction, trace_inopen, trace_inwater, trace_plane_dist, trace_plane_normal, trace_startsolid, vector(), and vlen().

Referenced by _Movetype_LinkEdict().

{
    if(this.solid == SOLID_NOT)
        return;

    // due to a lack of pointers in QC, we must save the trace values and restore them for other functions
    bool save_trace_allsolid = trace_allsolid;
    bool save_trace_startsolid = trace_startsolid;
    float save_trace_fraction = trace_fraction;
    bool save_trace_inwater = trace_inwater;
    bool save_trace_inopen = trace_inopen;
    vector save_trace_endpos = trace_endpos;
    vector save_trace_plane_normal = trace_plane_normal;
    float save_trace_plane_dist = trace_plane_dist;
    entity save_trace_ent = trace_ent;
    int save_trace_dpstartcontents = trace_dpstartcontents;
    int save_trace_dphitcontents = trace_dphitcontents;
    int save_trace_dphitq3surfaceflags = trace_dphitq3surfaceflags;
    string save_trace_dphittexturename = trace_dphittexturename;

    FOREACH_ENTITY_RADIUS_ORDERED(0.5 * (this.absmin + this.absmax), 0.5 * vlen(this.absmax - this.absmin), true, {
        if (it.solid == SOLID_TRIGGER && it != this)
        if (it.move_nomonsters != MOVE_NOMONSTERS && it.move_nomonsters != MOVE_WORLDONLY)
        if (gettouch(it) && boxesoverlap(it.absmin, it.absmax, this.absmin, this.absmax))
        {
            trace_allsolid = false;
            trace_startsolid = false;
            trace_fraction = 1;
            trace_inwater = false;
            trace_inopen = true;
            trace_endpos = it.origin;
            trace_plane_normal = '0 0 1';
            trace_plane_dist = 0;
            trace_ent = this;
            trace_dpstartcontents = 0;
            trace_dphitcontents = 0;
            trace_dphitq3surfaceflags = 0;
            trace_dphittexturename = string_null;

            gettouch(it)(it, this);
        }
    });

    trace_allsolid = save_trace_allsolid;
    trace_startsolid = save_trace_startsolid;
    trace_fraction = save_trace_fraction;
    trace_inwater = save_trace_inwater;
    trace_inopen = save_trace_inopen;
    trace_endpos = save_trace_endpos;
    trace_plane_normal = save_trace_plane_normal;
    trace_plane_dist = save_trace_plane_dist;
    trace_ent = save_trace_ent;
    trace_dpstartcontents = save_trace_dpstartcontents;
    trace_dphitcontents = save_trace_dphitcontents;
    trace_dphitq3surfaceflags = save_trace_dphitq3surfaceflags;
    trace_dphittexturename = save_trace_dphittexturename;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_NudgeOutOfSolid_PivotIsKnownGood()

bool _Movetype_NudgeOutOfSolid_PivotIsKnownGood	(	entity	this,
		vector	pivot
	)

Definition at line 23 of file movetypes.qc.

References dir, MOVE_NOMONSTERS, origin, SOLID_BSP, trace_endpos, trace_ent, trace_fraction, trace_plane_normal, trace_startsolid, and vector().

Referenced by _Movetype_PushMove().

{
    vector stuckorigin = this.origin;
    vector goodmins = pivot, goodmaxs = pivot;
    for(int bump = 0; bump < 6; bump++)
    {
        int coord = 2 - (bump >> 1);
        int dir = (bump & 1);

        for(int subbump = 0; ; ++subbump)
        {
            vector testorigin = stuckorigin;
            if(dir)
            {
                // pushing maxs
                switch(coord)
                {
                    case 0: testorigin.x += this.maxs_x - goodmaxs.x; break;
                    case 1: testorigin.y += this.maxs_y - goodmaxs.y; break;
                    case 2: testorigin.z += this.maxs_z - goodmaxs.z; break;
                }
            }
            else
            {
                // pushing mins
                switch(coord)
                {
                    case 0: testorigin.x += this.mins_x - goodmins.x; break;
                    case 1: testorigin.y += this.mins_y - goodmins.y; break;
                    case 2: testorigin.z += this.mins_z - goodmins.z; break;
                }
            }

            tracebox(stuckorigin, goodmins, goodmaxs, testorigin, MOVE_NOMONSTERS, this);
            if(trace_startsolid && trace_ent.solid == SOLID_BSP) // NOTE: this checks for bmodelstartsolid in the engine
            {
                // BAD BAD, can't fix that
                return false;
            }

            if(trace_fraction >= 1)
                break; // it WORKS!

            if(subbump >= 10)
            {
                // BAD BAD, can't fix that
                return false;
            }

            // we hit something... let's move out of it
            vector move = trace_endpos - testorigin;
            float nudge = (trace_plane_normal * move) + 0.03125; // FIXME cvar this constant
            stuckorigin = stuckorigin + nudge * trace_plane_normal;
        }

        if(dir)
        {
            // pushing maxs
            switch(coord)
            {
                case 0: goodmaxs.x = this.maxs_x; break;
                case 1: goodmaxs.y = this.maxs_y; break;
                case 2: goodmaxs.z = this.maxs_z; break;
            }
        }
        else
        {
            // pushing mins
            switch(coord)
            {
                case 0: goodmins.x = this.mins_x; break;
                case 1: goodmins.y = this.mins_y; break;
                case 2: goodmins.z = this.mins_z; break;
            }
        }
    }

    // WE WIN
    this.origin = stuckorigin;

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_Physics_ClientFrame()

void _Movetype_Physics_ClientFrame	(	entity	this,
		float	movedt
	)

Definition at line 763 of file movetypes.qc.

References _Movetype_CheckStuck(), _Movetype_CheckWater(), _Movetype_LinkEdict(), _Movetype_Physics_Follow(), _Movetype_Physics_Step(), _Movetype_Physics_Toss(), _Movetype_Physics_Walk(), angles, avelocity, GAMEPLAYFIX_UNSTICKPLAYERS, LOG_DEBUG, move_didgravity, move_movetype, MOVETYPE_BOUNCE, MOVETYPE_BOUNCEMISSILE, MOVETYPE_FAKEPUSH, MOVETYPE_FLY, MOVETYPE_FLY_WORLDONLY, MOVETYPE_FLYMISSILE, MOVETYPE_FOLLOW, MOVETYPE_NOCLIP, MOVETYPE_NONE, MOVETYPE_PHYSICS, MOVETYPE_PUSH, MOVETYPE_STEP, MOVETYPE_TOSS, MOVETYPE_WALK, origin, and velocity.

Referenced by Movetype_Physics_NoMatchTicrate().

{
    this.move_didgravity = -1;
    switch (this.move_movetype)
    {
        case MOVETYPE_PUSH:
        case MOVETYPE_FAKEPUSH:
            LOG_DEBUG("Physics: Lacking QuakeC support for Push movetype, FIX ME by using engine physics!");
            break;
        case MOVETYPE_NONE:
            break;
        case MOVETYPE_FOLLOW:
            _Movetype_Physics_Follow(this);
            break;
        case MOVETYPE_NOCLIP:
            _Movetype_CheckWater(this);
            this.origin = this.origin + movedt * this.velocity;
            this.angles = this.angles + movedt * this.avelocity;
            break;
        case MOVETYPE_STEP:
            if (GAMEPLAYFIX_UNSTICKPLAYERS(this) == 2)
                _Movetype_CheckStuck(this);
            _Movetype_Physics_Step(this, movedt);
            break;
        case MOVETYPE_WALK:
        case MOVETYPE_FLY:
        case MOVETYPE_FLY_WORLDONLY:
            if (movedt > 0 && GAMEPLAYFIX_UNSTICKPLAYERS(this) == 2)
                _Movetype_CheckStuck(this);
            _Movetype_Physics_Walk(this, movedt);
            break;
        case MOVETYPE_TOSS:
        case MOVETYPE_BOUNCE:
        case MOVETYPE_BOUNCEMISSILE:
        case MOVETYPE_FLYMISSILE:
            if (GAMEPLAYFIX_UNSTICKPLAYERS(this) == 2)
                _Movetype_CheckStuck(this);
            _Movetype_Physics_Toss(this, movedt);
            break;
        case MOVETYPE_PHYSICS:
            break;
    }

    //_Movetype_CheckVelocity(this);

    _Movetype_LinkEdict(this, true);

    //_Movetype_CheckVelocity(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_Physics_Frame()

void _Movetype_Physics_Frame	(	entity	this,
		float	movedt
	)

Definition at line 724 of file movetypes.qc.

References _Movetype_CheckWater(), _Movetype_LinkEdict(), _Movetype_Physics_Follow(), _Movetype_Physics_Push(), _Movetype_Physics_Step(), _Movetype_Physics_Toss(), _Movetype_Physics_Walk(), angles, avelocity, move_didgravity, move_movetype, MOVETYPE_BOUNCE, MOVETYPE_BOUNCEMISSILE, MOVETYPE_FAKEPUSH, MOVETYPE_FLY, MOVETYPE_FLY_WORLDONLY, MOVETYPE_FLYMISSILE, MOVETYPE_FOLLOW, MOVETYPE_NOCLIP, MOVETYPE_NONE, MOVETYPE_PHYSICS, MOVETYPE_PUSH, MOVETYPE_STEP, MOVETYPE_TOSS, MOVETYPE_WALK, origin, and velocity.

Referenced by Movetype_Physics_MatchTicrate(), Movetype_Physics_NoMatchServer(), and Movetype_Physics_NoMatchTicrate().

{
    this.move_didgravity = -1;
    switch (this.move_movetype)
    {
        case MOVETYPE_PUSH:
        case MOVETYPE_FAKEPUSH:
            _Movetype_Physics_Push(this, movedt);
            break;
        case MOVETYPE_NONE:
            break;
        case MOVETYPE_FOLLOW:
            _Movetype_Physics_Follow(this);
            break;
        case MOVETYPE_NOCLIP:
            _Movetype_CheckWater(this);
            this.origin = this.origin + movedt * this.velocity;
            this.angles = this.angles + movedt * this.avelocity;
            _Movetype_LinkEdict(this, false);
            break;
        case MOVETYPE_STEP:
            _Movetype_Physics_Step(this, movedt);
            break;
        case MOVETYPE_WALK:
            _Movetype_Physics_Walk(this, movedt);
            break;
        case MOVETYPE_TOSS:
        case MOVETYPE_BOUNCE:
        case MOVETYPE_BOUNCEMISSILE:
        case MOVETYPE_FLYMISSILE:
        case MOVETYPE_FLY:
        case MOVETYPE_FLY_WORLDONLY:
            _Movetype_Physics_Toss(this, movedt);
            break;
        case MOVETYPE_PHYSICS:
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_PushEntity()

bool _Movetype_PushEntity	(	entity	this,
		vector	push,
		bool	failonstartsolid,
		bool	dolink
	)

Definition at line 697 of file movetypes.qc.

References _Movetype_Impact(), _Movetype_LinkEdict(), _Movetype_PushEntityTrace(), groundentity, IS_ONGROUND, move_nomonsters, MOVE_WORLDONLY, origin, solid, SOLID_TRIGGER, trace_endpos, trace_ent, trace_fraction, trace_startsolid, and vector().

Referenced by _Movetype_FlyMove(), _Movetype_Physics_Toss(), _Movetype_Physics_Walk(), and _Movetype_PushMove().

{
    _Movetype_PushEntityTrace(this, push);

    // NOTE: this is a workaround for the QC's lack of a worldstartsolid trace parameter
    if(trace_startsolid && failonstartsolid)
    {
        int oldtype = this.move_nomonsters;
        this.move_nomonsters = MOVE_WORLDONLY;
        _Movetype_PushEntityTrace(this, push);
        this.move_nomonsters = oldtype;
        if(trace_startsolid)
            return true;
    }

    this.origin = trace_endpos;

    vector last_origin = this.origin;

    _Movetype_LinkEdict(this, dolink);

    if((this.solid >= SOLID_TRIGGER && trace_fraction < 1 && (!IS_ONGROUND(this) || this.groundentity != trace_ent)))
        _Movetype_Impact(this, trace_ent);

    return (this.origin == last_origin); // false if teleported by touch
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_PushEntityTrace()

void _Movetype_PushEntityTrace	(	entity	this,
		vector	push
	)

Definition at line 679 of file movetypes.qc.

References max(), maxs, mins, MOVE_MISSILE, move_movetype, move_nomonsters, MOVE_NOMONSTERS, MOVE_NORMAL, MOVE_WORLDONLY, MOVETYPE_FLY_WORLDONLY, MOVETYPE_FLYMISSILE, origin, solid, SOLID_NOT, SOLID_TRIGGER, and vector().

Referenced by _Movetype_PushEntity(), and Movetype_Physics_MatchTicrate().

{
    vector end = this.origin + push;
    int type;
    if(this.move_nomonsters)
        type = max(0, this.move_nomonsters);
    else if(this.move_movetype == MOVETYPE_FLYMISSILE)
        type = MOVE_MISSILE;
    else if(this.move_movetype == MOVETYPE_FLY_WORLDONLY)
        type = MOVE_WORLDONLY;
    else if(this.solid == SOLID_TRIGGER || this.solid == SOLID_NOT)
        type = MOVE_NOMONSTERS;
    else
        type = MOVE_NORMAL;

    tracebox(this.origin, this.mins, this.maxs, end, type, this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_TestEntityPosition()

bool _Movetype_TestEntityPosition

(

vector

ofs

)

Definition at line 584 of file movetypes.qc.

References _Movetype_ContentsMask(), _Movetype_TestEntityPosition_ent, entity(), maxs, mins, move_movetype, MOVE_NOMONSTERS, MOVE_WORLDONLY, MOVETYPE_FLY_WORLDONLY, origin, trace_dpstartcontents, trace_endpos, trace_startsolid, vector(), and vlen2.

Referenced by _Movetype_CheckStuck(), _Movetype_TestEntityPosition_Offset(), and _Movetype_UnstickEntity().

{
    entity this = _Movetype_TestEntityPosition_ent;
    vector org = this.origin + ofs;

    //int cont = this.dphitcontentsmask;
    //this.dphitcontentsmask = DPCONTENTS_SOLID;
    tracebox(org, this.mins, this.maxs, this.origin, ((this.move_movetype == MOVETYPE_FLY_WORLDONLY) ? MOVE_WORLDONLY : MOVE_NOMONSTERS), this);
    //this.dphitcontentsmask = cont;
    if(trace_dpstartcontents & _Movetype_ContentsMask(this))
        return true;

    if(vlen2(trace_endpos - this.origin) >= 0.0001)
    {
        tracebox(trace_endpos, this.mins, this.maxs, trace_endpos, MOVE_NOMONSTERS, this);
        if(!trace_startsolid)
            this.origin = trace_endpos;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_TestEntityPosition_Offset()

bool _Movetype_TestEntityPosition_Offset

(

int

offset

)

Definition at line 605 of file movetypes.qc.

References _Movetype_TestEntityPosition().

Referenced by _Movetype_UnstickEntity().

{
    // NOTE: expects _Movetype_TestEntityPosition_ent to be set to the correct entity
    // returns true if stuck

    // start at 2, since the first position has already been checked
    for(int j = 2; j <= offset; ++j)
    {
        if(!_Movetype_TestEntityPosition('0 0 -1' * j))
            return false;
        if(!_Movetype_TestEntityPosition('0 0 1' * j))
            return false;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_UnstickEntity()

int _Movetype_UnstickEntity

(

entity

this

)

Definition at line 622 of file movetypes.qc.

References _Movetype_LinkEdict(), _Movetype_TestEntityPosition(), _Movetype_TestEntityPosition_Offset(), classname, etof(), LOG_DEBUGF, maxs, origin, rint(), UNSTICK_FINE, UNSTICK_FIXED, UNSTICK_STUCK, vtos(), and X.

Referenced by _Movetype_CheckStuck(), and _Movetype_Physics_Toss().

{
    _Movetype_TestEntityPosition_ent = this;
    if (!_Movetype_TestEntityPosition(' 0  0  0')) {
        return UNSTICK_FINE;
    }
    #define X(v) if (_Movetype_TestEntityPosition(v))
    X('0  0  -1') X(' 0  0  1')
    X('-1  0  0') X(' 1  0  0')
    X(' 0 -1  0') X(' 0  1  0')
    X('-1 -1  0') X(' 1 -1  0')
    X('-1  1  0') X(' 1  1  0')
    #undef X
    {
        if(_Movetype_TestEntityPosition_Offset(rint((this.maxs.z - this.mins.z) * 0.36)))
        {
            LOG_DEBUGF("Can't unstick an entity (edict: %d, classname: %s, origin: %s)",
                etof(this), this.classname, vtos(this.origin));
            return UNSTICK_STUCK;
        }
    }
    LOG_DEBUGF("Sucessfully unstuck an entity (edict: %d, classname: %s, origin: %s)",
        etof(this), this.classname, vtos(this.origin));
    _Movetype_LinkEdict(this, false);
    return UNSTICK_FIXED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Movetype_WallFriction()

void _Movetype_WallFriction	(	entity	this,
		vector	stepnormal
	)

Definition at line 106 of file movetypes.qc.

Referenced by _Movetype_Physics_Walk().

{
    /*float d, i;
    vector into, side;
    makevectors(this.v_angle);
    d = (stepnormal * v_forward) + 0.5;

    if(d < 0)
    {
        i = (stepnormal * this.velocity);
        into = i * stepnormal;
        side = this.velocity - into;
        this.velocity_x = side.x * (1 * d);
        this.velocity_y = side.y * (1 * d);
    }*/
}

Here is the caller graph for this function:

Movetype_Physics_MatchServer()

void Movetype_Physics_MatchServer	(	entity	this,
		bool	sloppy
	)

Definition at line 851 of file movetypes.qc.

References Movetype_Physics_MatchTicrate().

Referenced by ItemDraw(), Projectile_Draw(), and train_next().

{
    Movetype_Physics_MatchTicrate(this, TICRATE, sloppy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Movetype_Physics_MatchTicrate()

void Movetype_Physics_MatchTicrate	(	entity	this,
		float	tr,
		bool	sloppy
	)

Definition at line 869 of file movetypes.qc.

References _Movetype_Physics_Frame(), _Movetype_PushEntityTrace(), angles, avelocity, bound(), FL_ONGROUND, flags, floor(), gravity, move_didgravity, move_movetype, move_time, MOVETYPE_BOUNCE, MOVETYPE_NOCLIP, MOVETYPE_NONE, Movetype_Physics_NoMatchServer(), MOVETYPE_TOSS, origin, setorigin(), tic_angles, tic_avelocity, tic_flags, tic_origin, tic_saved_angles, tic_saved_avelocity, tic_saved_flags, tic_saved_origin, tic_saved_velocity, tic_velocity, time, trace_endpos, trace_startsolid, velocity, and X.

Referenced by Movetype_Physics_MatchServer(), and turret_gib_draw().

{
    // this hack exists to contain the physics feature
    // (so entities can place themselves in the world and not need to update .tic_* themselves)
#define X(s) \
    if(this.(s) != this.tic_saved_##s) \
        this.tic_##s = this.(s)

    X(origin);
    X(velocity);
    X(flags);
    X(avelocity);
    X(angles);
#undef X

    this.flags = this.tic_flags;
    this.velocity = this.tic_velocity;
    setorigin(this, this.tic_origin);
    this.avelocity = this.tic_avelocity;
    this.angles = this.tic_angles;

    if(tr <= 0)
    {
        Movetype_Physics_NoMatchServer(this);

        this.tic_saved_flags = this.tic_flags = this.flags;
        this.tic_saved_velocity = this.tic_velocity = this.velocity;
        this.tic_saved_origin = this.tic_origin = this.origin;
        this.tic_saved_avelocity = this.tic_avelocity = this.avelocity;
        this.tic_saved_angles = this.tic_angles = this.angles;
        return;
    }

    float dt = time - this.move_time;

    int n = bound(0, floor(dt / tr), 32); // limit the number of frames to 32 (CL_MAX_USERCMDS, using DP_SMALLMEMORY value for consideration of QC's limitations)
    dt -= n * tr;
    this.move_time += n * tr;

    if(!this.move_didgravity)
        this.move_didgravity = ((this.move_movetype == MOVETYPE_BOUNCE || this.move_movetype == MOVETYPE_TOSS) && !(this.tic_flags & FL_ONGROUND));

    for (int j = 0; j < n; ++j)
    {
        _Movetype_Physics_Frame(this, tr);
        if(wasfreed(this))
            return;
    }

    // update the physics fields
    this.tic_origin = this.origin;
    this.tic_velocity = this.velocity;
    this.tic_avelocity = this.avelocity;
    this.tic_angles = this.angles;
    this.tic_flags = this.flags;

    // restore their actual values
    this.flags = this.tic_saved_flags;
    this.velocity = this.tic_saved_velocity;
    setorigin(this, this.tic_saved_origin);
    //this.avelocity = this.tic_saved_avelocity;
    this.angles = this.tic_saved_angles;

    this.avelocity = this.tic_avelocity;

    if(dt > 0 && this.move_movetype != MOVETYPE_NONE && !(this.tic_flags & FL_ONGROUND))
    {
        // now continue the move from move_time to time
        this.velocity = this.tic_velocity;

        if(this.move_didgravity > 0)
        {
            this.velocity_z -= (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE ? 0.5 : 1)
                * dt
                * ((this.gravity) ? this.gravity : 1)
                * PHYS_GRAVITY(this);
        }

        this.angles = this.tic_angles + dt * this.avelocity;

        if(sloppy || this.move_movetype == MOVETYPE_NOCLIP)
        {
            setorigin(this, this.tic_origin + dt * this.velocity);
        }
        else
        {
            setorigin(this, this.tic_origin);
            _Movetype_PushEntityTrace(this, dt * this.velocity);
            if(!trace_startsolid)
                setorigin(this, trace_endpos);
            else
                setorigin(this, this.tic_saved_origin);
        }

        if(this.move_didgravity > 0 && GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
            this.velocity_z -= 0.5 * dt * ((this.gravity) ? this.gravity : 1) * PHYS_GRAVITY(this);
    }
    else
    {
        this.velocity = this.tic_velocity;
        this.angles = this.tic_angles;
        setorigin(this, this.tic_origin);
    }

    this.flags = this.tic_flags;

    this.tic_saved_flags = this.flags;
    this.tic_saved_velocity = this.velocity;
    this.tic_saved_origin = this.origin;
    this.tic_saved_avelocity = this.avelocity;
    this.tic_saved_angles = this.angles;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Movetype_Physics_NoMatchServer()

void Movetype_Physics_NoMatchServer

(

entity

this

)

Definition at line 839 of file movetypes.qc.

References _Movetype_Physics_Frame(), move_time, origin, setorigin(), and time.

Referenced by Movetype_Physics_MatchTicrate(), and Projectile_Draw().

{
    float movedt = time - this.move_time;
    this.move_time = time;

    _Movetype_Physics_Frame(this, movedt);
    if(wasfreed(this))
        return;

    setorigin(this, this.origin);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Movetype_Physics_NoMatchTicrate()

void Movetype_Physics_NoMatchTicrate	(	entity	this,
		float	movedt,
		bool	isclient
	)

Definition at line 813 of file movetypes.qc.

References _Movetype_Physics_ClientFrame(), _Movetype_Physics_Frame(), GAMEPLAYFIX_DELAYPROJECTILES, move_time, origin, setorigin(), and time.

Referenced by CSQCPlayer_Physics(), Physics_Frame(), and Player_Physics().

{
    bool didmove = (this.move_time != 0);
    this.move_time = time;

    if(isclient)
        _Movetype_Physics_ClientFrame(this, movedt);
    else
    {
        // this doesn't apply to clients, and only applies to unmatched entities
        // don't run think/move on newly spawned projectiles as it messes up
        // movement interpolation and rocket trails, and is inconsistent with
        // respect to entities spawned in the same frame
        // (if an ent spawns a higher numbered ent, it moves in the same frame,
        //  but if it spawns a lower numbered ent, it doesn't - this never moves
        //  ents in the first frame regardless)
        if(!didmove && GAMEPLAYFIX_DELAYPROJECTILES(this) > 0)
            return;
        _Movetype_Physics_Frame(this, movedt);
    }
    if(wasfreed(this))
        return;

    setorigin(this, this.origin);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_Movetype_TestEntityPosition_ent

entity _Movetype_TestEntityPosition_ent

Definition at line 583 of file movetypes.qc.

Referenced by _Movetype_TestEntityPosition().

autocvar__movetype_debug

bool autocvar__movetype_debug = false

Definition at line 511 of file movetypes.qc.

planes

vector planes[MAX_CLIP_PLANES]

Definition at line 123 of file movetypes.qc.

tic_angles

vector tic_angles

Definition at line 861 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_avelocity

vector tic_avelocity

Definition at line 860 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_flags

int tic_flags

Definition at line 859 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_origin

vector tic_origin

Definition at line 857 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_saved_angles

vector tic_saved_angles

Definition at line 868 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_saved_avelocity

vector tic_saved_avelocity

Definition at line 867 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_saved_flags

int tic_saved_flags

Definition at line 866 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_saved_origin

vector tic_saved_origin

Definition at line 864 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_saved_velocity

vector tic_saved_velocity

Definition at line 865 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().

tic_velocity

vector tic_velocity

Definition at line 858 of file movetypes.qc.

Referenced by Movetype_Physics_MatchTicrate().