1268 lines
31 KiB
C
1268 lines
31 KiB
C
/*
|
|
Copyright (C) 1996-2001 Id Software, Inc.
|
|
Copyright (C) 2002-2009 John Fitzgibbons and others
|
|
Copyright (C) 2010-2014 QuakeSpasm developers
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
// sv_phys.c
|
|
|
|
#include "q_defs.h"
|
|
|
|
/*
|
|
|
|
|
|
pushmove objects do not obey gravity, and do not interact with each other or trigger, but block normal movement and push normal objects when they move.
|
|
|
|
onground is set for toss objects when they come to a complete rest. it is set for steping or walking objects
|
|
|
|
doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
|
|
bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
|
|
corpses are SOLID_NOT and MOVETYPE_TOSS
|
|
crates are SOLID_BBOX and MOVETYPE_TOSS
|
|
walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP
|
|
flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY
|
|
|
|
solid_edge items only clip against bsp models.
|
|
|
|
*/
|
|
|
|
cvar_t sv_friction = {"sv_friction", "4", CVAR_NOTIFY | CVAR_SERVERINFO};
|
|
cvar_t sv_stopspeed = {"sv_stopspeed", "100", CVAR_NONE};
|
|
cvar_t sv_gravity = {"sv_gravity", "800", CVAR_NOTIFY | CVAR_SERVERINFO};
|
|
cvar_t sv_maxvelocity = {"sv_maxvelocity", "2000", CVAR_NONE};
|
|
cvar_t sv_nostep = {"sv_nostep", "0", CVAR_NONE};
|
|
cvar_t sv_freezenonclients = {"sv_freezenonclients", "0", CVAR_NONE};
|
|
|
|
|
|
#define MOVE_EPSILON 0.01
|
|
|
|
void SV_Physics_Toss(edict_t *ent);
|
|
|
|
/*
|
|
================
|
|
SV_CheckAllEnts
|
|
================
|
|
*/
|
|
void SV_CheckAllEnts(void)
|
|
{
|
|
int32_t e;
|
|
edict_t *check;
|
|
|
|
// see if any solid entities are inside the final position
|
|
check = NextEdict(sv.edicts);
|
|
for(e = 1 ; e < sv.num_edicts ; e++, check = NextEdict(check))
|
|
{
|
|
if(check->free)
|
|
continue;
|
|
if(ED_Float(check, ED_movetype) == MOVETYPE_PUSH
|
|
|| ED_Float(check, ED_movetype) == MOVETYPE_NONE
|
|
|| ED_Float(check, ED_movetype) == MOVETYPE_NOCLIP)
|
|
continue;
|
|
|
|
if(SV_TestEntityPosition(check))
|
|
Con_Printf("entity in invalid position\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_CheckVelocity
|
|
================
|
|
*/
|
|
void SV_CheckVelocity(edict_t *ent)
|
|
{
|
|
int32_t i;
|
|
|
|
//
|
|
// bound velocity
|
|
//
|
|
for(i = 0 ; i < 3 ; i++)
|
|
{
|
|
if(isnan(ED_Vector(ent, ED_velocity)[i]))
|
|
{
|
|
Con_Printf("Got a NaN velocity on %s\n", ED_String(ent, ED_classname));
|
|
ED_Vector(ent, ED_velocity)[i] = 0;
|
|
}
|
|
if(isnan(ED_Vector(ent, ED_origin)[i]))
|
|
{
|
|
Con_Printf("Got a NaN origin on %s\n", ED_String(ent, ED_classname));
|
|
ED_Vector(ent, ED_origin)[i] = 0;
|
|
}
|
|
if(ED_Vector(ent, ED_velocity)[i] > sv_maxvelocity.value)
|
|
ED_Vector(ent, ED_velocity)[i] = sv_maxvelocity.value;
|
|
else if(ED_Vector(ent, ED_velocity)[i] < -sv_maxvelocity.value)
|
|
ED_Vector(ent, ED_velocity)[i] = -sv_maxvelocity.value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
SV_RunThink
|
|
|
|
Runs thinking code if time. There is some play in the exact time the think
|
|
function will be called, because it is called before any movement is done
|
|
in a frame. Not used for pushmove objects, because they must be exact.
|
|
Returns false if the entity removed itself.
|
|
=============
|
|
*/
|
|
bool SV_RunThink(edict_t *ent)
|
|
{
|
|
float thinktime;
|
|
float oldframe; //johnfitz
|
|
int32_t i; //johnfitz
|
|
|
|
thinktime = ED_Float(ent, ED_nextthink);
|
|
if(thinktime <= 0 || thinktime > sv.time + host_frametime)
|
|
return true;
|
|
|
|
if(thinktime < sv.time)
|
|
thinktime = sv.time; // don't let things stay in the past.
|
|
// it is possible to start that way
|
|
// by a trigger with a local time.
|
|
|
|
oldframe = ED_Float(ent, ED_frame); //johnfitz
|
|
|
|
ED_Float(ent, ED_nextthink) = 0;
|
|
G_Float(GBL_time) = thinktime;
|
|
G_PEdict(GBL_self) = EdictProg(ent);
|
|
G_PEdict(GBL_other) = EdictProg(sv.edicts);
|
|
PR_ExecuteProgram(ED_Func(ent, ED_think));
|
|
|
|
//johnfitz -- PROTOCOL_FITZQUAKE
|
|
//capture interval to nextthink here and send it to client for better
|
|
//lerp timing, but only if interval is not 0.1 (which client assumes)
|
|
ent->sendinterval = false;
|
|
if(!ent->free && ED_Float(ent, ED_nextthink) && (ED_Float(ent, ED_movetype) == MOVETYPE_STEP || ED_Float(ent, ED_frame) != oldframe))
|
|
{
|
|
i = Q_rint((ED_Float(ent, ED_nextthink) - thinktime) * 255);
|
|
if(i >= 0 && i < 256 && i != 25 && i != 26) //25 and 26 are close enough to 0.1 to not send
|
|
ent->sendinterval = true;
|
|
}
|
|
//johnfitz
|
|
|
|
return !ent->free;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
SV_Impact
|
|
|
|
Two entities have touched, so run their touch functions
|
|
==================
|
|
*/
|
|
void SV_Impact(edict_t *e1, edict_t *e2)
|
|
{
|
|
pedict_t old_self, old_other;
|
|
|
|
old_self = G_PEdict(GBL_self);
|
|
old_other = G_PEdict(GBL_other);
|
|
|
|
G_Float(GBL_time) = sv.time;
|
|
if(ED_Func(e1, ED_touch) && ED_Float(e1, ED_solid) != SOLID_NOT)
|
|
{
|
|
G_PEdict(GBL_self) = EdictProg(e1);
|
|
G_PEdict(GBL_other) = EdictProg(e2);
|
|
PR_ExecuteProgram(ED_Func(e1, ED_touch));
|
|
}
|
|
|
|
if(ED_Func(e2, ED_touch) && ED_Float(e2, ED_solid) != SOLID_NOT)
|
|
{
|
|
G_PEdict(GBL_self) = EdictProg(e2);
|
|
G_PEdict(GBL_other) = EdictProg(e1);
|
|
PR_ExecuteProgram(ED_Func(e2, ED_touch));
|
|
}
|
|
|
|
G_PEdict(GBL_self) = old_self;
|
|
G_PEdict(GBL_other) = old_other;
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
ClipVelocity
|
|
|
|
Slide off of the impacting object
|
|
returns the blocked flags (1 = floor, 2 = step / wall)
|
|
==================
|
|
*/
|
|
#define STOP_EPSILON 0.1
|
|
|
|
int32_t ClipVelocity(vec3_t in, vec3_t normal, vec3_t out, float overbounce)
|
|
{
|
|
float backoff;
|
|
float change;
|
|
int32_t i, blocked;
|
|
|
|
blocked = 0;
|
|
if(normal[2] > 0)
|
|
blocked |= 1; // floor
|
|
if(!normal[2])
|
|
blocked |= 2; // step
|
|
|
|
backoff = DotProduct(in, normal) * overbounce;
|
|
|
|
for(i = 0 ; i < 3 ; i++)
|
|
{
|
|
change = normal[i] * backoff;
|
|
out[i] = in[i] - change;
|
|
if(out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
|
|
out[i] = 0;
|
|
}
|
|
|
|
return blocked;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
SV_FlyMove
|
|
|
|
The basic solid body movement clip that slides along multiple planes
|
|
Returns the clipflags if the velocity was modified (hit something solid)
|
|
1 = floor
|
|
2 = wall / step
|
|
4 = dead stop
|
|
If steptrace is not NULL, the trace of any vertical wall hit will be stored
|
|
============
|
|
*/
|
|
#define MAX_CLIP_PLANES 5
|
|
int32_t SV_FlyMove(edict_t *ent, float time, trace_t *steptrace)
|
|
{
|
|
int32_t bumpcount, numbumps;
|
|
vec3_t dir;
|
|
float d;
|
|
int32_t numplanes;
|
|
vec3_t planes[MAX_CLIP_PLANES];
|
|
vec3_t primal_velocity, original_velocity, new_velocity;
|
|
int32_t i, j;
|
|
trace_t trace;
|
|
vec3_t end;
|
|
float time_left;
|
|
int32_t blocked;
|
|
|
|
numbumps = 4;
|
|
|
|
blocked = 0;
|
|
VectorCopy(ED_Vector(ent, ED_velocity), original_velocity);
|
|
VectorCopy(ED_Vector(ent, ED_velocity), primal_velocity);
|
|
numplanes = 0;
|
|
|
|
time_left = time;
|
|
|
|
for(bumpcount = 0 ; bumpcount < numbumps ; bumpcount++)
|
|
{
|
|
if(!ED_Vector(ent, ED_velocity)[0] && !ED_Vector(ent, ED_velocity)[1] && !ED_Vector(ent, ED_velocity)[2])
|
|
break;
|
|
|
|
for(i = 0 ; i < 3 ; i++)
|
|
end[i] = ED_Vector(ent, ED_origin)[i] + time_left * ED_Vector(ent, ED_velocity)[i];
|
|
|
|
trace = SV_Move(ED_Vector(ent, ED_origin), ED_Vector(ent, ED_mins), ED_Vector(ent, ED_maxs), end, false, ent);
|
|
|
|
if(trace.allsolid)
|
|
{
|
|
// entity is trapped in another solid
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_velocity));
|
|
return 3;
|
|
}
|
|
|
|
if(trace.fraction > 0)
|
|
{
|
|
// actually covered some distance
|
|
VectorCopy(trace.endpos, ED_Vector(ent, ED_origin));
|
|
VectorCopy(ED_Vector(ent, ED_velocity), original_velocity);
|
|
numplanes = 0;
|
|
}
|
|
|
|
if(trace.fraction == 1)
|
|
break; // moved the entire distance
|
|
|
|
if(!trace.ent)
|
|
Sys_Error("SV_FlyMove: !trace.ent");
|
|
|
|
if(trace.plane.normal[2] > 0.7)
|
|
{
|
|
blocked |= 1; // floor
|
|
if(ED_Float(trace.ent, ED_solid) == SOLID_BSP)
|
|
{
|
|
ED_Float(ent, ED_flags) = (int32_t)ED_Float(ent, ED_flags) | FL_ONGROUND;
|
|
ED_PEdict(ent, ED_groundentity) = EdictProg(trace.ent);
|
|
}
|
|
}
|
|
if(!trace.plane.normal[2])
|
|
{
|
|
blocked |= 2; // step
|
|
if(steptrace)
|
|
*steptrace = trace; // save for player extrafriction
|
|
}
|
|
|
|
//
|
|
// run the impact function
|
|
//
|
|
SV_Impact(ent, trace.ent);
|
|
if(ent->free)
|
|
break; // removed by the impact function
|
|
|
|
|
|
time_left -= time_left * trace.fraction;
|
|
|
|
// cliped to another plane
|
|
if(numplanes >= MAX_CLIP_PLANES)
|
|
{
|
|
// this shouldn't really happen
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_velocity));
|
|
return 3;
|
|
}
|
|
|
|
VectorCopy(trace.plane.normal, planes[numplanes]);
|
|
numplanes++;
|
|
|
|
//
|
|
// modify original_velocity so it parallels all of the clip planes
|
|
//
|
|
for(i = 0 ; i < numplanes ; i++)
|
|
{
|
|
ClipVelocity(original_velocity, planes[i], new_velocity, 1);
|
|
for(j = 0 ; j < numplanes ; j++)
|
|
if(j != i)
|
|
{
|
|
if(DotProduct(new_velocity, planes[j]) < 0)
|
|
break; // not ok
|
|
}
|
|
if(j == numplanes)
|
|
break;
|
|
}
|
|
|
|
if(i != numplanes)
|
|
{
|
|
// go along this plane
|
|
VectorCopy(new_velocity, ED_Vector(ent, ED_velocity));
|
|
}
|
|
else
|
|
{
|
|
// go along the crease
|
|
if(numplanes != 2)
|
|
{
|
|
// Con_Printf ("clip velocity, numplanes == %" PRIi32 "\n",numplanes);
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_velocity));
|
|
return 7;
|
|
}
|
|
CrossProduct(planes[0], planes[1], dir);
|
|
d = DotProduct(dir, ED_Vector(ent, ED_velocity));
|
|
VectorScale(dir, d, ED_Vector(ent, ED_velocity));
|
|
}
|
|
|
|
//
|
|
// if original velocity is against the original velocity, stop dead
|
|
// to avoid tiny occilations in sloping corners
|
|
//
|
|
if(DotProduct(ED_Vector(ent, ED_velocity), primal_velocity) <= 0)
|
|
{
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_velocity));
|
|
return blocked;
|
|
}
|
|
}
|
|
|
|
return blocked;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
SV_AddGravity
|
|
|
|
============
|
|
*/
|
|
void SV_AddGravity(edict_t *ent)
|
|
{
|
|
float ent_gravity;
|
|
eval_t *val;
|
|
|
|
val = GetEdictFieldValue(ent, "gravity");
|
|
if(val && val->flt)
|
|
ent_gravity = val->flt;
|
|
else
|
|
ent_gravity = 1.0;
|
|
|
|
ED_Vector(ent, ED_velocity)[2] -= ent_gravity * sv_gravity.value * host_frametime;
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
PUSHMOVE
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
============
|
|
SV_PushEntity
|
|
|
|
Does not change the entities velocity at all
|
|
============
|
|
*/
|
|
trace_t SV_PushEntity(edict_t *ent, vec3_t push)
|
|
{
|
|
trace_t trace;
|
|
vec3_t end;
|
|
|
|
VectorAdd(ED_Vector(ent, ED_origin), push, end);
|
|
|
|
if(ED_Float(ent, ED_movetype) == MOVETYPE_FLYMISSILE)
|
|
trace = SV_Move(ED_Vector(ent, ED_origin), ED_Vector(ent, ED_mins), ED_Vector(ent, ED_maxs), end, MOVE_MISSILE, ent);
|
|
else if(ED_Float(ent, ED_solid) == SOLID_TRIGGER || ED_Float(ent, ED_solid) == SOLID_NOT)
|
|
// only clip against bmodels
|
|
trace = SV_Move(ED_Vector(ent, ED_origin), ED_Vector(ent, ED_mins), ED_Vector(ent, ED_maxs), end, MOVE_NOMONSTERS, ent);
|
|
else
|
|
trace = SV_Move(ED_Vector(ent, ED_origin), ED_Vector(ent, ED_mins), ED_Vector(ent, ED_maxs), end, MOVE_NORMAL, ent);
|
|
|
|
VectorCopy(trace.endpos, ED_Vector(ent, ED_origin));
|
|
SV_LinkEdict(ent, true);
|
|
|
|
if(trace.ent)
|
|
SV_Impact(ent, trace.ent);
|
|
|
|
return trace;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
SV_PushMove
|
|
============
|
|
*/
|
|
void SV_PushMove(edict_t *pusher, float movetime)
|
|
{
|
|
int32_t i, e;
|
|
edict_t *check, *block;
|
|
vec3_t mins, maxs, move;
|
|
vec3_t entorig, pushorig;
|
|
int32_t num_moved;
|
|
edict_t **moved_edict; //johnfitz -- dynamically allocate
|
|
vec3_t *moved_from; //johnfitz -- dynamically allocate
|
|
int32_t mark; //johnfitz
|
|
|
|
if(!ED_Vector(pusher, ED_velocity)[0] && !ED_Vector(pusher, ED_velocity)[1] && !ED_Vector(pusher, ED_velocity)[2])
|
|
{
|
|
ED_Float(pusher, ED_ltime) += movetime;
|
|
return;
|
|
}
|
|
|
|
for(i = 0 ; i < 3 ; i++)
|
|
{
|
|
move[i] = ED_Vector(pusher, ED_velocity)[i] * movetime;
|
|
mins[i] = ED_Vector(pusher, ED_absmin)[i] + move[i];
|
|
maxs[i] = ED_Vector(pusher, ED_absmax)[i] + move[i];
|
|
}
|
|
|
|
VectorCopy(ED_Vector(pusher, ED_origin), pushorig);
|
|
|
|
// move the pusher to it's final position
|
|
|
|
VectorAdd(ED_Vector(pusher, ED_origin), move, ED_Vector(pusher, ED_origin));
|
|
ED_Float(pusher, ED_ltime) += movetime;
|
|
SV_LinkEdict(pusher, false);
|
|
|
|
//johnfitz -- dynamically allocate
|
|
mark = Hunk_LowMark();
|
|
moved_edict = Hunk_AllocName(sv.num_edicts * sizeof(edict_t *), "moved_edict");
|
|
moved_from = Hunk_AllocName(sv.num_edicts * sizeof(vec3_t), "moved_from");
|
|
//johnfitz
|
|
|
|
// see if any solid entities are inside the final position
|
|
num_moved = 0;
|
|
check = NextEdict(sv.edicts);
|
|
for(e = 1 ; e < sv.num_edicts ; e++, check = NextEdict(check))
|
|
{
|
|
if(check->free)
|
|
continue;
|
|
if(ED_Float(check, ED_movetype) == MOVETYPE_PUSH
|
|
|| ED_Float(check, ED_movetype) == MOVETYPE_NONE
|
|
|| ED_Float(check, ED_movetype) == MOVETYPE_NOCLIP)
|
|
continue;
|
|
|
|
// if the entity is standing on the pusher, it will definately be moved
|
|
if(!(((int32_t)ED_Float(check, ED_flags) & FL_ONGROUND)
|
|
&& ProgEdict(ED_PEdict(check, ED_groundentity)) == pusher))
|
|
{
|
|
if(ED_Vector(check, ED_absmin)[0] >= maxs[0]
|
|
|| ED_Vector(check, ED_absmin)[1] >= maxs[1]
|
|
|| ED_Vector(check, ED_absmin)[2] >= maxs[2]
|
|
|| ED_Vector(check, ED_absmax)[0] <= mins[0]
|
|
|| ED_Vector(check, ED_absmax)[1] <= mins[1]
|
|
|| ED_Vector(check, ED_absmax)[2] <= mins[2])
|
|
continue;
|
|
|
|
// see if the ent's bbox is inside the pusher's final position
|
|
if(!SV_TestEntityPosition(check))
|
|
continue;
|
|
}
|
|
|
|
// remove the onground flag for non-players
|
|
if(ED_Float(check, ED_movetype) != MOVETYPE_WALK)
|
|
ED_Float(check, ED_flags) = (int32_t)ED_Float(check, ED_flags) & ~FL_ONGROUND;
|
|
|
|
VectorCopy(ED_Vector(check, ED_origin), entorig);
|
|
VectorCopy(ED_Vector(check, ED_origin), moved_from[num_moved]);
|
|
moved_edict[num_moved] = check;
|
|
num_moved++;
|
|
|
|
// try moving the contacted entity
|
|
ED_Float(pusher, ED_solid) = SOLID_NOT;
|
|
SV_PushEntity(check, move);
|
|
ED_Float(pusher, ED_solid) = SOLID_BSP;
|
|
|
|
// if it is still inside the pusher, block
|
|
block = SV_TestEntityPosition(check);
|
|
if(block)
|
|
{
|
|
// fail the move
|
|
if(ED_Vector(check, ED_mins)[0] == ED_Vector(check, ED_maxs)[0])
|
|
continue;
|
|
if(ED_Float(check, ED_solid) == SOLID_NOT || ED_Float(check, ED_solid) == SOLID_TRIGGER)
|
|
{
|
|
// corpse
|
|
ED_Vector(check, ED_mins)[0] = ED_Vector(check, ED_mins)[1] = 0;
|
|
VectorCopy(ED_Vector(check, ED_mins), ED_Vector(check, ED_maxs));
|
|
continue;
|
|
}
|
|
|
|
VectorCopy(entorig, ED_Vector(check, ED_origin));
|
|
SV_LinkEdict(check, true);
|
|
|
|
VectorCopy(pushorig, ED_Vector(pusher, ED_origin));
|
|
SV_LinkEdict(pusher, false);
|
|
ED_Float(pusher, ED_ltime) -= movetime;
|
|
|
|
// if the pusher has a "blocked" function, call it
|
|
// otherwise, just stay in place until the obstacle is gone
|
|
if(ED_Func(pusher, ED_blocked))
|
|
{
|
|
G_PEdict(GBL_self) = EdictProg(pusher);
|
|
G_PEdict(GBL_other) = EdictProg(check);
|
|
PR_ExecuteProgram(ED_Func(pusher, ED_blocked));
|
|
}
|
|
|
|
// move back any entities we already moved
|
|
for(i = 0 ; i < num_moved ; i++)
|
|
{
|
|
VectorCopy(moved_from[i], ED_Vector(moved_edict[i], ED_origin));
|
|
SV_LinkEdict(moved_edict[i], false);
|
|
}
|
|
Hunk_FreeToLowMark(mark); //johnfitz
|
|
return;
|
|
}
|
|
}
|
|
|
|
Hunk_FreeToLowMark(mark); //johnfitz
|
|
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_Physics_Pusher
|
|
|
|
================
|
|
*/
|
|
void SV_Physics_Pusher(edict_t *ent)
|
|
{
|
|
float thinktime;
|
|
float oldltime;
|
|
float movetime;
|
|
|
|
oldltime = ED_Float(ent, ED_ltime);
|
|
|
|
thinktime = ED_Float(ent, ED_nextthink);
|
|
if(thinktime < ED_Float(ent, ED_ltime) + host_frametime)
|
|
{
|
|
movetime = thinktime - ED_Float(ent, ED_ltime);
|
|
if(movetime < 0)
|
|
movetime = 0;
|
|
}
|
|
else
|
|
movetime = host_frametime;
|
|
|
|
if(movetime)
|
|
{
|
|
SV_PushMove(ent, movetime); // advances ED_Float(ent, ED_ltime) if not blocked
|
|
}
|
|
|
|
if(thinktime > oldltime && thinktime <= ED_Float(ent, ED_ltime))
|
|
{
|
|
ED_Float(ent, ED_nextthink) = 0;
|
|
G_Float(GBL_time) = sv.time;
|
|
G_PEdict(GBL_self) = EdictProg(ent);
|
|
G_PEdict(GBL_other) = EdictProg(sv.edicts);
|
|
PR_ExecuteProgram(ED_Func(ent, ED_think));
|
|
if(ent->free)
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
CLIENT MOVEMENT
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
=============
|
|
SV_CheckStuck
|
|
|
|
This is a big hack to try and fix the rare case of getting stuck in the world
|
|
clipping hull.
|
|
=============
|
|
*/
|
|
void SV_CheckStuck(edict_t *ent)
|
|
{
|
|
int32_t i, j;
|
|
int32_t z;
|
|
vec3_t org;
|
|
|
|
if(!SV_TestEntityPosition(ent))
|
|
{
|
|
VectorCopy(ED_Vector(ent, ED_origin), ED_Vector(ent, ED_oldorigin));
|
|
return;
|
|
}
|
|
|
|
VectorCopy(ED_Vector(ent, ED_origin), org);
|
|
VectorCopy(ED_Vector(ent, ED_oldorigin), ED_Vector(ent, ED_origin));
|
|
if(!SV_TestEntityPosition(ent))
|
|
{
|
|
Con_DPrintf("Unstuck.\n");
|
|
SV_LinkEdict(ent, true);
|
|
return;
|
|
}
|
|
|
|
for(z = 0 ; z < 18 ; z++)
|
|
for(i = -1 ; i <= 1 ; i++)
|
|
for(j = -1 ; j <= 1 ; j++)
|
|
{
|
|
ED_Vector(ent, ED_origin)[0] = org[0] + i;
|
|
ED_Vector(ent, ED_origin)[1] = org[1] + j;
|
|
ED_Vector(ent, ED_origin)[2] = org[2] + z;
|
|
if(!SV_TestEntityPosition(ent))
|
|
{
|
|
Con_DPrintf("Unstuck.\n");
|
|
SV_LinkEdict(ent, true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
VectorCopy(org, ED_Vector(ent, ED_origin));
|
|
Con_DPrintf("player is stuck.\n");
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
SV_CheckWater
|
|
=============
|
|
*/
|
|
bool SV_CheckWater(edict_t *ent)
|
|
{
|
|
vec3_t point;
|
|
int32_t cont;
|
|
|
|
point[0] = ED_Vector(ent, ED_origin)[0];
|
|
point[1] = ED_Vector(ent, ED_origin)[1];
|
|
point[2] = ED_Vector(ent, ED_origin)[2] + ED_Vector(ent, ED_mins)[2] + 1;
|
|
|
|
ED_Float(ent, ED_waterlevel) = 0;
|
|
ED_Float(ent, ED_watertype) = CONTENTS_EMPTY;
|
|
cont = SV_PointContents(point);
|
|
if(cont <= CONTENTS_WATER)
|
|
{
|
|
ED_Float(ent, ED_watertype) = cont;
|
|
ED_Float(ent, ED_waterlevel) = 1;
|
|
point[2] = ED_Vector(ent, ED_origin)[2] + (ED_Vector(ent, ED_mins)[2] + ED_Vector(ent, ED_maxs)[2]) * 0.5;
|
|
cont = SV_PointContents(point);
|
|
if(cont <= CONTENTS_WATER)
|
|
{
|
|
ED_Float(ent, ED_waterlevel) = 2;
|
|
point[2] = ED_Vector(ent, ED_origin)[2] + ED_Vector(ent, ED_view_ofs)[2];
|
|
cont = SV_PointContents(point);
|
|
if(cont <= CONTENTS_WATER)
|
|
ED_Float(ent, ED_waterlevel) = 3;
|
|
}
|
|
}
|
|
|
|
return ED_Float(ent, ED_waterlevel) > 1;
|
|
}
|
|
|
|
/*
|
|
============
|
|
SV_WallFriction
|
|
|
|
============
|
|
*/
|
|
void SV_WallFriction(edict_t *ent, trace_t *trace)
|
|
{
|
|
vec3_t forward, right, up;
|
|
float d, i;
|
|
vec3_t into, side;
|
|
|
|
AngleVectors(ED_Vector(ent, ED_v_angle), forward, right, up);
|
|
d = DotProduct(trace->plane.normal, forward);
|
|
|
|
d += 0.5;
|
|
if(d >= 0)
|
|
return;
|
|
|
|
// cut the tangential velocity
|
|
i = DotProduct(trace->plane.normal, ED_Vector(ent, ED_velocity));
|
|
VectorScale(trace->plane.normal, i, into);
|
|
VectorSubtract(ED_Vector(ent, ED_velocity), into, side);
|
|
|
|
ED_Vector(ent, ED_velocity)[0] = side[0] * (1 + d);
|
|
ED_Vector(ent, ED_velocity)[1] = side[1] * (1 + d);
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
SV_TryUnstick
|
|
|
|
Player has come to a dead stop, possibly due to the problem with limited
|
|
float precision at some angle joins in the BSP hull.
|
|
|
|
Try fixing by pushing one pixel in each direction.
|
|
|
|
This is a hack, but in the interest of good gameplay...
|
|
======================
|
|
*/
|
|
int32_t SV_TryUnstick(edict_t *ent, vec3_t oldvel)
|
|
{
|
|
int32_t i;
|
|
vec3_t oldorg;
|
|
vec3_t dir;
|
|
int32_t clip;
|
|
trace_t steptrace;
|
|
|
|
VectorCopy(ED_Vector(ent, ED_origin), oldorg);
|
|
VectorCopy(vec3_origin, dir);
|
|
|
|
for(i = 0 ; i < 8 ; i++)
|
|
{
|
|
// try pushing a little in an axial direction
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
dir[0] = 2;
|
|
dir[1] = 0;
|
|
break;
|
|
case 1:
|
|
dir[0] = 0;
|
|
dir[1] = 2;
|
|
break;
|
|
case 2:
|
|
dir[0] = -2;
|
|
dir[1] = 0;
|
|
break;
|
|
case 3:
|
|
dir[0] = 0;
|
|
dir[1] = -2;
|
|
break;
|
|
case 4:
|
|
dir[0] = 2;
|
|
dir[1] = 2;
|
|
break;
|
|
case 5:
|
|
dir[0] = -2;
|
|
dir[1] = 2;
|
|
break;
|
|
case 6:
|
|
dir[0] = 2;
|
|
dir[1] = -2;
|
|
break;
|
|
case 7:
|
|
dir[0] = -2;
|
|
dir[1] = -2;
|
|
break;
|
|
}
|
|
|
|
SV_PushEntity(ent, dir);
|
|
|
|
// retry the original move
|
|
ED_Vector(ent, ED_velocity)[0] = oldvel[0];
|
|
ED_Vector(ent, ED_velocity)[1] = oldvel[1];
|
|
ED_Vector(ent, ED_velocity)[2] = 0;
|
|
clip = SV_FlyMove(ent, 0.1, &steptrace);
|
|
|
|
if(fabs(oldorg[1] - ED_Vector(ent, ED_origin)[1]) > 4
|
|
|| fabs(oldorg[0] - ED_Vector(ent, ED_origin)[0]) > 4)
|
|
{
|
|
//Con_DPrintf ("unstuck!\n");
|
|
return clip;
|
|
}
|
|
|
|
// go back to the original pos and try again
|
|
VectorCopy(oldorg, ED_Vector(ent, ED_origin));
|
|
}
|
|
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_velocity));
|
|
return 7; // still not moving
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
SV_WalkMove
|
|
|
|
Only used by players
|
|
======================
|
|
*/
|
|
#define STEPSIZE 18
|
|
void SV_WalkMove(edict_t *ent)
|
|
{
|
|
vec3_t upmove, downmove;
|
|
vec3_t oldorg, oldvel;
|
|
vec3_t nosteporg, nostepvel;
|
|
int32_t clip;
|
|
int32_t oldonground;
|
|
trace_t steptrace, downtrace;
|
|
|
|
//
|
|
// do a regular slide move unless it looks like you ran into a step
|
|
//
|
|
oldonground = (int32_t)ED_Float(ent, ED_flags) & FL_ONGROUND;
|
|
ED_Float(ent, ED_flags) = (int32_t)ED_Float(ent, ED_flags) & ~FL_ONGROUND;
|
|
|
|
VectorCopy(ED_Vector(ent, ED_origin), oldorg);
|
|
VectorCopy(ED_Vector(ent, ED_velocity), oldvel);
|
|
|
|
clip = SV_FlyMove(ent, host_frametime, &steptrace);
|
|
|
|
if(!(clip & 2))
|
|
return; // move didn't block on a step
|
|
|
|
if(!oldonground && ED_Float(ent, ED_waterlevel) == 0)
|
|
return; // don't stair up while jumping
|
|
|
|
if(ED_Float(ent, ED_movetype) != MOVETYPE_WALK)
|
|
return; // gibbed by a trigger
|
|
|
|
if(sv_nostep.value)
|
|
return;
|
|
|
|
if((int32_t)ED_Float(sv_player, ED_flags) & FL_WATERJUMP)
|
|
return;
|
|
|
|
VectorCopy(ED_Vector(ent, ED_origin), nosteporg);
|
|
VectorCopy(ED_Vector(ent, ED_velocity), nostepvel);
|
|
|
|
//
|
|
// try moving up and forward to go up a step
|
|
//
|
|
VectorCopy(oldorg, ED_Vector(ent, ED_origin)); // back to start pos
|
|
|
|
VectorCopy(vec3_origin, upmove);
|
|
VectorCopy(vec3_origin, downmove);
|
|
upmove[2] = STEPSIZE;
|
|
downmove[2] = -STEPSIZE + oldvel[2] * host_frametime;
|
|
|
|
// move up
|
|
SV_PushEntity(ent, upmove); // FIXME: don't link?
|
|
|
|
// move forward
|
|
ED_Vector(ent, ED_velocity)[0] = oldvel[0];
|
|
ED_Vector(ent, ED_velocity)[1] = oldvel[1];
|
|
ED_Vector(ent, ED_velocity)[2] = 0;
|
|
clip = SV_FlyMove(ent, host_frametime, &steptrace);
|
|
|
|
// check for stuckness, possibly due to the limited precision of floats
|
|
// in the clipping hulls
|
|
if(clip)
|
|
{
|
|
if(fabs(oldorg[1] - ED_Vector(ent, ED_origin)[1]) < 0.03125
|
|
&& fabs(oldorg[0] - ED_Vector(ent, ED_origin)[0]) < 0.03125)
|
|
{
|
|
// stepping up didn't make any progress
|
|
clip = SV_TryUnstick(ent, oldvel);
|
|
}
|
|
}
|
|
|
|
// extra friction based on view angle
|
|
if(clip & 2)
|
|
SV_WallFriction(ent, &steptrace);
|
|
|
|
// move down
|
|
downtrace = SV_PushEntity(ent, downmove); // FIXME: don't link?
|
|
|
|
if(downtrace.plane.normal[2] > 0.7)
|
|
{
|
|
if(ED_Float(ent, ED_solid) == SOLID_BSP)
|
|
{
|
|
ED_Float(ent, ED_flags) = (int32_t)ED_Float(ent, ED_flags) | FL_ONGROUND;
|
|
ED_PEdict(ent, ED_groundentity) = EdictProg(downtrace.ent);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if the push down didn't end up on good ground, use the move without
|
|
// the step up. This happens near wall / slope combinations, and can
|
|
// cause the player to hop up higher on a slope too steep to climb
|
|
VectorCopy(nosteporg, ED_Vector(ent, ED_origin));
|
|
VectorCopy(nostepvel, ED_Vector(ent, ED_velocity));
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
SV_Physics_Client
|
|
|
|
Player character actions
|
|
================
|
|
*/
|
|
void SV_Physics_Client(edict_t *ent, int32_t num)
|
|
{
|
|
if(! svs.clients[num - 1].active)
|
|
return; // unconnected slot
|
|
|
|
//
|
|
// call standard client pre-think
|
|
//
|
|
G_Float(GBL_time) = sv.time;
|
|
G_PEdict(GBL_self) = EdictProg(ent);
|
|
PR_ExecuteProgram(G_Func(GBL_PlayerPreThink));
|
|
|
|
//
|
|
// do a move
|
|
//
|
|
SV_CheckVelocity(ent);
|
|
|
|
//
|
|
// decide which move function to call
|
|
//
|
|
switch((int32_t)ED_Float(ent, ED_movetype))
|
|
{
|
|
case MOVETYPE_NONE:
|
|
if(!SV_RunThink(ent))
|
|
return;
|
|
break;
|
|
|
|
case MOVETYPE_WALK:
|
|
if(!SV_RunThink(ent))
|
|
return;
|
|
if(!SV_CheckWater(ent) && !((int32_t)ED_Float(ent, ED_flags) & FL_WATERJUMP))
|
|
SV_AddGravity(ent);
|
|
SV_CheckStuck(ent);
|
|
SV_WalkMove(ent);
|
|
break;
|
|
|
|
case MOVETYPE_TOSS:
|
|
case MOVETYPE_BOUNCE:
|
|
SV_Physics_Toss(ent);
|
|
break;
|
|
|
|
case MOVETYPE_FLY:
|
|
if(!SV_RunThink(ent))
|
|
return;
|
|
SV_FlyMove(ent, host_frametime, NULL);
|
|
break;
|
|
|
|
case MOVETYPE_NOCLIP:
|
|
if(!SV_RunThink(ent))
|
|
return;
|
|
VectorMA(ED_Vector(ent, ED_origin), host_frametime, ED_Vector(ent, ED_velocity), ED_Vector(ent, ED_origin));
|
|
break;
|
|
|
|
default:
|
|
Sys_Error("SV_Physics_client: bad movetype %" PRIi32, (int32_t)ED_Float(ent, ED_movetype));
|
|
}
|
|
|
|
//
|
|
// call standard player post-think
|
|
//
|
|
SV_LinkEdict(ent, true);
|
|
|
|
G_Float(GBL_time) = sv.time;
|
|
G_PEdict(GBL_self) = EdictProg(ent);
|
|
PR_ExecuteProgram(G_Func(GBL_PlayerPostThink));
|
|
}
|
|
|
|
//============================================================================
|
|
|
|
/*
|
|
=============
|
|
SV_Physics_None
|
|
|
|
Non moving objects can only think
|
|
=============
|
|
*/
|
|
void SV_Physics_None(edict_t *ent)
|
|
{
|
|
// regular thinking
|
|
SV_RunThink(ent);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
SV_Physics_Noclip
|
|
|
|
A moving object that doesn't obey physics
|
|
=============
|
|
*/
|
|
void SV_Physics_Noclip(edict_t *ent)
|
|
{
|
|
// regular thinking
|
|
if(!SV_RunThink(ent))
|
|
return;
|
|
|
|
VectorMA(ED_Vector(ent, ED_angles), host_frametime, ED_Vector(ent, ED_avelocity), ED_Vector(ent, ED_angles));
|
|
VectorMA(ED_Vector(ent, ED_origin), host_frametime, ED_Vector(ent, ED_velocity), ED_Vector(ent, ED_origin));
|
|
|
|
SV_LinkEdict(ent, false);
|
|
}
|
|
|
|
/*
|
|
==============================================================================
|
|
|
|
TOSS / BOUNCE
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
/*
|
|
=============
|
|
SV_CheckWaterTransition
|
|
|
|
=============
|
|
*/
|
|
void SV_CheckWaterTransition(edict_t *ent)
|
|
{
|
|
int32_t cont;
|
|
|
|
cont = SV_PointContents(ED_Vector(ent, ED_origin));
|
|
|
|
if(!ED_Float(ent, ED_watertype))
|
|
{
|
|
// just spawned here
|
|
ED_Float(ent, ED_watertype) = cont;
|
|
ED_Float(ent, ED_waterlevel) = 1;
|
|
return;
|
|
}
|
|
|
|
if(cont <= CONTENTS_WATER)
|
|
{
|
|
if(ED_Float(ent, ED_watertype) == CONTENTS_EMPTY)
|
|
{
|
|
// just crossed into water
|
|
SV_StartSound(ent, 0, "misc/h2ohit1.wav", 255, 1);
|
|
}
|
|
ED_Float(ent, ED_watertype) = cont;
|
|
ED_Float(ent, ED_waterlevel) = 1;
|
|
}
|
|
else
|
|
{
|
|
if(ED_Float(ent, ED_watertype) != CONTENTS_EMPTY)
|
|
{
|
|
// just crossed into water
|
|
SV_StartSound(ent, 0, "misc/h2ohit1.wav", 255, 1);
|
|
}
|
|
ED_Float(ent, ED_watertype) = CONTENTS_EMPTY;
|
|
ED_Float(ent, ED_waterlevel) = cont;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
SV_Physics_Toss
|
|
|
|
Toss, bounce, and fly movement. When onground, do nothing.
|
|
=============
|
|
*/
|
|
void SV_Physics_Toss(edict_t *ent)
|
|
{
|
|
trace_t trace;
|
|
vec3_t move;
|
|
float backoff;
|
|
|
|
// regular thinking
|
|
if(!SV_RunThink(ent))
|
|
return;
|
|
|
|
// if onground, return without moving
|
|
if(((int32_t)ED_Float(ent, ED_flags) & FL_ONGROUND))
|
|
return;
|
|
|
|
SV_CheckVelocity(ent);
|
|
|
|
// add gravity
|
|
if(ED_Float(ent, ED_movetype) != MOVETYPE_FLY
|
|
&& ED_Float(ent, ED_movetype) != MOVETYPE_FLYMISSILE)
|
|
SV_AddGravity(ent);
|
|
|
|
// move angles
|
|
VectorMA(ED_Vector(ent, ED_angles), host_frametime, ED_Vector(ent, ED_avelocity), ED_Vector(ent, ED_angles));
|
|
|
|
// move origin
|
|
VectorScale(ED_Vector(ent, ED_velocity), host_frametime, move);
|
|
trace = SV_PushEntity(ent, move);
|
|
if(trace.fraction == 1)
|
|
return;
|
|
if(ent->free)
|
|
return;
|
|
|
|
if(ED_Float(ent, ED_movetype) == MOVETYPE_BOUNCE)
|
|
backoff = 1.5;
|
|
else
|
|
backoff = 1;
|
|
|
|
ClipVelocity(ED_Vector(ent, ED_velocity), trace.plane.normal, ED_Vector(ent, ED_velocity), backoff);
|
|
|
|
// stop if on ground
|
|
if(trace.plane.normal[2] > 0.7)
|
|
{
|
|
if(ED_Vector(ent, ED_velocity)[2] < 60 || ED_Float(ent, ED_movetype) != MOVETYPE_BOUNCE)
|
|
{
|
|
ED_Float(ent, ED_flags) = (int32_t)ED_Float(ent, ED_flags) | FL_ONGROUND;
|
|
ED_PEdict(ent, ED_groundentity) = EdictProg(trace.ent);
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_velocity));
|
|
VectorCopy(vec3_origin, ED_Vector(ent, ED_avelocity));
|
|
}
|
|
}
|
|
|
|
// check for in water
|
|
SV_CheckWaterTransition(ent);
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
STEPPING MOVEMENT
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
=============
|
|
SV_Physics_Step
|
|
|
|
Monsters freefall when they don't have a ground entity, otherwise
|
|
all movement is done with discrete steps.
|
|
|
|
This is also used for objects that have become still on the ground, but
|
|
will fall if the floor is pulled out from under them.
|
|
=============
|
|
*/
|
|
void SV_Physics_Step(edict_t *ent)
|
|
{
|
|
bool hitsound;
|
|
|
|
// freefall if not onground
|
|
if(!((int32_t)ED_Float(ent, ED_flags) & (FL_ONGROUND | FL_FLY | FL_SWIM)))
|
|
{
|
|
if(ED_Vector(ent, ED_velocity)[2] < sv_gravity.value * -0.1)
|
|
hitsound = true;
|
|
else
|
|
hitsound = false;
|
|
|
|
SV_AddGravity(ent);
|
|
SV_CheckVelocity(ent);
|
|
SV_FlyMove(ent, host_frametime, NULL);
|
|
SV_LinkEdict(ent, true);
|
|
|
|
if((int32_t)ED_Float(ent, ED_flags) & FL_ONGROUND) // just hit ground
|
|
{
|
|
if(hitsound)
|
|
SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
|
|
}
|
|
}
|
|
|
|
// regular thinking
|
|
SV_RunThink(ent);
|
|
|
|
SV_CheckWaterTransition(ent);
|
|
}
|
|
|
|
|
|
//============================================================================
|
|
|
|
/*
|
|
================
|
|
SV_Physics
|
|
|
|
================
|
|
*/
|
|
void SV_Physics(void)
|
|
{
|
|
int32_t i;
|
|
int32_t entity_cap; // For sv_freezenonclients
|
|
edict_t *ent;
|
|
|
|
// let the progs know that a new frame has started
|
|
G_PEdict(GBL_self) = EdictProg(sv.edicts);
|
|
G_PEdict(GBL_other) = EdictProg(sv.edicts);
|
|
G_Float(GBL_time) = sv.time;
|
|
PR_ExecuteProgram(G_Func(GBL_StartFrame));
|
|
|
|
//SV_CheckAllEnts ();
|
|
|
|
//
|
|
// treat each object in turn
|
|
//
|
|
ent = sv.edicts;
|
|
|
|
if(sv_freezenonclients.value)
|
|
entity_cap = svs.maxclients + 1; // Only run physics on clients and the world
|
|
else
|
|
entity_cap = sv.num_edicts;
|
|
|
|
//for (i=0 ; i<sv.num_edicts ; i++, ent = NextEdict(ent))
|
|
for(i = 0 ; i < entity_cap ; i++, ent = NextEdict(ent))
|
|
{
|
|
if(ent->free)
|
|
continue;
|
|
|
|
if(G_Float(GBL_force_retouch))
|
|
{
|
|
SV_LinkEdict(ent, true); // force retouch even for stationary
|
|
}
|
|
|
|
if(i > 0 && i <= svs.maxclients)
|
|
SV_Physics_Client(ent, i);
|
|
else if(ED_Float(ent, ED_movetype) == MOVETYPE_PUSH)
|
|
SV_Physics_Pusher(ent);
|
|
else if(ED_Float(ent, ED_movetype) == MOVETYPE_NONE)
|
|
SV_Physics_None(ent);
|
|
else if(ED_Float(ent, ED_movetype) == MOVETYPE_NOCLIP)
|
|
SV_Physics_Noclip(ent);
|
|
else if(ED_Float(ent, ED_movetype) == MOVETYPE_STEP)
|
|
SV_Physics_Step(ent);
|
|
else if(ED_Float(ent, ED_movetype) == MOVETYPE_TOSS
|
|
|| ED_Float(ent, ED_movetype) == MOVETYPE_BOUNCE
|
|
|| ED_Float(ent, ED_movetype) == MOVETYPE_FLY
|
|
|| ED_Float(ent, ED_movetype) == MOVETYPE_FLYMISSILE)
|
|
SV_Physics_Toss(ent);
|
|
else
|
|
Sys_Error("SV_Physics: bad movetype %" PRIi32, (int32_t)ED_Float(ent, ED_movetype));
|
|
}
|
|
|
|
if(G_Float(GBL_force_retouch))
|
|
G_Float(GBL_force_retouch)--;
|
|
|
|
if(!sv_freezenonclients.value)
|
|
sv.time += host_frametime;
|
|
}
|