/*
=============
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.
FIXME: is this true?
=============
*/
void SV_Physics_Step (edict_t *ent)
{
qbool hitsound;
// frefall if not onground
if ( ! ((int)ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) )
{
if (ent->v.velocity[2] < sv.movevars.gravity*-0.1)
hitsound = true;
else
hitsound = false;
SV_AddGravity (ent, 1.0);
SV_CheckVelocity (ent);
// Tonik: the check for SOLID_NOT is to fix the way dead bodies and
// gibs behave (should not be blocked by players & monsters);
// The SOLID_TRIGGER check is disabled lest we break frikbots
if (ent->v.solid == SOLID_NOT /* || ent->v.solid == SOLID_TRIGGER*/)
SV_FlyMove (ent, sv_frametime, NULL, MOVE_NOMONSTERS);
else
SV_FlyMove (ent, sv_frametime, NULL, MOVE_NORMAL);
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, NULL);
}
}
// regular thinking
SV_RunThink (ent);
SV_CheckWaterTransition (ent);
}
/* 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;
Math_VectorCopy (ent->v.origin, oldorg);
Math_VectorCopy (mv3Origin, 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.1f,&steptrace);
if ( fabs(oldorg[1] - ent->v.origin[1]) > 4
|| fabs(oldorg[0] - ent->v.origin[0]) > 4 )
return clip;
// Go back to the original pos and try again
Math_VectorCopy (oldorg, ent->v.origin);
}
Math_VectorCopy(mv3Origin,ent->v.velocity);
return 7; // still not moving
}
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);
}
/* 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.self = EDICT_TO_PROG(ent);
Game->Game_Init(SERVER_PLAYERPRETHINK,ent,sv.time);
Game->Physics_CheckVelocity(ent);
// decide which move function to call
switch(ent->v.movetype)
{
case MOVETYPE_NONE:
if (!Server_RunThink(ent))
return;
break;
case MOVETYPE_WALK:
if(!Server_RunThink(ent))
return;
if(!Physics_CheckWater(ent) && !(ent->v.flags & FL_WATERJUMP))
Game->Physics_SetGravity(ent);
SV_CheckStuck (ent);
SV_WalkMove (ent);
break;
case MOVETYPE_TOSS:
case MOVETYPE_BOUNCE:
case MOVETYPE_FLYBOUNCE:
Physics_Toss(ent);
break;
case MOVETYPE_FLY:
if(!Server_RunThink(ent))
return;
SV_FlyMove(ent,host_frametime,NULL);
break;
case MOVETYPE_NOCLIP:
if(!Server_RunThink(ent))
return;
Math_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.self = EDICT_TO_PROG(ent);
Game->Game_Init(SERVER_CLIENTPOSTTHINK,ent,sv.time);
}
/*
=============
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)
{
qboolean hitsound;
char *snd;
// 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
#ifdef HEXEN2_SUPPORT
if (!hexen2 || (!ent->v.flags & FL_MONSTER))
#endif
{
if (hitsound)
{
#ifdef HEXEN2_SUPPORT
if (hexen2)
snd = "fx/thngland.wav";
else
#endif
snd = "demon/dland2.wav";
SV_StartSound (ent, 0, snd, 255, 1);
}
}
}
// regular thinking
SV_RunThink (ent);
SV_CheckWaterTransition (ent);
}
/* 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 Physics_Step(edict_t *ent)
{
// Freefall if not onground
if(!(ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM)))
{
#if 0
// [19/3/2013] TODO: Replace! ~hogsy
if(ent->v.velocity[2] < Cvar_VariableValue("server_gravityamount")*-0.1f) //sv_gravity.value*-0.1f)
bHitSound = true;
#endif
Game->Physics_SetGravity(ent);
Game->Physics_CheckVelocity(ent);
SV_FlyMove(ent,host_frametime,NULL);
SV_LinkEdict(ent,true);
}
// Regular thinking
Server_RunThink(ent);
Game->Physics_CheckWaterTransition(ent);
}
/*
================
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);
SV_WalkMove (ent);
break;
case MOVETYPE_TOSS:
case MOVETYPE_BOUNCE:
SV_Physics_Toss (ent);
break;
case MOVETYPE_FLY:
if (!SV_RunThink (ent))
return;
SV_CheckWater (ent);
SV_FlyMove (ent, host_frametime, NULL);
break;
case MOVETYPE_NOCLIP:
if (!SV_RunThink (ent))
return;
ent->v.waterlevel = 0; // Avoid annoying waterjumps in noclip
ent->v.watertype = CONTENTS_EMPTY; // Avoid annoying waterjumps in noclip
VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
break;
default:
Host_Error ("SV_Physics_client: bad movetype %i", (int)ent->v.movetype);
}
//
// call standard player post-think
//
if (ent->v.movetype == MOVETYPE_NOCLIP)
SV_LinkEdict (ent, false); // don't touch triggers in noclip
else
SV_LinkEdict (ent, true);
pr_global_struct->time = sv.time;
pr_global_struct->self = EDICT_TO_PROG(ent);
PR_ExecuteProgram (pr_global_struct->PlayerPostThink);
}
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);
}
/*
================
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 = ((int)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 = ((int)EDICT_TO_PROG(ent));
PR_ExecuteProgram (pr_global_struct->PlayerPostThink);
}
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 = ((int)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);
}
}
void SV_Physics_Step (edict_t *ent)
{
qboolean wasonground;
qboolean hitsound = false;
float *vel;
float speed, newspeed, control;
float friction;
edict_t *groundentity;
int mask;
// airborn monsters should always check for ground
if (!ent->groundentity)
M_CheckGround (ent);
groundentity = ent->groundentity;
SV_CheckVelocity (ent);
if (groundentity)
wasonground = true;
else
wasonground = false;
if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
SV_AddRotationalFriction (ent);
// add gravity except:
// flying monsters
// swimming monsters who are in the water
if (! wasonground)
if (!(ent->flags & FL_FLY))
if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2)))
{
if (ent->velocity[2] < sv_gravity->value*-0.1)
hitsound = true;
if (ent->waterlevel == 0)
SV_AddGravity (ent);
}
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed->value ? sv_stopspeed->value : speed;
friction = sv_friction/3;
newspeed = speed - (FRAMETIME * control * friction);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed->value ? sv_stopspeed->value : speed;
newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0])
{
// apply friction
// let dead monsters who aren't completely onground slide
if ((wasonground) || (ent->flags & (FL_SWIM|FL_FLY)))
if (!(ent->health <= 0.0 && !M_CheckBottom(ent)))
{
vel = ent->velocity;
speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]);
if (speed)
{
friction = sv_friction;
control = speed < sv_stopspeed->value ? sv_stopspeed->value : speed;
newspeed = speed - FRAMETIME*control*friction;
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
vel[0] *= newspeed;
vel[1] *= newspeed;
}
}
if (ent->svflags & SVF_MONSTER)
mask = MASK_MONSTERSOLID;
else
mask = MASK_SOLID;
SV_FlyMove (ent, FRAMETIME, mask);
gi.linkentity (ent);
// ========
// PGM - reset this every time they move.
// G_touchtriggers will set it back if appropriate
ent->gravity = 1.0;
// ========
G_TouchTriggers (ent);
if (!ent->inuse)
return;
if (ent->groundentity)
if (!wasonground)
if (hitsound)
gi.sound (ent, 0, gi.soundindex("world/land.wav"), 1, 1, 0);
}
if(!ent->inuse) // PGM g_touchtrigger free problem
return;
// regular thinking
SV_RunThink (ent);
}
/*
=============
SV_Physics_NewToss
Toss, bounce, and fly movement. When on ground and no velocity, do nothing. With velocity,
slide.
=============
*/
void SV_Physics_NewToss (edict_t *ent)
{
trace_t trace;
vec3_t move;
// float backoff;
edict_t *slave;
qboolean wasinwater;
qboolean isinwater;
qboolean wasonground;
float speed, newspeed;
vec3_t old_origin;
// float firstmove;
// int mask;
// regular thinking
SV_RunThink (ent);
// if not a team captain, so movement will be handled elsewhere
if ( ent->flags & FL_TEAMSLAVE)
return;
if (ent->groundentity)
wasonground = true;
else
wasonground = false;
wasinwater = ent->waterlevel;
// find out what we're sitting on.
VectorCopy (ent->s.origin, move);
move[2] -= 0.25;
trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, move, ent, ent->clipmask);
if(ent->groundentity && ent->groundentity->inuse)
ent->groundentity = trace.ent;
else
ent->groundentity = NULL;
// if we're sitting on something flat and have no velocity of our own, return.
if (ent->groundentity && (trace.plane.normal[2] == 1.0) &&
!ent->velocity[0] && !ent->velocity[1] && !ent->velocity[2])
{
return;
}
// store the old origin
VectorCopy (ent->s.origin, old_origin);
SV_CheckVelocity (ent);
// add gravity
SV_AddGravity (ent);
if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
SV_AddRotationalFriction (ent);
// add friction
speed = VectorLength(ent->velocity);
if(ent->waterlevel) // friction for water movement
{
newspeed = speed - (sv_waterfriction * 6 * ent->waterlevel);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
VectorScale (ent->velocity, newspeed, ent->velocity);
}
else if (!ent->groundentity) // friction for air movement
{
newspeed = speed - ((sv_friction));
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
VectorScale (ent->velocity, newspeed, ent->velocity);
}
else // use ground friction
{
newspeed = speed - (sv_friction * 6);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
VectorScale (ent->velocity, newspeed, ent->velocity);
}
SV_FlyMove (ent, FRAMETIME, ent->clipmask);
gi.linkentity (ent);
G_TouchTriggers (ent);
// check for water transition
wasinwater = (ent->watertype & MASK_WATER);
ent->watertype = gi.pointcontents (ent->s.origin);
isinwater = ent->watertype & MASK_WATER;
if (isinwater)
ent->waterlevel = 1;
else
ent->waterlevel = 0;
if (!wasinwater && isinwater)
gi.positioned_sound (old_origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
else if (wasinwater && !isinwater)
gi.positioned_sound (ent->s.origin, g_edicts, CHAN_AUTO, gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
// move teamslaves
for (slave = ent->teamchain; slave; slave = slave->teamchain)
{
VectorCopy (ent->s.origin, slave->s.origin);
gi.linkentity (slave);
}
}
void SV_Physics_Step (edict_t *ent)
{
qboolean wasonground;
qboolean hitsound = false;
float *vel;
float speed, newspeed, control;
float friction;
edict_t *groundentity;
int mask;
int retval;
vec3_t oldpos;
// BEGIN: Xatrix/Ridah
vec3_t old_vel;
// END: Xatrix/Ridah
// Joseph
if (ent->fallerflag)
{
// Fix if sitting off center
think_checkedges(ent);
}
// airborn monsters should always check for ground
if (!ent->groundentity)
M_CheckGround (ent);
groundentity = ent->groundentity;
SV_CheckVelocity (ent);
if (groundentity)
wasonground = true;
else
wasonground = false;
if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
SV_AddRotationalFriction (ent);
// add gravity except:
// flying monsters
// swimming monsters who are in the water
if (! wasonground)
if (!(ent->flags & FL_FLY))
if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2)))
{
if (ent->velocity[2] < sv_gravity->value*-0.1)
hitsound = true;
// Ridah, 1-may-99, disabled this to prevent guys getting stuck in water
// if (ent->waterlevel == 0)
SV_AddGravity (ent);
}
/*
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
friction = sv_friction/3;
newspeed = speed - (FRAMETIME * control * friction);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
*/
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0])
{
// apply friction
// let dead monsters who aren't completely onground slide
if ((wasonground) || (ent->flags & (FL_SWIM|FL_FLY)))
if (!(ent->health <= 0.0 && !M_CheckBottom(ent)))
{
vel = ent->velocity;
speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]);
if (speed)
{
friction = sv_friction;
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - FRAMETIME*control*friction;
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
vel[0] *= newspeed;
vel[1] *= newspeed;
}
}
// BEGIN: Xatrix/Ridah
// JOSEPH 26-APR-99
if ((ent->svflags & SVF_MONSTER) || (ent->monsterprop))
// END JOSEPH
{
// if (ent->cast_info.aiflags & AI_PLAYERCLIP)
mask = MASK_PLAYERSOLID | CONTENTS_MONSTERCLIP;
// else
// mask = MASK_MONSTERSOLID;
}
else
mask = MASK_SOLID;
VectorCopy (ent->velocity, old_vel);
// END: Xatrix/Ridah
VectorCopy (ent->s.origin, oldpos );
retval = SV_FlyMove (ent, FRAMETIME, mask);
#if 0 // leave this here for now.
// Ridah, HACK... sometimes they get stuck, we should debug this properly when we get the time
if (!ValidBoxAtLoc( ent->s.origin, ent->mins, ent->maxs, ent, MASK_SOLID ))
{ // move back to old position and clear velocity
int iter=0;
VectorCopy (oldpos, ent->s.origin);
VectorClear (ent->velocity);
// find a good position
while (!ValidBoxAtLoc( ent->s.origin, ent->mins, ent->maxs, ent, MASK_SOLID ))
{
VectorAdd( ent->s.origin, tv((random()-0.5) * 64, (random()-0.5) * 64, (random()-0.5) * 64), ent->s.origin );
if (++iter > 10)
break;
}
// if (iter <= 4)
// { // make sure they're on the ground
// M_droptofloor( ent );
// }
goto exit_vel_check; // get out of here?
}
#endif
// BEGIN: Xatrix/Ridah
if (!ent->groundentity || (ent->flags & FL_FLY))
{
node_t *land_node;
// Ridah, prevent guys getting stuck trying to jump
if (VectorDistance( ent->s.origin, oldpos ) < 1 && !ent->groundentity && (ent->last_onground < (level.time - 2)))
{
ent->velocity[0] = crandom() * 300;
ent->velocity[1] = crandom() * 300;
if (ent->velocity[2] < -200)
ent->velocity[2] = -200;
ent->velocity[2] += random() * 350;
ent->nav_data.goal_index = 0;
ent->last_onground = level.time;
}
if (ent->velocity[2] > 80 && retval != 20)
{ // while rising, maintain XY velocity
ent->velocity[0] = old_vel[0];
ent->velocity[1] = old_vel[1];
}
// see if we've gone passed the landing position
if ( !(ent->flags & FL_FLY)
&& (retval == -1) && (ent->nav_data.goal_index)
&& (land_node = level.node_data->nodes[ent->nav_data.goal_index-1]))
// && (land_node->node_type & NODE_LANDING))
{
vec3_t unit_vel, goal_dir, goal_vec;
float vel_scale, dist;
VectorSubtract( land_node->origin, ent->s.origin, goal_vec );
goal_vec[2] = 0;
dist = VectorNormalize2( goal_vec, goal_dir );
if (dist > 16)
{
VectorCopy( ent->velocity, unit_vel );
unit_vel[2] = 0;
vel_scale = VectorNormalize( unit_vel );
if (DotProduct( unit_vel, goal_dir ) < 0.8)
{ // we've either gone passed, or need some correction
vec3_t new_pos;
float old_z;
if (VectorLength( goal_vec ) < 40)
{
new_pos[0] = land_node->origin[0];
new_pos[1] = land_node->origin[1];
new_pos[2] = ent->s.origin[2];
if (ValidBoxAtLoc( new_pos, ent->mins, ent->maxs, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID ))
{ // move there, it's safe, and clear velocity
VectorCopy( new_pos, ent->s.origin );
ent->velocity[0] = ent->velocity[1] = 0;
goto exit_vel_check;
}
}
// we need to adjust our velocity
if (land_node->origin[2] < (ent->s.origin[2] - 64))
{
old_z = ent->velocity[2];
VectorScale( goal_dir, vel_scale, ent->velocity );
ent->velocity[2] = old_z;
}
}
}
}
if ( (ent->flags & FL_FLY)
&& ((land_node = level.node_data->nodes[ent->nav_data.goal_index-1]) || ((ent->flags &= ~FL_FLY) && false))
/*&& (land_node->node_type & NODE_LANDING)*/)
{ // if climbing ladder, and we're reached the landing position, stop
// Ridah, 8-jun-99, make sure dog's don't climb ladders
if (!ent->gender)
{
goto abort_climb;
}
if (ent->s.origin[2] > land_node->origin[2])
{
//gi.dprintf( "-> end of climb\n" );
// VectorSubtract( land_node->origin, ent->s.origin, ent->velocity );
AngleVectors( ent->s.angles, ent->velocity, NULL, NULL );
ent->velocity[2] = 0;
VectorNormalize( ent->velocity );
VectorScale( ent->velocity, 96, ent->velocity );
ent->velocity[2] = 200;
ent->flags &= ~FL_FLY;
ent->nav_data.goal_index = 0; // look for a new node
ent->nav_data.cache_node = -1;
if (ent->cast_info.move_end_climb)
ent->cast_info.currentmove = ent->cast_info.move_end_climb;
}
else
{
trace_t tr;
vec3_t end, goal_vec;
VectorSubtract( land_node->origin, ent->s.origin, goal_vec );
ent->velocity[0] = goal_vec[0];
ent->velocity[1] = goal_vec[1];
ent->velocity[2] = 120;
// if another character is above us, abort
VectorCopy( ent->s.origin, end );
end[2] += 128;
tr = gi.trace( ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID );
if ((tr.fraction < 1) && (tr.ent->svflags & SVF_MONSTER))
{
abort_climb:
AngleVectors( ent->s.angles, goal_vec, NULL, NULL );
VectorScale( goal_vec, -64, ent->velocity );
ent->flags &= ~FL_FLY;
ent->nav_data.goal_index = 0;
if (ent->cast_info.move_end_climb)
{
ent->cast_info.currentmove = ent->cast_info.move_end_climb;
}
else if (ent->cast_info.move_jump)
{
ent->cast_info.currentmove = ent->cast_info.move_jump;
}
}
else if (ent->s.origin[2] > (land_node->origin[2] - 48))
{ // we're near the top, stopping climbing anim
//gi.dprintf( "near end of climb\n" );
if (ent->cast_info.move_end_climb)
ent->cast_info.currentmove = ent->cast_info.move_end_climb;
// add some forward momentum
AngleVectors( ent->s.angles, goal_vec, NULL, NULL );
VectorMA( ent->velocity, 64, goal_vec, ent->velocity );
}
}
}
}
exit_vel_check:
// END: Xatrix/Ridah
gi.linkentity (ent);
G_TouchTriggers (ent);
// Note to Ryan: we can't use this because we are playing specific sounds elsewhere
/*
if (ent->groundentity)
if (!wasonground)
if (hitsound)
// BEGIN: Xatrix/Ridah/Navigator/03-apr-1998
if (!(ent->cast_info.move_run))
// END: Xatrix/Ridah/Navigator/03-apr-1998
gi.sound (ent, 0, gi.soundindex("world/land.wav"), 1, 1, 0);
*/
}
// regular thinking
SV_RunThink (ent);
}
/*
================
SV_Physics_Client
Player character actions
================
*/
void SV_Physics_Client (edict_t *ent, int num)
{
client_t *cl;
vec3_t v;
qboolean was_angle_set;
cl = &svs.clients[num-1];
if (!cl->active)
return; // unconnected slot
// call standard client pre-think
PR_GLOBAL(time) = sv.time;
PR_GLOBAL(self) = EDICT_TO_PROG(ent);
PR_ExecuteProgram (PR_GLOBAL(PlayerPreThink));
// for cutscene hack (see below)
if (isDedicated || (num != 1))
was_angle_set = false; // do it on local client only
else
was_angle_set = (ent->v.fixangle != 0);
// 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);
SV_WalkMove (ent);
break;
case MOVETYPE_TOSS:
case MOVETYPE_BOUNCE:
SV_Physics_Toss (ent);
break;
case MOVETYPE_FLY:
#ifdef HEXEN2_SUPPORT
case MOVETYPE_SWIM:
#endif
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);
}
// JDH: hack for cutscenes made by Darin McNeil's Cutscene Construction Kit:
// (note that the extra precision is noticeable only if the viewangles
// are sent from server to client as 2-byte values; hence the addition
// of the new svc_setpreciseangle message code)
if (was_angle_set && (ent->v.view_ofs[2] == 0) && host_cutscenehack.value
&& !strcmp (pr_strings + ent->v.classname, "camera"))
{
// - when camera changes back to player, classname remains "camera" for
// 1 frame, but movedir is no longer valid. So as an additional check,
// I verify that view_ofs[2] is still 0
// - early version(s?) of Cutscene Construction Kit don't move the camera,
// so movedir is not used. I determine the version by checking *when*
// the viewangle is set: early version does it in the .think function;
// later ones in PlayerPreThink. was_angle_set will be true only if
// it was changed in PlayerPreThink
//if (!sv_oldprotocol.value)
{
v[0] = ent->v.movedir[0] - ent->v.origin[0];
v[1] = ent->v.movedir[1] - ent->v.origin[1];
v[2] = ent->v.origin[2] - ent->v.movedir[2];
//vectoangles (v, ent->v.angles);
vectoangles (v, cl->cutscene_viewangles);
}
if (!cl->in_cutscene)
{
int i;
edict_t *ed;
// by this time, the player's viewangles have already been changed.
// But the dummy entity spawned in place of the player has the values
for (i = 1 ; i < sv.num_edicts ; i++)
{
// get the current server version
ed = EDICT_NUM(i);
if (ed->free)
continue;
if (!strcmp(pr_strings + ed->v.classname, "dummy"))
{
VectorCopy (ed->v.angles, cl->prev_viewangles);
break;
}
}
cl->in_cutscene = true;
}
//sv.found_cutscene = true;
}
else
{
if (cl->in_cutscene)
{
// I'm not sure why, but last viewangle while in_cutscene isn't final angle
ent->v.fixangle = 1;
VectorCopy (cl->prev_viewangles, ent->v.angles);
cl->in_cutscene = false;
}
}
SV_LinkEdict (ent, true);
PR_GLOBAL(time) = sv.time;
PR_GLOBAL(self) = EDICT_TO_PROG(ent);
// JDH: another hack, this time for progs that lack CycleWeaponReverse
if ((ent->v.impulse == 12.0) && ((sv_imp12hack.value >= 2) || (sv_imp12hack.value && !pr_handles_imp12)) &&
!ent->v.deadflag && (ent->v.view_ofs[0] || ent->v.view_ofs[1] || ent->v.view_ofs[2]))
{
eval_t *val = GETEDICTFIELD(ent, eval_attack_finished);
if (val && (sv.time >= val->_float))
{
SV_CycleWeaponReverse (ent);
}
}
// call standard player post-think
PR_ExecuteProgram (PR_GLOBAL(PlayerPostThink));
}
void SV_Physics_Step (edict_t *ent)
{
bool wasonground;
bool hitsound = false;
float *vel;
float speed, newspeed, control;
float friction;
edict_t *groundentity;
int mask;
// airborn monsters should always check for ground
if (!ent->groundentity)
M_CheckGround (ent);
groundentity = ent->groundentity;
SV_CheckVelocity (ent);
if (groundentity)
wasonground = true;
else
wasonground = false;
if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
SV_AddRotationalFriction (ent);
// add gravity except:
// flying monsters
// swimming monsters who are in the water
if (! wasonground)
if (!(ent->flags & FL_FLY))
if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2)))
{
if (ent->velocity[2] < level.gravity*-0.1)
hitsound = true;
if (ent->waterlevel == 0)
SV_AddGravity (ent);
}
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
friction = sv_friction/3;
newspeed = speed - (FRAMETIME * control * friction);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0])
{
// apply friction
// let dead monsters who aren't completely onground slide
if ((wasonground) || (ent->flags & (FL_SWIM|FL_FLY)))
if (!(ent->health <= 0.0 && !M_CheckBottom(ent)))
{
vel = ent->velocity;
speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]);
if (speed)
{
friction = sv_friction;
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - FRAMETIME*control*friction;
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
vel[0] *= newspeed;
vel[1] *= newspeed;
}
}
if (ent->r.svflags & SVF_MONSTER)
mask = MASK_MONSTERSOLID;
else
mask = MASK_SOLID;
SV_FlyMove (ent, FRAMETIME, mask);
GClip_LinkEntity (ent);
GClip_TouchTriggers (ent);
if (ent->groundentity)
if (!wasonground)
if (hitsound)
G_Sound (ent, 0, trap_SoundIndex( S_LAND ), ATTN_NORM);
}
}
/*
=============
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 )
{
qboolean inwater;
qboolean wasonground;
qboolean wasonmover;
vec3_t mins, maxs;
vec3_t point;
trace_t trace;
int x, y;
SV_WaterMove( ent );
SV_CheckVelocity( ent );
wasonground = (ent->v.flags & FL_ONGROUND);
wasonmover = SV_CheckMover( ent );
inwater = SV_CheckWater( ent );
if( ent->v.flags & FL_FLOAT && ent->v.waterlevel > 0 )
{
float buoyancy = SV_Submerged( ent ) * ent->v.skin * host.frametime;
SV_AddGravity( ent );
ent->v.velocity[2] += buoyancy;
}
if( !wasonground && !( ent->v.flags & FL_FLY ) && (!( ent->v.flags & FL_SWIM ) || ent->v.waterlevel <= 0 ))
{
if( !inwater )
SV_AddGravity( ent );
}
if( !VectorIsNull( ent->v.velocity ) || !VectorIsNull( ent->v.basevelocity ))
{
ent->v.flags &= ~FL_ONGROUND;
if(( wasonground || wasonmover ) && ( ent->v.health > 0 || SV_CheckBottom( ent, MOVE_NORMAL )))
{
float *vel = ent->v.velocity;
float control, speed, newspeed;
float friction;
speed = sqrt(( vel[0] * vel[0] ) + ( vel[1] * vel[1] )); // DotProduct2D
if( speed )
{
friction = sv_friction->value * ent->v.friction; // factor
ent->v.friction = 1.0f; // g-cont. ???
if( wasonmover ) friction *= 0.5f; // add a little friction
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_CheckVelocity( ent );
SV_FlyMove( ent, host.frametime, NULL );
if( ent->free ) return;
SV_CheckVelocity( ent );
VectorSubtract( ent->v.velocity, ent->v.basevelocity, ent->v.velocity );
SV_CheckVelocity( ent );
VectorAdd( ent->v.origin, ent->v.mins, mins );
VectorAdd( ent->v.origin, ent->v.maxs, maxs );
point[2] = mins[2] - 1.0f;
for( x = 0; x <= 1; x++ )
{
if( ent->v.flags & FL_ONGROUND )
break;
for( y = 0; y <= 1; y++ )
{
point[0] = x ? maxs[0] : mins[0];
point[1] = y ? maxs[1] : mins[1];
trace = SV_Move( point, vec3_origin, vec3_origin, point, MOVE_NORMAL, ent );
if( trace.startsolid )
{
ent->v.flags |= FL_ONGROUND;
ent->v.groundentity = trace.ent;
ent->v.friction = 1.0f;
break;
}
}
}
SV_LinkEdict( ent, true );
}
else
{
if( svgame.globals->force_retouch != 0 )
{
trace = SV_Move( ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, MOVE_NORMAL, ent );
// hentacle impact code
if(( trace.fraction < 1.0f || trace.startsolid ) && SV_IsValidEdict( trace.ent ))
{
SV_Impact( ent, trace.ent, &trace );
if( ent->free ) return;
}
}
}
if( !SV_RunThink( ent )) return;
SV_CheckWaterTransition( ent );
}
void SV_Physics_Step (edict_t *ent)
{
qboolean wasonground;
qboolean hitsound = false;
float *vel;
float speed, newspeed, control;
float friction;
edict_t *groundentity;
int mask;
// vec3_t dir;
// airborn monsters should always check for ground
// if (!ent->groundentity)
M_CheckGround (ent);
groundentity = ent->groundentity;
SV_CheckVelocity (ent);
if (groundentity)
wasonground = true;
else
wasonground = false;
// if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
// SV_AddRotationalFriction (ent);
// add gravity except:
// flying monsters
// swimming monsters who are in the water
if (! wasonground)
if (!(ent->flags & FL_FLY))
if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2)))
{
if (ent->velocity[2] < sv_gravity->value*-0.1)
hitsound = true;
if (ent->waterlevel == 0)
SV_AddGravity (ent);
}
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0))
{
//gi.bprintf(PRINT_HIGH,"FLY!\n");
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
friction = sv_friction/3;
newspeed = speed - (FRAMETIME * control * friction);
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
// friction for flying monsters that have been given vertical velocity
if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0))
{
//gi.bprintf(PRINT_HIGH,"SWIM!\n");
//K03 Begin
float water_friction;
//K03 End
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
//K03 Begin
water_friction=(FRAMETIME * control * sv_waterfriction * ent->waterlevel);
//newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel);
if ((ent->myskills.abilities[SUPER_SPEED].current_level < 1) || (ent->myskills.abilities[SUPER_SPEED].disable))
newspeed = speed;
else
newspeed = speed - water_friction;
//K03 End
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0])
{
// apply friction
// let dead monsters who aren't completely onground slide
if ((wasonground) || (ent->flags & (FL_SWIM|FL_FLY)))
if (!(ent->health <= 0.0 && !M_CheckBottom(ent)))
{
//K03 Begin
float water_friction;
//K03 End
vel = ent->velocity;
speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1]);
if (speed)
{
friction = sv_friction;
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - FRAMETIME*control*friction;
//K03 Begin
water_friction=FRAMETIME*control*friction;
//newspeed = speed - FRAMETIME*control*friction;
if ( ((ent->myskills.abilities[SUPER_SPEED].current_level < 1) || (ent->myskills.abilities[SUPER_SPEED].disable))
&& !(ent->flags & FL_SWIM))
newspeed = speed;
else
newspeed = speed - water_friction;
//K03 End
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
vel[0] *= newspeed;
vel[1] *= newspeed;
}
}
if (ent->svflags & SVF_MONSTER)
{
if(!deathmatch->value) mask = MASK_MONSTERSOLID;
else mask = MASK_BOTSOLIDX;//MASK_PLAYERSOLID;
}
else
mask = MASK_SOLID;
//FIXME: warning - SV_FlyMove() can cause an entity to be freed
SV_FlyMove (ent, FRAMETIME, mask);
gi.linkentity (ent);
// G_TouchTriggers (ent);
}
else
V_TouchSolids(ent);
// regular thinking
SV_RunThink (ent);
}
void SV_Physics_Step (edict_t *ent)
{
qboolean wasonground;
qboolean hitsound = false;
float *vel;
float speed, newspeed, control;
float friction;
edict_t *groundentity;
int mask;
if (!ent)
{
return;
}
/* airborn monsters should always check for ground */
if (!ent->groundentity)
{
M_CheckGround(ent);
}
groundentity = ent->groundentity;
SV_CheckVelocity(ent);
if (groundentity)
{
wasonground = true;
}
else
{
wasonground = false;
}
if (ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
{
SV_AddRotationalFriction(ent);
}
/* add gravity except:
- flying monsters
- swimming monsters who are in the water */
if (!wasonground)
{
if (!(ent->flags & FL_FLY))
{
if (!((ent->flags & FL_SWIM) && (ent->waterlevel > 2)))
{
if (ent->velocity[2] < sv_gravity->value * -0.1)
{
hitsound = true;
}
if (ent->waterlevel == 0)
{
SV_AddGravity(ent);
}
}
}
}
/* friction for flying monsters that have been given vertical velocity */
if ((ent->flags & FL_FLY) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
friction = sv_friction / 3;
newspeed = speed - (FRAMETIME * control * friction);
if (newspeed < 0)
{
newspeed = 0;
}
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
/* friction for flying monsters that have been given vertical velocity */
if ((ent->flags & FL_SWIM) && (ent->velocity[2] != 0))
{
speed = fabs(ent->velocity[2]);
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - (FRAMETIME * control * sv_waterfriction * ent->waterlevel);
if (newspeed < 0)
{
newspeed = 0;
}
newspeed /= speed;
ent->velocity[2] *= newspeed;
}
if (ent->velocity[2] || ent->velocity[1] || ent->velocity[0])
{
/* let dead monsters who aren't completely onground slide */
if ((wasonground) || (ent->flags & (FL_SWIM | FL_FLY)))
{
if (!((ent->health <= 0.0) && !M_CheckBottom(ent)))
{
vel = ent->velocity;
speed = sqrt(vel[0] * vel[0] + vel[1] * vel[1]);
if (speed)
{
friction = sv_friction;
control = speed < sv_stopspeed ? sv_stopspeed : speed;
newspeed = speed - FRAMETIME * control * friction;
if (newspeed < 0)
{
newspeed = 0;
}
newspeed /= speed;
vel[0] *= newspeed;
vel[1] *= newspeed;
}
}
}
if (ent->svflags & SVF_MONSTER)
{
mask = MASK_MONSTERSOLID;
}
else
{
mask = MASK_SOLID;
}
SV_FlyMove(ent, FRAMETIME, mask);
gi.linkentity(ent);
G_TouchTriggers(ent);
if (!ent->inuse)
{
return;
}
if (ent->groundentity)
{
if (!wasonground)
{
if (hitsound)
{
gi.sound(ent, 0, gi.soundindex("world/land.wav"), 1, 1, 0);
}
}
}
}
/* regular thinking */
SV_RunThink(ent);
}
