eliminated qbyte type, now uses unsigned char throughout the engine for this purpose
[xonotic/darkplaces.git] / sv_phys.c
index a44bfa4..3db1887 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -49,6 +49,7 @@ 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_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1"};
 
 #define        MOVE_EPSILON    0.01
 
@@ -61,6 +62,8 @@ void SV_Phys_Init (void)
        Cvar_RegisterVariable(&sv_wallfriction);
        Cvar_RegisterVariable(&sv_newflymove);
        Cvar_RegisterVariable(&sv_freezenonclients);
+
+       Cvar_RegisterVariable(&sv_playerphysicsqc);
 }
 
 /*
@@ -313,7 +316,10 @@ int SV_FlyMove (prvm_edict_t *ent, float time, float *stepnormal)
                }
 
                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;
@@ -353,7 +359,7 @@ int SV_FlyMove (prvm_edict_t *ent, float time, float *stepnormal)
                // 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)
@@ -450,23 +456,6 @@ int SV_FlyMove (prvm_edict_t *ent, float time, float *stepnormal)
        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
@@ -523,7 +512,7 @@ trace_t SV_PushEntity (prvm_edict_t *ent, vec3_t push)
        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;
 }
 
@@ -534,13 +523,11 @@ SV_PushMove
 
 ============
 */
-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];
@@ -643,7 +630,7 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
        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);
@@ -658,9 +645,9 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
        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)
@@ -668,11 +655,19 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
 
                // 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);
@@ -683,10 +678,6 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                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;
@@ -699,50 +690,63 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                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;
                        }
                }
        }
@@ -985,7 +989,6 @@ void SV_WalkMove (prvm_edict_t *ent)
 
        clip = SV_FlyMove (ent, sv.frametime, NULL);
 
-       SV_SetOnGround (ent);
        SV_CheckVelocity(ent);
 
        VectorCopy(ent->fields.server->origin, originalmove_origin);
@@ -1094,7 +1097,6 @@ void SV_WalkMove (prvm_edict_t *ent)
                ent->fields.server->groundentity = originalmove_groundentity;
        }
 
-       SV_SetOnGround (ent);
        SV_CheckVelocity(ent);
 }
 
@@ -1161,7 +1163,7 @@ SV_CheckWaterTransition
 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
@@ -1171,7 +1173,7 @@ void SV_CheckWaterTransition (prvm_edict_t *ent)
        }
 
        // 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)
@@ -1340,40 +1342,86 @@ void SV_Physics_Step (prvm_edict_t *ent)
 
 //============================================================================
 
-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", (int)ent->fields.server->movetype);
+               break;
+       }
+}
+
+void SV_Physics_ClientEntity (prvm_edict_t *ent)
+{
+       // 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:
@@ -1395,9 +1443,6 @@ void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
                        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);
@@ -1409,9 +1454,6 @@ void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
                                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:
@@ -1419,42 +1461,33 @@ void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
        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", (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
@@ -1465,7 +1498,7 @@ void SV_Physics (void)
 {
        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);
@@ -1474,6 +1507,8 @@ void SV_Physics (void)
        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))
@@ -1484,33 +1519,32 @@ void SV_Physics (void)
 // 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);