| /*
|
| 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 "qwsvdef.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_maxvelocity = {"sv_maxvelocity","2000"}; |
|
|
| cvar_t sv_gravity = { "sv_gravity", "800"};
|
| cvar_t sv_stopspeed = { "sv_stopspeed", "100"};
|
| cvar_t sv_maxspeed = { "sv_maxspeed", "320"};
|
| cvar_t sv_spectatormaxspeed = { "sv_spectatormaxspeed", "500"};
|
| cvar_t sv_accelerate = { "sv_accelerate", "10"};
|
| cvar_t sv_airaccelerate = { "sv_airaccelerate", "0.7"};
|
| cvar_t sv_wateraccelerate = { "sv_wateraccelerate", "10"};
|
| cvar_t sv_friction = { "sv_friction", "4"};
|
| cvar_t sv_waterfriction = { "sv_waterfriction", "4"};
|
|
|
| |
| #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 |
| || 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_GetString(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_GetString(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; |
|
|
| do
|
| { |
| thinktime = ent->v.nextthink; |
| if (thinktime <= 0)
|
| return true; |
| if (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);
|
|
|
| if (ent->free)
|
| return false;
|
| } while (1);
|
| |
| return true; |
| } |
| |
| /* |
| ================== |
| 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++) |
| { |
| 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) |
| SV_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 scale) |
| { |
| ent->v.velocity[2] -= scale * movevars.gravity * 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_Push
|
|
|
| ============
|
| */
|
| qboolean SV_Push (edict_t *pusher, vec3_t move)
|
| {
|
| int i, e;
|
| edict_t *check, *block;
|
| vec3_t mins, maxs;
|
| vec3_t pushorig;
|
| int num_moved;
|
| edict_t *moved_edict[MAX_EDICTS];
|
| vec3_t moved_from[MAX_EDICTS];
|
|
|
| for (i=0 ; i<3 ; i++)
|
| {
|
| 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);
|
| 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_NOCLIP)
|
| continue;
|
|
|
| pusher->v.solid = SOLID_NOT;
|
| block = SV_TestEntityPosition (check);
|
| pusher->v.solid = SOLID_BSP;
|
| if (block)
|
| 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;
|
| }
|
|
|
| VectorCopy (check->v.origin, moved_from[num_moved]);
|
| moved_edict[num_moved] = check;
|
| num_moved++;
|
|
|
| // try moving the contacted entity
|
| VectorAdd (check->v.origin, move, check->v.origin);
|
| block = SV_TestEntityPosition (check);
|
| if (!block)
|
| { // pushed ok
|
| SV_LinkEdict (check, false);
|
| continue;
|
| }
|
|
|
| // if it is ok to leave in the old position, do it
|
| VectorSubtract (check->v.origin, move, check->v.origin);
|
| block = SV_TestEntityPosition (check);
|
| if (!block)
|
| {
|
| num_moved--;
|
| continue;
|
| }
|
|
|
| // if it is still inside the pusher, block
|
| if (check->v.mins[0] == check->v.maxs[0])
|
| {
|
| SV_LinkEdict (check, false);
|
| 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);
|
| SV_LinkEdict (check, false);
|
| continue;
|
| }
|
|
|
| VectorCopy (pushorig, pusher->v.origin);
|
| SV_LinkEdict (pusher, false);
|
|
|
| // 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 false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| /*
|
| ============
|
| SV_PushMove
|
|
|
| ============
|
| */
|
| void SV_PushMove (edict_t *pusher, float movetime)
|
| {
|
| int i;
|
| vec3_t move;
|
|
|
| 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;
|
|
|
| if (SV_Push (pusher, move))
|
| pusher->v.ltime += movetime;
|
| }
|
|
|
| |
| /* |
| ================ |
| SV_Physics_Pusher |
| |
| ================ |
| */ |
| void SV_Physics_Pusher (edict_t *ent) |
| { |
| float thinktime; |
| float oldltime; |
| float movetime; |
| vec3_t oldorg, move;
|
| float l;
|
| |
| 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) |
| { |
| SV_PushMove (ent, movetime); // advances ent->v.ltime if not blocked |
| } |
| |
| if (thinktime > oldltime && thinktime <= ent->v.ltime) |
| { |
| VectorCopy (ent->v.origin, oldorg);
|
| 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;
|
| VectorSubtract (ent->v.origin, oldorg, move);
|
|
|
| l = Length(move);
|
| if (l > 1.0/64)
|
| {
|
| // Con_Printf ("**** snap: %f\n", Length (l));
|
| VectorCopy (oldorg, ent->v.origin);
|
| SV_Push (ent, move);
|
| }
|
| |
| } |
| |
| } |
| |
| |
| /* |
| ============= |
| 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 (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; |
| |
| cont = SV_PointContents (ent->v.origin); |
| 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; |
| |
| // regular thinking |
| if (!SV_RunThink (ent)) |
| return; |
|
|
| if (ent->v.velocity[2] > 0) |
| ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
|
|
|
| // 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, 1.0); |
| |
| // move angles |
| VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles); |
| |
| // move origin |
| VectorScale (ent->v.velocity, host_frametime, move); |
| trace = SV_PushEntity (ent, move); |
| if (trace.fraction == 1)
|
| return;
|
| if (ent->free) |
| return; |
| |
| if (ent->v.movetype == MOVETYPE_BOUNCE) |
| backoff = 1.5; |
| 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) |
| { |
| if (ent->v.velocity[2] < 60 || ent->v.movetype != MOVETYPE_BOUNCE ) |
| { |
| 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. |
| FIXME: is this true? |
| ============= |
| */ |
| void SV_Physics_Step (edict_t *ent) |
| { |
| qboolean hitsound; |
| |
| // frefall if not onground |
| if ( ! ((int)ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) ) |
| { |
| if (ent->v.velocity[2] < movevars.gravity*-0.1) |
| hitsound = true; |
| else |
| hitsound = false; |
| |
| SV_AddGravity (ent, 1.0); |
| 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); |
| } |
| |
| //============================================================================ |
| |
| void SV_ProgStartFrame (void) |
| { |
| // 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_RunEntity |
| |
| ================ |
| */ |
| void SV_RunEntity (edict_t *ent) |
| { |
| if (ent->v.lastruntime == (float)realtime) |
| return; |
| ent->v.lastruntime = (float)realtime; |
| |
| switch ( (int)ent->v.movetype) |
| { |
| case MOVETYPE_PUSH: |
| SV_Physics_Pusher (ent); |
| break; |
| case MOVETYPE_NONE: |
| SV_Physics_None (ent); |
| break; |
| case MOVETYPE_NOCLIP: |
| SV_Physics_Noclip (ent); |
| break; |
| case MOVETYPE_STEP: |
| SV_Physics_Step (ent); |
| break; |
| case MOVETYPE_TOSS: |
| case MOVETYPE_BOUNCE: |
| case MOVETYPE_FLY: |
| case MOVETYPE_FLYMISSILE: |
| SV_Physics_Toss (ent); |
| break; |
| default: |
| SV_Error ("SV_Physics: bad movetype %i", (int)ent->v.movetype); |
| } |
| } |
| |
| /* |
| ================ |
| SV_RunNewmis |
| |
| ================ |
| */ |
| void SV_RunNewmis (void) |
| { |
| edict_t *ent; |
| |
| if (!pr_global_struct->newmis) |
| return; |
| ent = PROG_TO_EDICT(pr_global_struct->newmis);
|
| host_frametime = 0.05; |
| pr_global_struct->newmis = 0; |
| |
| SV_RunEntity (ent); |
| } |
| |
| /* |
| ================ |
| SV_Physics |
| |
| ================ |
| */ |
| void SV_Physics (void) |
| { |
| int i; |
| edict_t *ent; |
| static double old_time; |
| |
| // don't bother running a frame if sys_ticrate seconds haven't passed |
| host_frametime = realtime - old_time; |
| if (host_frametime < sv_mintic.value) |
| return; |
| if (host_frametime > sv_maxtic.value) |
| host_frametime = sv_maxtic.value; |
| old_time = realtime; |
| |
| pr_global_struct->frametime = host_frametime; |
| |
| SV_ProgStartFrame (); |
| |
| // |
| // treat each object in turn |
| // even the world gets a chance to think |
| // |
| 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 <= MAX_CLIENTS) |
| continue; // clients are run directly from packets |
| |
| SV_RunEntity (ent); |
| SV_RunNewmis (); |
| } |
| |
| if (pr_global_struct->force_retouch) |
| pr_global_struct->force_retouch--; |
| } |
|
|
| void SV_SetMoveVars(void)
|
| {
|
| movevars.gravity = sv_gravity.value;
|
| movevars.stopspeed = sv_stopspeed.value;
|
| movevars.maxspeed = sv_maxspeed.value;
|
| movevars.spectatormaxspeed = sv_spectatormaxspeed.value;
|
| movevars.accelerate = sv_accelerate.value;
|
| movevars.airaccelerate = sv_airaccelerate.value;
|
| movevars.wateraccelerate = sv_wateraccelerate.value;
|
| movevars.friction = sv_friction.value;
|
| movevars.waterfriction = sv_waterfriction.value;
|
| movevars.entgravity = 1.0;
|
| }
|