0,0 → 1,1617 |
/* |
Copyright (C) 1996-1997 Id Software, Inc. |
|
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 "quakedef.h" |
|
/* |
|
|
pushmove objects do not obey gravity, and do not interact with each other or trigger fields, 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",false,true}; |
cvar_t sv_stopspeed = {"sv_stopspeed","100"}; |
cvar_t sv_gravity = {"sv_gravity","800",false,true}; |
cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"}; |
cvar_t sv_nostep = {"sv_nostep","0"}; |
|
#ifdef QUAKE2 |
static vec3_t vec_origin = {0.0, 0.0, 0.0}; |
#endif |
|
#define MOVE_EPSILON 0.01 |
|
void SV_Physics_Toss (edict_t *ent); |
|
/* |
================ |
SV_CheckAllEnts |
================ |
*/ |
void SV_CheckAllEnts (void) |
{ |
int e; |
edict_t *check; |
|
// see if any solid entities are inside the final position |
check = NEXT_EDICT(sv.edicts); |
for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check)) |
{ |
if (check->free) |
continue; |
if (check->v.movetype == MOVETYPE_PUSH |
|| check->v.movetype == MOVETYPE_NONE |
#ifdef QUAKE2 |
|| check->v.movetype == MOVETYPE_FOLLOW |
#endif |
|| check->v.movetype == MOVETYPE_NOCLIP) |
continue; |
|
if (SV_TestEntityPosition (check)) |
Con_Printf ("entity in invalid position\n"); |
} |
} |
|
/* |
================ |
SV_CheckVelocity |
================ |
*/ |
void SV_CheckVelocity (edict_t *ent) |
{ |
int i; |
|
// |
// bound velocity |
// |
for (i=0 ; i<3 ; i++) |
{ |
if (IS_NAN(ent->v.velocity[i])) |
{ |
Con_Printf ("Got a NaN velocity on %s\n", pr_strings + ent->v.classname); |
ent->v.velocity[i] = 0; |
} |
if (IS_NAN(ent->v.origin[i])) |
{ |
Con_Printf ("Got a NaN origin on %s\n", pr_strings + ent->v.classname); |
ent->v.origin[i] = 0; |
} |
if (ent->v.velocity[i] > sv_maxvelocity.value) |
ent->v.velocity[i] = sv_maxvelocity.value; |
else if (ent->v.velocity[i] < -sv_maxvelocity.value) |
ent->v.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. |
============= |
*/ |
qboolean SV_RunThink (edict_t *ent) |
{ |
float thinktime; |
|
thinktime = ent->v.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. |
ent->v.nextthink = 0; |
pr_global_struct->time = thinktime; |
pr_global_struct->self = EDICT_TO_PROG(ent); |
pr_global_struct->other = EDICT_TO_PROG(sv.edicts); |
PR_ExecuteProgram (ent->v.think); |
return !ent->free; |
} |
|
/* |
================== |
SV_Impact |
|
Two entities have touched, so run their touch functions |
================== |
*/ |
void SV_Impact (edict_t *e1, edict_t *e2) |
{ |
int old_self, old_other; |
|
old_self = pr_global_struct->self; |
old_other = pr_global_struct->other; |
|
pr_global_struct->time = sv.time; |
if (e1->v.touch && e1->v.solid != SOLID_NOT) |
{ |
pr_global_struct->self = EDICT_TO_PROG(e1); |
pr_global_struct->other = EDICT_TO_PROG(e2); |
PR_ExecuteProgram (e1->v.touch); |
} |
|
if (e2->v.touch && e2->v.solid != SOLID_NOT) |
{ |
pr_global_struct->self = EDICT_TO_PROG(e2); |
pr_global_struct->other = EDICT_TO_PROG(e1); |
PR_ExecuteProgram (e2->v.touch); |
} |
|
pr_global_struct->self = old_self; |
pr_global_struct->other = old_other; |
} |
|
|
/* |
================== |
ClipVelocity |
|
Slide off of the impacting object |
returns the blocked flags (1 = floor, 2 = step / wall) |
================== |
*/ |
#define STOP_EPSILON 0.1 |
|
int ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce) |
{ |
float backoff; |
float change; |
int 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 |
int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) |
{ |
int bumpcount, numbumps; |
vec3_t dir; |
float d; |
int numplanes; |
vec3_t planes[MAX_CLIP_PLANES]; |
vec3_t primal_velocity, original_velocity, new_velocity; |
int i, j; |
trace_t trace; |
vec3_t end; |
float time_left; |
int blocked; |
|
numbumps = 4; |
|
blocked = 0; |
VectorCopy (ent->v.velocity, original_velocity); |
VectorCopy (ent->v.velocity, primal_velocity); |
numplanes = 0; |
|
time_left = time; |
|
for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++) |
{ |
if (!ent->v.velocity[0] && !ent->v.velocity[1] && !ent->v.velocity[2]) |
break; |
|
for (i=0 ; i<3 ; i++) |
end[i] = ent->v.origin[i] + time_left * ent->v.velocity[i]; |
|
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent); |
|
if (trace.allsolid) |
{ // entity is trapped in another solid |
VectorCopy (vec3_origin, ent->v.velocity); |
return 3; |
} |
|
if (trace.fraction > 0) |
{ // actually covered some distance |
VectorCopy (trace.endpos, ent->v.origin); |
VectorCopy (ent->v.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 (trace.ent->v.solid == SOLID_BSP) |
{ |
ent->v.flags = (int)ent->v.flags | FL_ONGROUND; |
ent->v.groundentity = EDICT_TO_PROG(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, ent->v.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, ent->v.velocity); |
} |
else |
{ // go along the crease |
if (numplanes != 2) |
{ |
// Con_Printf ("clip velocity, numplanes == %i\n",numplanes); |
VectorCopy (vec3_origin, ent->v.velocity); |
return 7; |
} |
CrossProduct (planes[0], planes[1], dir); |
d = DotProduct (dir, ent->v.velocity); |
VectorScale (dir, d, ent->v.velocity); |
} |
|
// |
// if original velocity is against the original velocity, stop dead |
// to avoid tiny occilations in sloping corners |
// |
if (DotProduct (ent->v.velocity, primal_velocity) <= 0) |
{ |
VectorCopy (vec3_origin, ent->v.velocity); |
return blocked; |
} |
} |
|
return blocked; |
} |
|
|
/* |
============ |
SV_AddGravity |
|
============ |
*/ |
void SV_AddGravity (edict_t *ent) |
{ |
float ent_gravity; |
|
#ifdef QUAKE2 |
if (ent->v.gravity) |
ent_gravity = ent->v.gravity; |
else |
ent_gravity = 1.0; |
#else |
eval_t *val; |
|
val = GetEdictFieldValue(ent, "gravity"); |
if (val && val->_float) |
ent_gravity = val->_float; |
else |
ent_gravity = 1.0; |
#endif |
ent->v.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 (ent->v.origin, push, end); |
|
if (ent->v.movetype == MOVETYPE_FLYMISSILE) |
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_MISSILE, ent); |
else if (ent->v.solid == SOLID_TRIGGER || ent->v.solid == SOLID_NOT) |
// only clip against bmodels |
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent); |
else |
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent); |
|
VectorCopy (trace.endpos, ent->v.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) |
{ |
int i, e; |
edict_t *check, *block; |
vec3_t mins, maxs, move; |
vec3_t entorig, pushorig; |
int num_moved; |
edict_t *moved_edict[MAX_EDICTS]; |
vec3_t moved_from[MAX_EDICTS]; |
|
if (!pusher->v.velocity[0] && !pusher->v.velocity[1] && !pusher->v.velocity[2]) |
{ |
pusher->v.ltime += movetime; |
return; |
} |
|
for (i=0 ; i<3 ; i++) |
{ |
move[i] = pusher->v.velocity[i] * movetime; |
mins[i] = pusher->v.absmin[i] + move[i]; |
maxs[i] = pusher->v.absmax[i] + move[i]; |
} |
|
VectorCopy (pusher->v.origin, pushorig); |
|
// move the pusher to it's final position |
|
VectorAdd (pusher->v.origin, move, pusher->v.origin); |
pusher->v.ltime += movetime; |
SV_LinkEdict (pusher, false); |
|
|
// see if any solid entities are inside the final position |
num_moved = 0; |
check = NEXT_EDICT(sv.edicts); |
for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check)) |
{ |
if (check->free) |
continue; |
if (check->v.movetype == MOVETYPE_PUSH |
|| check->v.movetype == MOVETYPE_NONE |
#ifdef QUAKE2 |
|| check->v.movetype == MOVETYPE_FOLLOW |
#endif |
|| check->v.movetype == MOVETYPE_NOCLIP) |
continue; |
|
// if the entity is standing on the pusher, it will definately be moved |
if ( ! ( ((int)check->v.flags & FL_ONGROUND) |
&& PROG_TO_EDICT(check->v.groundentity) == pusher) ) |
{ |
if ( check->v.absmin[0] >= maxs[0] |
|| check->v.absmin[1] >= maxs[1] |
|| check->v.absmin[2] >= maxs[2] |
|| check->v.absmax[0] <= mins[0] |
|| check->v.absmax[1] <= mins[1] |
|| check->v.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 (check->v.movetype != MOVETYPE_WALK) |
check->v.flags = (int)check->v.flags & ~FL_ONGROUND; |
|
VectorCopy (check->v.origin, entorig); |
VectorCopy (check->v.origin, moved_from[num_moved]); |
moved_edict[num_moved] = check; |
num_moved++; |
|
// try moving the contacted entity |
pusher->v.solid = SOLID_NOT; |
SV_PushEntity (check, move); |
pusher->v.solid = SOLID_BSP; |
|
// if it is still inside the pusher, block |
block = SV_TestEntityPosition (check); |
if (block) |
{ // fail the move |
if (check->v.mins[0] == check->v.maxs[0]) |
continue; |
if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER) |
{ // corpse |
check->v.mins[0] = check->v.mins[1] = 0; |
VectorCopy (check->v.mins, check->v.maxs); |
continue; |
} |
|
VectorCopy (entorig, check->v.origin); |
SV_LinkEdict (check, true); |
|
VectorCopy (pushorig, pusher->v.origin); |
SV_LinkEdict (pusher, false); |
pusher->v.ltime -= movetime; |
|
// if the pusher has a "blocked" function, call it |
// otherwise, just stay in place until the obstacle is gone |
if (pusher->v.blocked) |
{ |
pr_global_struct->self = EDICT_TO_PROG(pusher); |
pr_global_struct->other = EDICT_TO_PROG(check); |
PR_ExecuteProgram (pusher->v.blocked); |
} |
|
// move back any entities we already moved |
for (i=0 ; i<num_moved ; i++) |
{ |
VectorCopy (moved_from[i], moved_edict[i]->v.origin); |
SV_LinkEdict (moved_edict[i], false); |
} |
return; |
} |
} |
|
|
} |
|
#ifdef QUAKE2 |
/* |
============ |
SV_PushRotate |
|
============ |
*/ |
void SV_PushRotate (edict_t *pusher, float movetime) |
{ |
int i, e; |
edict_t *check, *block; |
vec3_t move, a, amove; |
vec3_t entorig, pushorig; |
int num_moved; |
edict_t *moved_edict[MAX_EDICTS]; |
vec3_t moved_from[MAX_EDICTS]; |
vec3_t org, org2; |
vec3_t forward, right, up; |
|
if (!pusher->v.avelocity[0] && !pusher->v.avelocity[1] && !pusher->v.avelocity[2]) |
{ |
pusher->v.ltime += movetime; |
return; |
} |
|
for (i=0 ; i<3 ; i++) |
amove[i] = pusher->v.avelocity[i] * movetime; |
|
VectorSubtract (vec3_origin, amove, a); |
AngleVectors (a, forward, right, up); |
|
VectorCopy (pusher->v.angles, pushorig); |
|
// move the pusher to it's final position |
|
VectorAdd (pusher->v.angles, amove, pusher->v.angles); |
pusher->v.ltime += movetime; |
SV_LinkEdict (pusher, false); |
|
|
// see if any solid entities are inside the final position |
num_moved = 0; |
check = NEXT_EDICT(sv.edicts); |
for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check)) |
{ |
if (check->free) |
continue; |
if (check->v.movetype == MOVETYPE_PUSH |
|| check->v.movetype == MOVETYPE_NONE |
|| check->v.movetype == MOVETYPE_FOLLOW |
|| check->v.movetype == MOVETYPE_NOCLIP) |
continue; |
|
// if the entity is standing on the pusher, it will definately be moved |
if ( ! ( ((int)check->v.flags & FL_ONGROUND) |
&& PROG_TO_EDICT(check->v.groundentity) == pusher) ) |
{ |
if ( check->v.absmin[0] >= pusher->v.absmax[0] |
|| check->v.absmin[1] >= pusher->v.absmax[1] |
|| check->v.absmin[2] >= pusher->v.absmax[2] |
|| check->v.absmax[0] <= pusher->v.absmin[0] |
|| check->v.absmax[1] <= pusher->v.absmin[1] |
|| check->v.absmax[2] <= pusher->v.absmin[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 (check->v.movetype != MOVETYPE_WALK) |
check->v.flags = (int)check->v.flags & ~FL_ONGROUND; |
|
VectorCopy (check->v.origin, entorig); |
VectorCopy (check->v.origin, moved_from[num_moved]); |
moved_edict[num_moved] = check; |
num_moved++; |
|
// calculate destination position |
VectorSubtract (check->v.origin, pusher->v.origin, org); |
org2[0] = DotProduct (org, forward); |
org2[1] = -DotProduct (org, right); |
org2[2] = DotProduct (org, up); |
VectorSubtract (org2, org, move); |
|
// try moving the contacted entity |
pusher->v.solid = SOLID_NOT; |
SV_PushEntity (check, move); |
pusher->v.solid = SOLID_BSP; |
|
// if it is still inside the pusher, block |
block = SV_TestEntityPosition (check); |
if (block) |
{ // fail the move |
if (check->v.mins[0] == check->v.maxs[0]) |
continue; |
if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER) |
{ // corpse |
check->v.mins[0] = check->v.mins[1] = 0; |
VectorCopy (check->v.mins, check->v.maxs); |
continue; |
} |
|
VectorCopy (entorig, check->v.origin); |
SV_LinkEdict (check, true); |
|
VectorCopy (pushorig, pusher->v.angles); |
SV_LinkEdict (pusher, false); |
pusher->v.ltime -= movetime; |
|
// if the pusher has a "blocked" function, call it |
// otherwise, just stay in place until the obstacle is gone |
if (pusher->v.blocked) |
{ |
pr_global_struct->self = EDICT_TO_PROG(pusher); |
pr_global_struct->other = EDICT_TO_PROG(check); |
PR_ExecuteProgram (pusher->v.blocked); |
} |
|
// move back any entities we already moved |
for (i=0 ; i<num_moved ; i++) |
{ |
VectorCopy (moved_from[i], moved_edict[i]->v.origin); |
VectorSubtract (moved_edict[i]->v.angles, amove, moved_edict[i]->v.angles); |
SV_LinkEdict (moved_edict[i], false); |
} |
return; |
} |
else |
{ |
VectorAdd (check->v.angles, amove, check->v.angles); |
} |
} |
|
|
} |
#endif |
|
/* |
================ |
SV_Physics_Pusher |
|
================ |
*/ |
void SV_Physics_Pusher (edict_t *ent) |
{ |
float thinktime; |
float oldltime; |
float movetime; |
|
oldltime = ent->v.ltime; |
|
thinktime = ent->v.nextthink; |
if (thinktime < ent->v.ltime + host_frametime) |
{ |
movetime = thinktime - ent->v.ltime; |
if (movetime < 0) |
movetime = 0; |
} |
else |
movetime = host_frametime; |
|
if (movetime) |
{ |
#ifdef QUAKE2 |
if (ent->v.avelocity[0] || ent->v.avelocity[1] || ent->v.avelocity[2]) |
SV_PushRotate (ent, movetime); |
else |
#endif |
SV_PushMove (ent, movetime); // advances ent->v.ltime if not blocked |
} |
|
if (thinktime > oldltime && thinktime <= ent->v.ltime) |
{ |
ent->v.nextthink = 0; |
pr_global_struct->time = sv.time; |
pr_global_struct->self = EDICT_TO_PROG(ent); |
pr_global_struct->other = EDICT_TO_PROG(sv.edicts); |
PR_ExecuteProgram (ent->v.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) |
{ |
int i, j; |
int z; |
vec3_t org; |
|
if (!SV_TestEntityPosition(ent)) |
{ |
VectorCopy (ent->v.origin, ent->v.oldorigin); |
return; |
} |
|
VectorCopy (ent->v.origin, org); |
VectorCopy (ent->v.oldorigin, ent->v.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++) |
{ |
ent->v.origin[0] = org[0] + i; |
ent->v.origin[1] = org[1] + j; |
ent->v.origin[2] = org[2] + z; |
if (!SV_TestEntityPosition(ent)) |
{ |
Con_DPrintf ("Unstuck.\n"); |
SV_LinkEdict (ent, true); |
return; |
} |
} |
|
VectorCopy (org, ent->v.origin); |
Con_DPrintf ("player is stuck.\n"); |
} |
|
|
/* |
============= |
SV_CheckWater |
============= |
*/ |
qboolean SV_CheckWater (edict_t *ent) |
{ |
vec3_t point; |
int cont; |
#ifdef QUAKE2 |
int truecont; |
#endif |
|
point[0] = ent->v.origin[0]; |
point[1] = ent->v.origin[1]; |
point[2] = ent->v.origin[2] + ent->v.mins[2] + 1; |
|
ent->v.waterlevel = 0; |
ent->v.watertype = CONTENTS_EMPTY; |
cont = SV_PointContents (point); |
if (cont <= CONTENTS_WATER) |
{ |
#ifdef QUAKE2 |
truecont = SV_TruePointContents (point); |
#endif |
ent->v.watertype = cont; |
ent->v.waterlevel = 1; |
point[2] = ent->v.origin[2] + (ent->v.mins[2] + ent->v.maxs[2])*0.5; |
cont = SV_PointContents (point); |
if (cont <= CONTENTS_WATER) |
{ |
ent->v.waterlevel = 2; |
point[2] = ent->v.origin[2] + ent->v.view_ofs[2]; |
cont = SV_PointContents (point); |
if (cont <= CONTENTS_WATER) |
ent->v.waterlevel = 3; |
} |
#ifdef QUAKE2 |
if (truecont <= CONTENTS_CURRENT_0 && truecont >= CONTENTS_CURRENT_DOWN) |
{ |
static vec3_t current_table[] = |
{ |
{1, 0, 0}, |
{0, 1, 0}, |
{-1, 0, 0}, |
{0, -1, 0}, |
{0, 0, 1}, |
{0, 0, -1} |
}; |
|
VectorMA (ent->v.basevelocity, 150.0*ent->v.waterlevel/3.0, current_table[CONTENTS_CURRENT_0 - truecont], ent->v.basevelocity); |
} |
#endif |
} |
|
return ent->v.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 (ent->v.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, ent->v.velocity); |
VectorScale (trace->plane.normal, i, into); |
VectorSubtract (ent->v.velocity, into, side); |
|
ent->v.velocity[0] = side[0] * (1 + d); |
ent->v.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... |
====================== |
*/ |
int SV_TryUnstick (edict_t *ent, vec3_t oldvel) |
{ |
int i; |
vec3_t oldorg; |
vec3_t dir; |
int clip; |
trace_t steptrace; |
|
VectorCopy (ent->v.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 |
ent->v.velocity[0] = oldvel[0]; |
ent->v. velocity[1] = oldvel[1]; |
ent->v. velocity[2] = 0; |
clip = SV_FlyMove (ent, 0.1, &steptrace); |
|
if ( fabs(oldorg[1] - ent->v.origin[1]) > 4 |
|| fabs(oldorg[0] - ent->v.origin[0]) > 4 ) |
{ |
//Con_DPrintf ("unstuck!\n"); |
return clip; |
} |
|
// go back to the original pos and try again |
VectorCopy (oldorg, ent->v.origin); |
} |
|
VectorCopy (vec3_origin, ent->v.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; |
int clip; |
int oldonground; |
trace_t steptrace, downtrace; |
|
// |
// do a regular slide move unless it looks like you ran into a step |
// |
oldonground = (int)ent->v.flags & FL_ONGROUND; |
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND; |
|
VectorCopy (ent->v.origin, oldorg); |
VectorCopy (ent->v.velocity, oldvel); |
|
clip = SV_FlyMove (ent, host_frametime, &steptrace); |
|
if ( !(clip & 2) ) |
return; // move didn't block on a step |
|
if (!oldonground && ent->v.waterlevel == 0) |
return; // don't stair up while jumping |
|
if (ent->v.movetype != MOVETYPE_WALK) |
return; // gibbed by a trigger |
|
if (sv_nostep.value) |
return; |
|
if ( (int)sv_player->v.flags & FL_WATERJUMP ) |
return; |
|
VectorCopy (ent->v.origin, nosteporg); |
VectorCopy (ent->v.velocity, nostepvel); |
|
// |
// try moving up and forward to go up a step |
// |
VectorCopy (oldorg, ent->v.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 |
ent->v.velocity[0] = oldvel[0]; |
ent->v. velocity[1] = oldvel[1]; |
ent->v. 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] - ent->v.origin[1]) < 0.03125 |
&& fabs(oldorg[0] - ent->v.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 (ent->v.solid == SOLID_BSP) |
{ |
ent->v.flags = (int)ent->v.flags | FL_ONGROUND; |
ent->v.groundentity = EDICT_TO_PROG(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, ent->v.origin); |
VectorCopy (nostepvel, ent->v.velocity); |
} |
} |
|
|
/* |
================ |
SV_Physics_Client |
|
Player character actions |
================ |
*/ |
void SV_Physics_Client (edict_t *ent, int num) |
{ |
if ( ! svs.clients[num-1].active ) |
return; // unconnected slot |
|
// |
// call standard client pre-think |
// |
pr_global_struct->time = sv.time; |
pr_global_struct->self = EDICT_TO_PROG(ent); |
PR_ExecuteProgram (pr_global_struct->PlayerPreThink); |
|
// |
// do a move |
// |
SV_CheckVelocity (ent); |
|
// |
// decide which move function to call |
// |
switch ((int)ent->v.movetype) |
{ |
case MOVETYPE_NONE: |
if (!SV_RunThink (ent)) |
return; |
break; |
|
case MOVETYPE_WALK: |
if (!SV_RunThink (ent)) |
return; |
if (!SV_CheckWater (ent) && ! ((int)ent->v.flags & FL_WATERJUMP) ) |
SV_AddGravity (ent); |
SV_CheckStuck (ent); |
#ifdef QUAKE2 |
VectorAdd (ent->v.velocity, ent->v.basevelocity, ent->v.velocity); |
#endif |
SV_WalkMove (ent); |
|
#ifdef QUAKE2 |
VectorSubtract (ent->v.velocity, ent->v.basevelocity, ent->v.velocity); |
#endif |
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 (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin); |
break; |
|
default: |
Sys_Error ("SV_Physics_client: bad movetype %i", (int)ent->v.movetype); |
} |
|
// |
// call standard player post-think |
// |
SV_LinkEdict (ent, true); |
|
pr_global_struct->time = sv.time; |
pr_global_struct->self = EDICT_TO_PROG(ent); |
PR_ExecuteProgram (pr_global_struct->PlayerPostThink); |
} |
|
//============================================================================ |
|
/* |
============= |
SV_Physics_None |
|
Non moving objects can only think |
============= |
*/ |
void SV_Physics_None (edict_t *ent) |
{ |
// regular thinking |
SV_RunThink (ent); |
} |
|
#ifdef QUAKE2 |
/* |
============= |
SV_Physics_Follow |
|
Entities that are "stuck" to another entity |
============= |
*/ |
void SV_Physics_Follow (edict_t *ent) |
{ |
// regular thinking |
SV_RunThink (ent); |
VectorAdd (PROG_TO_EDICT(ent->v.aiment)->v.origin, ent->v.v_angle, ent->v.origin); |
SV_LinkEdict (ent, true); |
} |
#endif |
|
/* |
============= |
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 (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles); |
VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin); |
|
SV_LinkEdict (ent, false); |
} |
|
/* |
============================================================================== |
|
TOSS / BOUNCE |
|
============================================================================== |
*/ |
|
/* |
============= |
SV_CheckWaterTransition |
|
============= |
*/ |
void SV_CheckWaterTransition (edict_t *ent) |
{ |
int cont; |
#ifdef QUAKE2 |
vec3_t point; |
|
point[0] = ent->v.origin[0]; |
point[1] = ent->v.origin[1]; |
point[2] = ent->v.origin[2] + ent->v.mins[2] + 1; |
cont = SV_PointContents (point); |
#else |
cont = SV_PointContents (ent->v.origin); |
#endif |
if (!ent->v.watertype) |
{ // just spawned here |
ent->v.watertype = cont; |
ent->v.waterlevel = 1; |
return; |
} |
|
if (cont <= CONTENTS_WATER) |
{ |
if (ent->v.watertype == CONTENTS_EMPTY) |
{ // just crossed into water |
SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1); |
} |
ent->v.watertype = cont; |
ent->v.waterlevel = 1; |
} |
else |
{ |
if (ent->v.watertype != CONTENTS_EMPTY) |
{ // just crossed into water |
SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1); |
} |
ent->v.watertype = CONTENTS_EMPTY; |
ent->v.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; |
#ifdef QUAKE2 |
edict_t *groundentity; |
|
groundentity = PROG_TO_EDICT(ent->v.groundentity); |
if ((int)groundentity->v.flags & FL_CONVEYOR) |
VectorScale(groundentity->v.movedir, groundentity->v.speed, ent->v.basevelocity); |
else |
VectorCopy(vec_origin, ent->v.basevelocity); |
SV_CheckWater (ent); |
#endif |
// regular thinking |
if (!SV_RunThink (ent)) |
return; |
|
#ifdef QUAKE2 |
if (ent->v.velocity[2] > 0) |
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND; |
|
if ( ((int)ent->v.flags & FL_ONGROUND) ) |
//@@ |
if (VectorCompare(ent->v.basevelocity, vec_origin)) |
return; |
|
SV_CheckVelocity (ent); |
|
// add gravity |
if (! ((int)ent->v.flags & FL_ONGROUND) |
&& ent->v.movetype != MOVETYPE_FLY |
&& ent->v.movetype != MOVETYPE_BOUNCEMISSILE |
&& ent->v.movetype != MOVETYPE_FLYMISSILE) |
SV_AddGravity (ent); |
|
#else |
// if onground, return without moving |
if ( ((int)ent->v.flags & FL_ONGROUND) ) |
return; |
|
SV_CheckVelocity (ent); |
|
// add gravity |
if (ent->v.movetype != MOVETYPE_FLY |
&& ent->v.movetype != MOVETYPE_FLYMISSILE) |
SV_AddGravity (ent); |
#endif |
|
// move angles |
VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles); |
|
// move origin |
#ifdef QUAKE2 |
VectorAdd (ent->v.velocity, ent->v.basevelocity, ent->v.velocity); |
#endif |
VectorScale (ent->v.velocity, host_frametime, move); |
trace = SV_PushEntity (ent, move); |
#ifdef QUAKE2 |
VectorSubtract (ent->v.velocity, ent->v.basevelocity, ent->v.velocity); |
#endif |
if (trace.fraction == 1) |
return; |
if (ent->free) |
return; |
|
if (ent->v.movetype == MOVETYPE_BOUNCE) |
backoff = 1.5; |
#ifdef QUAKE2 |
else if (ent->v.movetype == MOVETYPE_BOUNCEMISSILE) |
backoff = 2.0; |
#endif |
else |
backoff = 1; |
|
ClipVelocity (ent->v.velocity, trace.plane.normal, ent->v.velocity, backoff); |
|
// stop if on ground |
if (trace.plane.normal[2] > 0.7) |
{ |
#ifdef QUAKE2 |
if (ent->v.velocity[2] < 60 || (ent->v.movetype != MOVETYPE_BOUNCE && ent->v.movetype != MOVETYPE_BOUNCEMISSILE)) |
#else |
if (ent->v.velocity[2] < 60 || ent->v.movetype != MOVETYPE_BOUNCE) |
#endif |
{ |
ent->v.flags = (int)ent->v.flags | FL_ONGROUND; |
ent->v.groundentity = EDICT_TO_PROG(trace.ent); |
VectorCopy (vec3_origin, ent->v.velocity); |
VectorCopy (vec3_origin, ent->v.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. |
============= |
*/ |
#ifdef QUAKE2 |
void SV_Physics_Step (edict_t *ent) |
{ |
qboolean wasonground; |
qboolean inwater; |
qboolean hitsound = false; |
float *vel; |
float speed, newspeed, control; |
float friction; |
edict_t *groundentity; |
|
groundentity = PROG_TO_EDICT(ent->v.groundentity); |
if ((int)groundentity->v.flags & FL_CONVEYOR) |
VectorScale(groundentity->v.movedir, groundentity->v.speed, ent->v.basevelocity); |
else |
VectorCopy(vec_origin, ent->v.basevelocity); |
//@@ |
pr_global_struct->time = sv.time; |
pr_global_struct->self = EDICT_TO_PROG(ent); |
PF_WaterMove(); |
|
SV_CheckVelocity (ent); |
|
wasonground = (int)ent->v.flags & FL_ONGROUND; |
// ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND; |
|
// add gravity except: |
// flying monsters |
// swimming monsters who are in the water |
inwater = SV_CheckWater(ent); |
if (! wasonground) |
if (!((int)ent->v.flags & FL_FLY)) |
if (!(((int)ent->v.flags & FL_SWIM) && (ent->v.waterlevel > 0))) |
{ |
if (ent->v.velocity[2] < sv_gravity.value*-0.1) |
hitsound = true; |
if (!inwater) |
SV_AddGravity (ent); |
} |
|
if (!VectorCompare(ent->v.velocity, vec_origin) || !VectorCompare(ent->v.basevelocity, vec_origin)) |
{ |
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND; |
// apply friction |
// let dead monsters who aren't completely onground slide |
if (wasonground) |
if (!(ent->v.health <= 0.0 && !SV_CheckBottom(ent))) |
{ |
vel = ent->v.velocity; |
speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]); |
if (speed) |
{ |
friction = sv_friction.value; |
|
control = speed < sv_stopspeed.value ? sv_stopspeed.value : speed; |
newspeed = speed - host_frametime*control*friction; |
|
if (newspeed < 0) |
newspeed = 0; |
newspeed /= speed; |
|
vel[0] = vel[0] * newspeed; |
vel[1] = vel[1] * newspeed; |
} |
} |
|
VectorAdd (ent->v.velocity, ent->v.basevelocity, ent->v.velocity); |
SV_FlyMove (ent, host_frametime, NULL); |
VectorSubtract (ent->v.velocity, ent->v.basevelocity, ent->v.velocity); |
|
// determine if it's on solid ground at all |
{ |
vec3_t mins, maxs, point; |
int x, y; |
|
VectorAdd (ent->v.origin, ent->v.mins, mins); |
VectorAdd (ent->v.origin, ent->v.maxs, maxs); |
|
point[2] = mins[2] - 1; |
for (x=0 ; x<=1 ; x++) |
for (y=0 ; y<=1 ; y++) |
{ |
point[0] = x ? maxs[0] : mins[0]; |
point[1] = y ? maxs[1] : mins[1]; |
if (SV_PointContents (point) == CONTENTS_SOLID) |
{ |
ent->v.flags = (int)ent->v.flags | FL_ONGROUND; |
break; |
} |
} |
|
} |
|
SV_LinkEdict (ent, true); |
|
if ((int)ent->v.flags & FL_ONGROUND) |
if (!wasonground) |
if (hitsound) |
SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1); |
} |
|
// regular thinking |
SV_RunThink (ent); |
SV_CheckWaterTransition (ent); |
} |
#else |
void SV_Physics_Step (edict_t *ent) |
{ |
qboolean hitsound; |
|
// freefall if not onground |
if ( ! ((int)ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) ) |
{ |
if (ent->v.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 ( (int)ent->v.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); |
} |
#endif |
|
//============================================================================ |
|
/* |
================ |
SV_Physics |
|
================ |
*/ |
void SV_Physics (void) |
{ |
int i; |
edict_t *ent; |
|
// let the progs know that a new frame has started |
pr_global_struct->self = EDICT_TO_PROG(sv.edicts); |
pr_global_struct->other = EDICT_TO_PROG(sv.edicts); |
pr_global_struct->time = sv.time; |
PR_ExecuteProgram (pr_global_struct->StartFrame); |
|
//SV_CheckAllEnts (); |
|
// |
// treat each object in turn |
// |
ent = sv.edicts; |
for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent)) |
{ |
if (ent->free) |
continue; |
|
if (pr_global_struct->force_retouch) |
{ |
SV_LinkEdict (ent, true); // force retouch even for stationary |
} |
|
if (i > 0 && i <= svs.maxclients) |
SV_Physics_Client (ent, i); |
else if (ent->v.movetype == MOVETYPE_PUSH) |
SV_Physics_Pusher (ent); |
else if (ent->v.movetype == MOVETYPE_NONE) |
SV_Physics_None (ent); |
#ifdef QUAKE2 |
else if (ent->v.movetype == MOVETYPE_FOLLOW) |
SV_Physics_Follow (ent); |
#endif |
else if (ent->v.movetype == MOVETYPE_NOCLIP) |
SV_Physics_Noclip (ent); |
else if (ent->v.movetype == MOVETYPE_STEP) |
SV_Physics_Step (ent); |
else if (ent->v.movetype == MOVETYPE_TOSS |
|| ent->v.movetype == MOVETYPE_BOUNCE |
#ifdef QUAKE2 |
|| ent->v.movetype == MOVETYPE_BOUNCEMISSILE |
#endif |
|| ent->v.movetype == MOVETYPE_FLY |
|| ent->v.movetype == MOVETYPE_FLYMISSILE) |
SV_Physics_Toss (ent); |
else |
Sys_Error ("SV_Physics: bad movetype %i", (int)ent->v.movetype); |
} |
|
if (pr_global_struct->force_retouch) |
pr_global_struct->force_retouch--; |
|
sv.time += host_frametime; |
} |
|
|
#ifdef QUAKE2 |
trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore) |
{ |
edict_t tempent, *tent; |
trace_t trace; |
vec3_t move; |
vec3_t end; |
double save_frametime; |
// extern particle_t *active_particles, *free_particles; |
// particle_t *p; |
|
|
save_frametime = host_frametime; |
host_frametime = 0.05; |
|
memcpy(&tempent, ent, sizeof(edict_t)); |
tent = &tempent; |
|
while (1) |
{ |
SV_CheckVelocity (tent); |
SV_AddGravity (tent); |
VectorMA (tent->v.angles, host_frametime, tent->v.avelocity, tent->v.angles); |
VectorScale (tent->v.velocity, host_frametime, move); |
VectorAdd (tent->v.origin, move, end); |
trace = SV_Move (tent->v.origin, tent->v.mins, tent->v.maxs, end, MOVE_NORMAL, tent); |
VectorCopy (trace.endpos, tent->v.origin); |
|
// p = free_particles; |
// if (p) |
// { |
// free_particles = p->next; |
// p->next = active_particles; |
// active_particles = p; |
// |
// p->die = 256; |
// p->color = 15; |
// p->type = pt_static; |
// VectorCopy (vec3_origin, p->vel); |
// VectorCopy (tent->v.origin, p->org); |
// } |
|
if (trace.ent) |
if (trace.ent != ignore) |
break; |
} |
// p->color = 224; |
host_frametime = save_frametime; |
return trace; |
} |
#endif |