*/
-cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4"};
-cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100"};
-cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800"};
-cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000"};
-cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0"};
-cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18"};
-cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1"};
-cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1"};
-cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0"};
-cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0"};
+cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4", "how fast you slow down"};
+cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
+cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
+cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
+cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
+cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
+cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
+cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
+cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0", "enables simpler/buggier player physics (not recommended)"};
+cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
+cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
#define MOVE_EPSILON 0.01
Cvar_RegisterVariable(&sv_wallfriction);
Cvar_RegisterVariable(&sv_newflymove);
Cvar_RegisterVariable(&sv_freezenonclients);
+
+ Cvar_RegisterVariable(&sv_playerphysicsqc);
}
/*
}
if (!trace.ent)
- Host_Error("SV_FlyMove: !trace.ent");
+ {
+ Con_Printf ("SV_FlyMove: !trace.ent");
+ trace.ent = prog->edicts;
+ }
if (((int) ent->fields.server->flags & FL_ONGROUND) && ent->fields.server->groundentity == PRVM_EDICT_TO_PROG(trace.ent))
impact = false;
// run the impact function
if (impact)
{
- SV_Impact(ent, trace.ent);
+ SV_Impact(ent, (prvm_edict_t *)trace.ent);
// break if removed by the impact function
if (ent->priv.server->free)
return blocked;
}
-int SV_SetOnGround (prvm_edict_t *ent)
-{
- vec3_t end;
- trace_t trace;
- if ((int)ent->fields.server->flags & FL_ONGROUND)
- return 1;
- VectorSet(end, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] - 1);
- trace = SV_Move(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
- if (trace.fraction < 1 && trace.plane.normal[2] >= 0.7)
- {
- ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
- ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
- return 1;
- }
- return 0;
-}
-
/*
============
SV_AddGravity
SV_LinkEdict (ent, true);
if (trace.ent && (!((int)ent->fields.server->flags & FL_ONGROUND) || ent->fields.server->groundentity != PRVM_EDICT_TO_PROG(trace.ent)))
- SV_Impact (ent, trace.ent);
+ SV_Impact (ent, (prvm_edict_t *)trace.ent);
return trace;
}
============
*/
-trace_t SV_ClipMoveToEntity (prvm_edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
void SV_PushMove (prvm_edict_t *pusher, float movetime)
{
int i, e, index;
- prvm_edict_t *check, *ed;
float savesolid, movetime2, pushltime;
- vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org, org2;
+ vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org;
int num_moved;
int numcheckentities;
static prvm_edict_t *checkentities[MAX_EDICTS];
VectorCopy (pusher->fields.server->angles, pushang);
pushltime = pusher->fields.server->ltime;
-// move the pusher to it's final position
+// move the pusher to its final position
VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
numcheckentities = SV_EntitiesInBox(mins, maxs, MAX_EDICTS, checkentities);
for (e = 0;e < numcheckentities;e++)
{
- check = checkentities[e];
- if (check->fields.server->movetype == MOVETYPE_PUSH
- || check->fields.server->movetype == MOVETYPE_NONE
+ prvm_edict_t *check = checkentities[e];
+ if (check->fields.server->movetype == MOVETYPE_NONE
+ || check->fields.server->movetype == MOVETYPE_PUSH
|| check->fields.server->movetype == MOVETYPE_FOLLOW
|| check->fields.server->movetype == MOVETYPE_NOCLIP
|| check->fields.server->movetype == MOVETYPE_FAKEPUSH)
// if the entity is standing on the pusher, it will definitely be moved
if (!(((int)check->fields.server->flags & FL_ONGROUND) && PRVM_PROG_TO_EDICT(check->fields.server->groundentity) == pusher))
- if (!SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin).startsolid)
+ {
+ // if the entity is not inside the pusher's final position, leave it alone
+ if (!SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
continue;
+ // remove the onground flag for non-players
+ if (check->fields.server->movetype != MOVETYPE_WALK)
+ check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
+ }
+
if (forward[0] != 1 || left[1] != 1) // quick way to check if any rotation is used
{
+ vec3_t org2;
VectorSubtract (check->fields.server->origin, pusher->fields.server->origin, org);
org2[0] = DotProduct (org, forward);
org2[1] = DotProduct (org, left);
else
VectorCopy (move1, move);
- // remove the onground flag for non-players
- if (check->fields.server->movetype != MOVETYPE_WALK)
- check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
-
VectorCopy (check->fields.server->origin, check->priv.server->moved_from);
VectorCopy (check->fields.server->angles, check->priv.server->moved_fromangles);
sv.moved_edicts[num_moved++] = check;
pusher->fields.server->solid = savesolid; // was SOLID_BSP
// if it is still inside the pusher, block
- if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin).startsolid)
+ if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
{
// try moving the contacted entity a tiny bit further to account for precision errors
+ vec3_t move2;
pusher->fields.server->solid = SOLID_NOT;
- VectorScale(move, 0.1, move);
- SV_PushEntity (check, move);
+ VectorScale(move, 1.1, move2);
+ VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
+ VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
+ SV_PushEntity (check, move2);
pusher->fields.server->solid = savesolid;
- if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin).startsolid)
+ if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
{
- // still inside pusher, so it's really blocked
-
- // fail the move
- if (check->fields.server->mins[0] == check->fields.server->maxs[0])
- continue;
- if (check->fields.server->solid == SOLID_NOT || check->fields.server->solid == SOLID_TRIGGER)
+ // try moving the contacted entity a tiny bit less to account for precision errors
+ pusher->fields.server->solid = SOLID_NOT;
+ VectorScale(move, 0.9, move2);
+ VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
+ VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
+ SV_PushEntity (check, move2);
+ pusher->fields.server->solid = savesolid;
+ if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID).startsolid)
{
- // corpse
- check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
- VectorCopy (check->fields.server->mins, check->fields.server->maxs);
- continue;
- }
+ // still inside pusher, so it's really blocked
- VectorCopy (pushorig, pusher->fields.server->origin);
- VectorCopy (pushang, pusher->fields.server->angles);
- pusher->fields.server->ltime = pushltime;
- SV_LinkEdict (pusher, false);
+ // fail the move
+ if (check->fields.server->mins[0] == check->fields.server->maxs[0])
+ continue;
+ if (check->fields.server->solid == SOLID_NOT || check->fields.server->solid == SOLID_TRIGGER)
+ {
+ // corpse
+ check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
+ VectorCopy (check->fields.server->mins, check->fields.server->maxs);
+ continue;
+ }
- // move back any entities we already moved
- for (i = 0;i < num_moved;i++)
- {
- ed = sv.moved_edicts[i];
- VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
- VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
- SV_LinkEdict (ed, false);
- }
+ VectorCopy (pushorig, pusher->fields.server->origin);
+ VectorCopy (pushang, pusher->fields.server->angles);
+ pusher->fields.server->ltime = pushltime;
+ 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->fields.server->blocked)
- {
- prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
- prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
- PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
+ // move back any entities we already moved
+ for (i = 0;i < num_moved;i++)
+ {
+ prvm_edict_t *ed = sv.moved_edicts[i];
+ VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
+ VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
+ SV_LinkEdict (ed, false);
+ }
+
+ // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
+ if (pusher->fields.server->blocked)
+ {
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
+ prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
+ PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
+ }
+ break;
}
- break;
}
}
}
clip = SV_FlyMove (ent, sv.frametime, NULL);
- SV_SetOnGround (ent);
SV_CheckVelocity(ent);
VectorCopy(ent->fields.server->origin, originalmove_origin);
ent->fields.server->groundentity = originalmove_groundentity;
}
- SV_SetOnGround (ent);
SV_CheckVelocity(ent);
}
void SV_CheckWaterTransition (prvm_edict_t *ent)
{
int cont;
- cont = SV_PointQ1Contents(ent->fields.server->origin);
+ cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(ent->fields.server->origin));
if (!ent->fields.server->watertype)
{
// just spawned here
}
// check if the entity crossed into or out of water
- if ((ent->fields.server->watertype == CONTENTS_WATER || ent->fields.server->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME))
+ if (gamemode != GAME_NEXUIZ && ((ent->fields.server->watertype == CONTENTS_WATER || ent->fields.server->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME)))
SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
if (cont <= CONTENTS_WATER)
trace_t trace;
vec3_t move;
- // don't stick to ground if onground and moving upward
- if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && ((int)ent->fields.server->flags & FL_ONGROUND))
- ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
-
// if onground, return without moving
if ((int)ent->fields.server->flags & FL_ONGROUND)
{
- if (ent->fields.server->groundentity == 0 || sv_gameplayfix_noairborncorpse.integer)
- return;
- // if ent was supported by a brush model on previous frame,
- // and groundentity is now freed, set groundentity to 0 (floating)
- if (ent->priv.server->suspendedinairflag && PRVM_PROG_TO_EDICT(ent->fields.server->groundentity)->priv.server->free)
+ // don't stick to ground if onground and moving upward
+ if (ent->fields.server->velocity[2] >= (1.0 / 32.0))
+ ent->fields.server->flags -= FL_ONGROUND;
+ else
{
- // leave it suspended in the air
- ent->fields.server->groundentity = 0;
- return;
+ prvm_edict_t *ground = PRVM_PROG_TO_EDICT(ent->fields.server->groundentity);
+ if (ground->fields.server->solid == SOLID_BSP || !sv_gameplayfix_noairborncorpse.integer)
+ return;
+ // if ent was supported by a brush model on previous frame,
+ // and groundentity is now freed, set groundentity to 0 (floating)
+ if (ent->priv.server->suspendedinairflag && ground->priv.server->free)
+ {
+ // leave it suspended in the air
+ ent->fields.server->groundentity = 0;
+ return;
+ }
}
}
ent->priv.server->suspendedinairflag = false;
*/
void SV_Physics_Step (prvm_edict_t *ent)
{
- // don't stick to ground if onground and moving upward
- if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && ((int)ent->fields.server->flags & FL_ONGROUND))
- ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
-
- // freefall if not onground/fly/swim
- if (!((int)ent->fields.server->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
+ int flags = (int)ent->fields.server->flags;
+ // don't fall at all if fly/swim
+ if (!(flags & (FL_FLY | FL_SWIM)))
{
- int hitsound = ent->fields.server->velocity[2] < sv_gravity.value * -0.1;
+ if (flags & FL_ONGROUND)
+ {
+ // freefall if onground and moving upward
+ // freefall if not standing on a world surface (it may be a lift)
+ prvm_edict_t *ground = PRVM_PROG_TO_EDICT(ent->fields.server->groundentity);
+ if (ent->fields.server->velocity[2] >= (1.0 / 32.0) || (ground->fields.server->solid != SOLID_BSP && sv_gameplayfix_noairborncorpse.integer))
+ {
+ ent->fields.server->flags -= FL_ONGROUND;
+ SV_AddGravity(ent);
+ SV_CheckVelocity(ent);
+ SV_FlyMove(ent, sv.frametime, NULL);
+ SV_LinkEdict(ent, true);
+ }
+ }
+ else
+ {
+ // freefall if not onground
+ int hitsound = ent->fields.server->velocity[2] < sv_gravity.value * -0.1;
- SV_AddGravity(ent);
- SV_CheckVelocity(ent);
- SV_FlyMove(ent, sv.frametime, NULL);
- SV_LinkEdict(ent, true);
+ SV_AddGravity(ent);
+ SV_CheckVelocity(ent);
+ SV_FlyMove(ent, sv.frametime, NULL);
+ SV_LinkEdict(ent, true);
- // just hit ground
- if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND && gamemode != GAME_NEXUIZ)
- SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
+ // just hit ground
+ if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND && gamemode != GAME_NEXUIZ)
+ SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
+ }
}
// regular thinking
//============================================================================
-void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
+static void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
{
- int i = ent - prog->edicts;
- if (i >= 1 && i <= svs.maxclients)
+ switch ((int) ent->fields.server->movetype)
{
- // apply the latest accepted move to the entity fields
- SV_ApplyClientMove();
- // make sure the velocity is sane (not a NaN)
- SV_CheckVelocity(ent);
- // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
- if (SV_PlayerPhysicsQC)
+ case MOVETYPE_PUSH:
+ case MOVETYPE_FAKEPUSH:
+ SV_Physics_Pusher (ent);
+ break;
+ case MOVETYPE_NONE:
+ // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
+ if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
+ SV_RunThink (ent);
+ break;
+ case MOVETYPE_FOLLOW:
+ SV_Physics_Follow (ent);
+ break;
+ case MOVETYPE_NOCLIP:
+ if (SV_RunThink(ent))
{
- prog->globals.server->time = sv.time;
- prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
- PRVM_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - prog->functions), "QC function SV_PlayerPhysics is missing");
+ SV_CheckWater(ent);
+ VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
+ VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
}
- else
- SV_ClientThink ();
- // make sure the velocity is sane (not a NaN)
- SV_CheckVelocity(ent);
- // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
- // player_run/player_stand1 does not horribly malfunction if the
- // velocity becomes a number that is both == 0 and != 0
- // (sounds to me like NaN but to be absolutely safe...)
- if (DotProduct(ent->fields.server->velocity, ent->fields.server->velocity) < 0.0001)
- VectorClear(ent->fields.server->velocity);
- // call standard client pre-think
+ SV_LinkEdict(ent, false);
+ break;
+ case MOVETYPE_STEP:
+ SV_Physics_Step (ent);
+ break;
+ case MOVETYPE_WALK:
+ if (SV_RunThink (ent))
+ {
+ if (!SV_CheckWater (ent) && ! ((int)ent->fields.server->flags & FL_WATERJUMP) )
+ SV_AddGravity (ent);
+ SV_CheckStuck (ent);
+ SV_WalkMove (ent);
+ SV_LinkEdict (ent, true);
+ }
+ break;
+ case MOVETYPE_TOSS:
+ case MOVETYPE_BOUNCE:
+ case MOVETYPE_BOUNCEMISSILE:
+ case MOVETYPE_FLYMISSILE:
+ case MOVETYPE_FLY:
+ // regular thinking
+ if (SV_RunThink (ent) && runmove)
+ SV_Physics_Toss (ent);
+ break;
+ default:
+ Con_Printf ("SV_Physics: bad movetype %i\n", (int)ent->fields.server->movetype);
+ break;
+ }
+}
+
+void SV_ApplyClientMove (void);
+void SV_Physics_ClientEntity (prvm_edict_t *ent)
+{
+ SV_ApplyClientMove();
+ // make sure the velocity is sane (not a NaN)
+ SV_CheckVelocity(ent);
+ // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
+ if (SV_PlayerPhysicsQC && sv_playerphysicsqc.integer)
+ {
prog->globals.server->time = sv.time;
prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
- PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
- SV_CheckVelocity (ent);
+ PRVM_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - prog->functions), "QC function SV_PlayerPhysics is missing");
}
+ else
+ SV_ClientThink ();
+ // make sure the velocity is sane (not a NaN)
+ SV_CheckVelocity(ent);
+ // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
+ // player_run/player_stand1 does not horribly malfunction if the
+ // velocity becomes a number that is both == 0 and != 0
+ // (sounds to me like NaN but to be absolutely safe...)
+ if (DotProduct(ent->fields.server->velocity, ent->fields.server->velocity) < 0.0001)
+ VectorClear(ent->fields.server->velocity);
+ // call standard client pre-think
+ prog->globals.server->time = sv.time;
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
+ SV_CheckVelocity (ent);
- // LordHavoc: merged client and normal entity physics
switch ((int) ent->fields.server->movetype)
{
case MOVETYPE_PUSH:
VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
}
- // relink normal entities here, players always get relinked so don't relink twice
- if (!(i > 0 && i <= svs.maxclients))
- SV_LinkEdict(ent, false);
break;
case MOVETYPE_STEP:
SV_Physics_Step (ent);
SV_AddGravity (ent);
SV_CheckStuck (ent);
SV_WalkMove (ent);
- // relink normal entities here, players always get relinked so don't relink twice
- if (!(i > 0 && i <= svs.maxclients))
- SV_LinkEdict (ent, true);
}
break;
case MOVETYPE_TOSS:
case MOVETYPE_BOUNCEMISSILE:
case MOVETYPE_FLYMISSILE:
// regular thinking
- if (SV_RunThink (ent) && runmove)
+ if (SV_RunThink (ent))
SV_Physics_Toss (ent);
break;
case MOVETYPE_FLY:
- if (SV_RunThink (ent) && runmove)
+ if (SV_RunThink (ent))
{
- if (i > 0 && i <= svs.maxclients)
- {
- SV_CheckWater (ent);
- SV_WalkMove (ent);
- }
- else
- SV_Physics_Toss (ent);
+ SV_CheckWater (ent);
+ SV_WalkMove (ent);
}
break;
default:
- Host_Error ("SV_Physics: bad movetype %i", (int)ent->fields.server->movetype);
+ Con_Printf ("SV_Physics_ClientEntity: bad movetype %i\n", (int)ent->fields.server->movetype);
break;
}
- if (i >= 1 && i <= svs.maxclients)
- {
- SV_CheckVelocity (ent);
+ SV_CheckVelocity (ent);
- // call standard player post-think
- SV_LinkEdict (ent, true);
+ // call standard player post-think
+ SV_LinkEdict (ent, true);
- SV_CheckVelocity (ent);
+ SV_CheckVelocity (ent);
- prog->globals.server->time = sv.time;
- prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
- PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
- }
+ prog->globals.server->time = sv.time;
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
}
-
/*
================
SV_Physics
{
int i, newnum_edicts;
prvm_edict_t *ent;
- qbyte runmove[MAX_EDICTS];
+ unsigned char runmove[MAX_EDICTS];
// let the progs know that a new frame has started
prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
prog->globals.server->frametime = sv.frametime;
PRVM_ExecuteProgram (prog->globals.server->StartFrame, "QC function StartFrame is missing");
+ // don't run a move on newly spawned projectiles as it messes up movement
+ // interpolation and rocket trails
newnum_edicts = 0;
for (i = 0, ent = prog->edicts;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
if ((runmove[i] = !ent->priv.server->free))
// treat each object in turn
//
- for (i = 0, ent = prog->edicts;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
- {
- if (ent->priv.server->free)
- continue;
-
- if (prog->globals.server->force_retouch)
- SV_LinkEdict (ent, true); // force retouch even for stationary
+ // if force_retouch, relink all the entities
+ if (prog->globals.server->force_retouch > 0)
+ for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
+ if (!ent->priv.server->free)
+ SV_LinkEdict (ent, true); // force retouch even for stationary
- if (i >= 1 && i <= svs.maxclients)
+ // run physics on the client entities
+ for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
+ {
+ if (!ent->priv.server->free)
{
- host_client = svs.clients + i - 1;
// don't do physics on disconnected clients, FrikBot relies on this
if (!host_client->spawned)
- {
memset(&host_client->cmd, 0, sizeof(host_client->cmd));
- continue;
- }
- // connected slot
- if (host_client->movesequence)
- continue; // return if running asynchronously
+ // don't run physics here if running asynchronously
+ else if (!host_client->movesequence)
+ SV_Physics_ClientEntity(ent);
}
- else if (sv_freezenonclients.integer)
- continue;
-
- SV_Physics_Entity(ent, runmove[i]);
}
+ // run physics on all the non-client entities
+ if (!sv_freezenonclients.integer)
+ for (;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
+ if (!ent->priv.server->free)
+ SV_Physics_Entity(ent, runmove[i]);
+
if (prog->globals.server->force_retouch > 0)
prog->globals.server->force_retouch = max(0, prog->globals.server->force_retouch - 1);
projects / xonotic / darkplaces.git / blobdiff