eliminated qbyte type, now uses unsigned char throughout the engine for this purpose
[xonotic/darkplaces.git] / sv_phys.c
index 5ed7426..3db1887 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -47,16 +47,23 @@ 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_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1"};
 
 #define        MOVE_EPSILON    0.01
 
-void SV_Physics_Toss (edict_t *ent);
+void SV_Physics_Toss (prvm_edict_t *ent);
 
 void SV_Phys_Init (void)
 {
        Cvar_RegisterVariable(&sv_stepheight);
        Cvar_RegisterVariable(&sv_jumpstep);
        Cvar_RegisterVariable(&sv_wallfriction);
+       Cvar_RegisterVariable(&sv_newflymove);
+       Cvar_RegisterVariable(&sv_freezenonclients);
+
+       Cvar_RegisterVariable(&sv_playerphysicsqc);
 }
 
 /*
@@ -67,22 +74,22 @@ SV_CheckAllEnts
 void SV_CheckAllEnts (void)
 {
        int e;
-       edict_t *check;
+       prvm_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))
+       check = PRVM_NEXT_EDICT(prog->edicts);
+       for (e = 1;e < prog->num_edicts;e++, check = PRVM_NEXT_EDICT(check))
        {
-               if (check->free)
+               if (check->priv.server->free)
                        continue;
-               if (check->v->movetype == MOVETYPE_PUSH
-                || check->v->movetype == MOVETYPE_NONE
-                || check->v->movetype == MOVETYPE_FOLLOW
-                || check->v->movetype == MOVETYPE_NOCLIP)
+               if (check->fields.server->movetype == MOVETYPE_PUSH
+                || check->fields.server->movetype == MOVETYPE_NONE
+                || check->fields.server->movetype == MOVETYPE_FOLLOW
+                || check->fields.server->movetype == MOVETYPE_NOCLIP)
                        continue;
 
                if (SV_TestEntityPosition (check))
-                       Con_Print("entity in invalid position\n");
+                       Con_Print("entity in invalid position\n");
        }
 }
 
@@ -91,7 +98,7 @@ void SV_CheckAllEnts (void)
 SV_CheckVelocity
 ================
 */
-void SV_CheckVelocity (edict_t *ent)
+void SV_CheckVelocity (prvm_edict_t *ent)
 {
        int i;
        float wishspeed;
@@ -101,26 +108,26 @@ void SV_CheckVelocity (edict_t *ent)
 //
        for (i=0 ; i<3 ; i++)
        {
-               if (IS_NAN(ent->v->velocity[i]))
+               if (IS_NAN(ent->fields.server->velocity[i]))
                {
-                       Con_Printf ("Got a NaN velocity on %s\n", PR_GetString(ent->v->classname));
-                       ent->v->velocity[i] = 0;
+                       Con_Printf("Got a NaN velocity on %s\n", PRVM_GetString(ent->fields.server->classname));
+                       ent->fields.server->velocity[i] = 0;
                }
-               if (IS_NAN(ent->v->origin[i]))
+               if (IS_NAN(ent->fields.server->origin[i]))
                {
-                       Con_Printf ("Got a NaN origin on %s\n", PR_GetString(ent->v->classname));
-                       ent->v->origin[i] = 0;
+                       Con_Printf("Got a NaN origin on %s\n", PRVM_GetString(ent->fields.server->classname));
+                       ent->fields.server->origin[i] = 0;
                }
        }
 
        // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
-       wishspeed = DotProduct(ent->v->velocity, ent->v->velocity);
+       wishspeed = DotProduct(ent->fields.server->velocity, ent->fields.server->velocity);
        if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
        {
                wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
-               ent->v->velocity[0] *= wishspeed;
-               ent->v->velocity[1] *= wishspeed;
-               ent->v->velocity[2] *= wishspeed;
+               ent->fields.server->velocity[0] *= wishspeed;
+               ent->fields.server->velocity[1] *= wishspeed;
+               ent->fields.server->velocity[2] *= wishspeed;
        }
 }
 
@@ -134,11 +141,11 @@ 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)
+qboolean SV_RunThink (prvm_edict_t *ent)
 {
        float thinktime;
 
-       thinktime = ent->v->nextthink;
+       thinktime = ent->fields.server->nextthink;
        if (thinktime <= 0 || thinktime > sv.time + sv.frametime)
                return true;
 
@@ -147,12 +154,12 @@ qboolean SV_RunThink (edict_t *ent)
        if (thinktime < sv.time)
                thinktime = sv.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, "NULL think function");
-       return !ent->free;
+       ent->fields.server->nextthink = 0;
+       prog->globals.server->time = thinktime;
+       prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+       prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
+       PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
+       return !ent->priv.server->free;
 }
 
 /*
@@ -162,30 +169,30 @@ SV_Impact
 Two entities have touched, so run their touch functions
 ==================
 */
-void SV_Impact (edict_t *e1, edict_t *e2)
+void SV_Impact (prvm_edict_t *e1, prvm_edict_t *e2)
 {
        int old_self, old_other;
 
-       old_self = pr_global_struct->self;
-       old_other = pr_global_struct->other;
+       old_self = prog->globals.server->self;
+       old_other = prog->globals.server->other;
 
-       pr_global_struct->time = sv.time;
-       if (e1->v->touch && e1->v->solid != SOLID_NOT)
+       prog->globals.server->time = sv.time;
+       if (e1->fields.server->touch && e1->fields.server->solid != SOLID_NOT)
        {
-               pr_global_struct->self = EDICT_TO_PROG(e1);
-               pr_global_struct->other = EDICT_TO_PROG(e2);
-               PR_ExecuteProgram (e1->v->touch, "");
+               prog->globals.server->self = PRVM_EDICT_TO_PROG(e1);
+               prog->globals.server->other = PRVM_EDICT_TO_PROG(e2);
+               PRVM_ExecuteProgram (e1->fields.server->touch, "QC function self.touch is missing");
        }
 
-       if (e2->v->touch && e2->v->solid != SOLID_NOT)
+       if (e2->fields.server->touch && e2->fields.server->solid != SOLID_NOT)
        {
-               pr_global_struct->self = EDICT_TO_PROG(e2);
-               pr_global_struct->other = EDICT_TO_PROG(e1);
-               PR_ExecuteProgram (e2->v->touch, "");
+               prog->globals.server->self = PRVM_EDICT_TO_PROG(e2);
+               prog->globals.server->other = PRVM_EDICT_TO_PROG(e1);
+               PRVM_ExecuteProgram (e2->fields.server->touch, "QC function self.touch is missing");
        }
 
-       pr_global_struct->self = old_self;
-       pr_global_struct->other = old_other;
+       prog->globals.server->self = old_self;
+       prog->globals.server->other = old_other;
 }
 
 
@@ -198,30 +205,17 @@ 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)
+void ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
 {
-       int i, blocked;
-       float backoff, change;
-
-       blocked = 0;
-       // flag if it's a floor
-       if (normal[2] > 0)
-               blocked |= 1;
-       // flag if it's a step
-       if (!normal[2])
-               blocked |= 2;
+       int i;
+       float backoff;
 
-       backoff = DotProduct (in, normal) * overbounce;
+       backoff = -DotProduct (in, normal) * overbounce;
+       VectorMA(in, backoff, normal, out);
 
        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;
 }
 
 
@@ -234,178 +228,251 @@ 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
+If stepnormal is not NULL, the plane normal of any vertical wall hit will be stored
 ============
 */
-// LordHavoc: increased from 5 to 20
-#define MAX_CLIP_PLANES 20
-int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
+// LordHavoc: increased from 5 to 32
+#define MAX_CLIP_PLANES 32
+int SV_FlyMove (prvm_edict_t *ent, float time, float *stepnormal)
 {
-       int i, j, blocked, impact, numplanes, bumpcount, numbumps;
+       int blocked, bumpcount;
+       int i, j, impact, numplanes;
        float d, time_left;
        vec3_t dir, end, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, new_velocity;
        trace_t trace;
-
-       numbumps = 4;
-
        blocked = 0;
-       VectorCopy (ent->v->velocity, original_velocity);
-       VectorCopy (ent->v->velocity, primal_velocity);
+       VectorCopy(ent->fields.server->velocity, original_velocity);
+       VectorCopy(ent->fields.server->velocity, primal_velocity);
        numplanes = 0;
-
        time_left = time;
-
-       for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
+       for (bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
        {
-               if (!ent->v->velocity[0] && !ent->v->velocity[1] && !ent->v->velocity[2])
+               if (!ent->fields.server->velocity[0] && !ent->fields.server->velocity[1] && !ent->fields.server->velocity[2])
                        break;
 
-               for (i=0 ; i<3 ; i++)
-                       end[i] = ent->v->origin[i] + time_left * ent->v->velocity[i];
+               VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
+               trace = SV_Move(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
+#if 0
+               //if (trace.fraction < 0.002)
+               {
+#if 1
+                       vec3_t start;
+                       trace_t testtrace;
+                       VectorCopy(ent->fields.server->origin, start);
+                       start[2] += 3;//0.03125;
+                       VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
+                       end[2] += 3;//0.03125;
+                       testtrace = SV_Move(start, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
+                       if (trace.fraction < testtrace.fraction && !testtrace.startsolid && (testtrace.fraction == 1 || DotProduct(trace.plane.normal, ent->fields.server->velocity) < DotProduct(testtrace.plane.normal, ent->fields.server->velocity)))
+                       {
+                               Con_Printf("got further (new %f > old %f)\n", testtrace.fraction, trace.fraction);
+                               trace = testtrace;
+                       }
+#endif
+#if 0
+                       //j = -1;
+                       for (i = 0;i < numplanes;i++)
+                       {
+                               VectorCopy(ent->fields.server->origin, start);
+                               VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
+                               VectorMA(start, 3, planes[i], start);
+                               VectorMA(end, 3, planes[i], end);
+                               testtrace = SV_Move(start, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
+                               if (trace.fraction < testtrace.fraction)
+                               {
+                                       trace = testtrace;
+                                       VectorCopy(start, ent->fields.server->origin);
+                                       //j = i;
+                               }
+                       }
+                       //if (j >= 0)
+                       //      VectorAdd(ent->fields.server->origin, planes[j], start);
+#endif
+               }
+#endif
 
-               trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
+#if 0
+               Con_Printf("entity %i bump %i: velocity %f %f %f trace %f", ent - prog->edicts, bumpcount, ent->fields.server->velocity[0], ent->fields.server->velocity[1], ent->fields.server->velocity[2], trace.fraction);
+               if (trace.fraction < 1)
+                       Con_Printf(" : %f %f %f", trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2]);
+               Con_Print("\n");
+#endif
 
-               if (trace.allsolid)
+               /*
+               if (trace.startsolid)
                {
                        // LordHavoc: note: this code is what makes entities stick in place if embedded in another object (which can be the world)
                        // entity is trapped in another solid
-                       VectorClear(ent->v->velocity);
+                       VectorClear(ent->fields.server->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;
-               }
+               */
 
                // break if it moved the entire distance
                if (trace.fraction == 1)
-                        break;
+               {
+                       VectorCopy(trace.endpos, ent->fields.server->origin);
+                       break;
+               }
 
                if (!trace.ent)
-                       Host_Error ("SV_FlyMove: !trace.ent");
-
-               if ((int) ent->v->flags & FL_ONGROUND)
                {
-                       if (ent->v->groundentity == EDICT_TO_PROG(trace.ent))
-                               impact = false;
-                       else
-                       {
-                               ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
-                               impact = true;
-                       }
+                       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;
                else
+               {
+                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
                        impact = true;
+               }
 
-               if (trace.plane.normal[2] > 0.7)
+               if (trace.plane.normal[2])
                {
-                       // floor
-                       blocked |= 1;
-                       ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
-                       ent->v->groundentity = EDICT_TO_PROG(trace.ent);
+                       if (trace.plane.normal[2] > 0.7)
+                       {
+                               // floor
+                               blocked |= 1;
+                               ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
+                               ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                       }
                }
-               if (!trace.plane.normal[2])
+               else
                {
                        // step
                        blocked |= 2;
                        // save the trace for player extrafriction
-                       if (steptrace)
-                               *steptrace = trace;
+                       if (stepnormal)
+                               VectorCopy(trace.plane.normal, stepnormal);
+               }
+
+               if (trace.fraction >= 0.001)
+               {
+                       // actually covered some distance
+                       VectorCopy(trace.endpos, ent->fields.server->origin);
+                       VectorCopy(ent->fields.server->velocity, original_velocity);
+                       numplanes = 0;
                }
 
                // 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->free)
+                       if (ent->priv.server->free)
                                break;
                }
 
-
-               time_left -= time_left * trace.fraction;
+               time_left *= 1 - trace.fraction;
 
                // clipped to another plane
                if (numplanes >= MAX_CLIP_PLANES)
                {
                        // this shouldn't really happen
-                       VectorClear(ent->v->velocity);
-                       return 3;
+                       VectorClear(ent->fields.server->velocity);
+                       blocked = 3;
+                       break;
                }
 
-               VectorCopy (trace.plane.normal, planes[numplanes]);
+               /*
+               for (i = 0;i < numplanes;i++)
+                       if (DotProduct(trace.plane.normal, planes[i]) > 0.99)
+                               break;
+               if (i < numplanes)
+               {
+                       VectorAdd(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity);
+                       continue;
+               }
+               */
+
+               VectorCopy(trace.plane.normal, planes[numplanes]);
                numplanes++;
 
-               // modify original_velocity so it parallels all of the clip planes
-               for (i=0 ; i<numplanes ; i++)
+               if (sv_newflymove.integer)
+                       ClipVelocity(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1);
+               else
                {
-                       ClipVelocity (original_velocity, planes[i], new_velocity, 1);
-                       for (j=0 ; j<numplanes ; j++)
-                               if (j != i)
+                       // 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++)
                                {
-                                       // not ok
-                                       if (DotProduct (new_velocity, planes[j]) < 0)
-                                               break;
+                                       if (j != i)
+                                       {
+                                               // not ok
+                                               if (DotProduct(new_velocity, planes[j]) < 0)
+                                                       break;
+                                       }
                                }
-                       if (j == numplanes)
-                               break;
-               }
+                               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)
+                       if (i != numplanes)
+                       {
+                               // go along this plane
+                               VectorCopy(new_velocity, ent->fields.server->velocity);
+                       }
+                       else
                        {
-                               VectorClear(ent->v->velocity);
-                               return 7;
+                               // go along the crease
+                               if (numplanes != 2)
+                               {
+                                       VectorClear(ent->fields.server->velocity);
+                                       blocked = 7;
+                                       break;
+                               }
+                               CrossProduct(planes[0], planes[1], dir);
+                               // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
+                               VectorNormalize(dir);
+                               d = DotProduct(dir, ent->fields.server->velocity);
+                               VectorScale(dir, d, ent->fields.server->velocity);
                        }
-                       CrossProduct (planes[0], planes[1], dir);
-                       // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
-                       VectorNormalize(dir);
-                       d = DotProduct (dir, ent->v->velocity);
-                       VectorScale (dir, d, ent->v->velocity);
                }
 
-               // if original velocity is against the original velocity,
+               // if current velocity is against the original velocity,
                // stop dead to avoid tiny occilations in sloping corners
-               if (DotProduct (ent->v->velocity, primal_velocity) <= 0)
+               if (DotProduct(ent->fields.server->velocity, primal_velocity) <= 0)
                {
-                       VectorClear(ent->v->velocity);
-                       return blocked;
+                       VectorClear(ent->fields.server->velocity);
+                       break;
                }
        }
 
+       //Con_Printf("entity %i final: blocked %i velocity %f %f %f\n", ent - prog->edicts, blocked, ent->fields.server->velocity[0], ent->fields.server->velocity[1], ent->fields.server->velocity[2]);
+
+       /*
+       if ((blocked & 1) == 0 && bumpcount > 1)
+       {
+               // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
+               // flag ONGROUND if there's ground under it
+               trace = SV_Move(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
+       }
+       */
        return blocked;
 }
 
-
 /*
 ============
 SV_AddGravity
 
 ============
 */
-void SV_AddGravity (edict_t *ent)
+void SV_AddGravity (prvm_edict_t *ent)
 {
        float ent_gravity;
-       eval_t *val;
+       prvm_eval_t *val;
 
-       val = GETEDICTFIELDVALUE(ent, eval_gravity);
+       val = PRVM_GETEDICTFIELDVALUE(ent, eval_gravity);
        if (val!=0 && val->_float)
                ent_gravity = val->_float;
        else
                ent_gravity = 1.0;
-       ent->v->velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;
+       ent->fields.server->velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;
 }
 
 
@@ -424,28 +491,28 @@ SV_PushEntity
 Does not change the entities velocity at all
 ============
 */
-trace_t SV_PushEntity (edict_t *ent, vec3_t push, vec3_t pushangles)
+trace_t SV_PushEntity (prvm_edict_t *ent, vec3_t push)
 {
+       int type;
        trace_t trace;
        vec3_t end;
 
-       VectorAdd (ent->v->origin, push, end);
+       VectorAdd (ent->fields.server->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);
+       if (ent->fields.server->movetype == MOVETYPE_FLYMISSILE)
+               type = MOVE_MISSILE;
+       else if (ent->fields.server->solid == SOLID_TRIGGER || ent->fields.server->solid == SOLID_NOT)
+               type = MOVE_NOMONSTERS; // only clip against bmodels
        else
-               trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
+               type = MOVE_NORMAL;
 
-       VectorCopy (trace.endpos, ent->v->origin);
-       // FIXME: turn players specially
-       ent->v->angles[1] += trace.fraction * pushangles[1];
+       trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, type, ent);
+
+       VectorCopy (trace.endpos, ent->fields.server->origin);
        SV_LinkEdict (ent, true);
 
-       if (trace.ent && (!((int)ent->v->flags & FL_ONGROUND) || ent->v->groundentity != EDICT_TO_PROG(trace.ent)))
-               SV_Impact (ent, trace.ent);
+       if (trace.ent && (!((int)ent->fields.server->flags & FL_ONGROUND) || ent->fields.server->groundentity != PRVM_EDICT_TO_PROG(trace.ent)))
+               SV_Impact (ent, (prvm_edict_t *)trace.ent);
        return trace;
 }
 
@@ -456,18 +523,24 @@ SV_PushMove
 
 ============
 */
-trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
-void SV_PushMove (edict_t *pusher, float movetime)
+void SV_PushMove (prvm_edict_t *pusher, float movetime)
 {
        int i, e, index;
-       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];
        model_t *pushermodel;
        trace_t trace;
 
-       switch ((int) pusher->v->solid)
+       if (!pusher->fields.server->velocity[0] && !pusher->fields.server->velocity[1] && !pusher->fields.server->velocity[2] && !pusher->fields.server->avelocity[0] && !pusher->fields.server->avelocity[1] && !pusher->fields.server->avelocity[2])
+       {
+               pusher->fields.server->ltime += movetime;
+               return;
+       }
+
+       switch ((int) pusher->fields.server->solid)
        {
        // LordHavoc: valid pusher types
        case SOLID_BSP:
@@ -478,40 +551,42 @@ void SV_PushMove (edict_t *pusher, float movetime)
        // LordHavoc: no collisions
        case SOLID_NOT:
        case SOLID_TRIGGER:
-               VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
-               VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
-               pusher->v->ltime += movetime;
+               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);
+               pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
+               pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
+               pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
+               pusher->fields.server->ltime += movetime;
                SV_LinkEdict (pusher, false);
                return;
        default:
-               Host_Error("SV_PushMove: unrecognized solid type %f\n", pusher->v->solid);
+               Con_Printf("SV_PushMove: unrecognized solid type %f\n", pusher->fields.server->solid);
+               return;
        }
-       if (!pusher->v->velocity[0] && !pusher->v->velocity[1] && !pusher->v->velocity[2] && !pusher->v->avelocity[0] && !pusher->v->avelocity[1] && !pusher->v->avelocity[2])
+       index = (int) pusher->fields.server->modelindex;
+       if (index < 1 || index >= MAX_MODELS)
        {
-               pusher->v->ltime += movetime;
+               Con_Printf("SV_PushMove: invalid modelindex %f\n", pusher->fields.server->modelindex);
                return;
        }
-       index = (int) pusher->v->modelindex;
-       if (index < 1 || index >= MAX_MODELS)
-               Host_Error("SV_PushMove: invalid modelindex %f\n", pusher->v->modelindex);
        pushermodel = sv.models[index];
 
        movetime2 = movetime;
-       VectorScale(pusher->v->velocity, movetime2, move1);
-       VectorScale(pusher->v->avelocity, movetime2, moveangle);
+       VectorScale(pusher->fields.server->velocity, movetime2, move1);
+       VectorScale(pusher->fields.server->avelocity, movetime2, moveangle);
        if (moveangle[0] || moveangle[2])
        {
                for (i = 0;i < 3;i++)
                {
                        if (move1[i] > 0)
                        {
-                               mins[i] = pushermodel->rotatedmins[i] + pusher->v->origin[i] - 1;
-                               maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
+                               mins[i] = pushermodel->rotatedmins[i] + pusher->fields.server->origin[i] - 1;
+                               maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
                        }
                        else
                        {
-                               mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->v->origin[i] - 1;
-                               maxs[i] = pushermodel->rotatedmaxs[i] + pusher->v->origin[i] + 1;
+                               mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
+                               maxs[i] = pushermodel->rotatedmaxs[i] + pusher->fields.server->origin[i] + 1;
                        }
                }
        }
@@ -521,13 +596,13 @@ void SV_PushMove (edict_t *pusher, float movetime)
                {
                        if (move1[i] > 0)
                        {
-                               mins[i] = pushermodel->yawmins[i] + pusher->v->origin[i] - 1;
-                               maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
+                               mins[i] = pushermodel->yawmins[i] + pusher->fields.server->origin[i] - 1;
+                               maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
                        }
                        else
                        {
-                               mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->v->origin[i] - 1;
-                               maxs[i] = pushermodel->yawmaxs[i] + pusher->v->origin[i] + 1;
+                               mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
+                               maxs[i] = pushermodel->yawmaxs[i] + pusher->fields.server->origin[i] + 1;
                        }
                }
        }
@@ -537,13 +612,13 @@ void SV_PushMove (edict_t *pusher, float movetime)
                {
                        if (move1[i] > 0)
                        {
-                               mins[i] = pushermodel->normalmins[i] + pusher->v->origin[i] - 1;
-                               maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
+                               mins[i] = pushermodel->normalmins[i] + pusher->fields.server->origin[i] - 1;
+                               maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
                        }
                        else
                        {
-                               mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->v->origin[i] - 1;
-                               maxs[i] = pushermodel->normalmaxs[i] + pusher->v->origin[i] + 1;
+                               mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
+                               maxs[i] = pushermodel->normalmaxs[i] + pusher->fields.server->origin[i] + 1;
                        }
                }
        }
@@ -551,51 +626,49 @@ void SV_PushMove (edict_t *pusher, float movetime)
        VectorNegate (moveangle, a);
        AngleVectorsFLU (a, forward, left, up);
 
-       VectorCopy (pusher->v->origin, pushorig);
-       VectorCopy (pusher->v->angles, pushang);
-       pushltime = pusher->v->ltime;
+       VectorCopy (pusher->fields.server->origin, pushorig);
+       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->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
-       VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
-       pusher->v->ltime += movetime;
+       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);
+       pusher->fields.server->ltime += movetime;
        SV_LinkEdict (pusher, false);
 
-       savesolid = pusher->v->solid;
+       savesolid = pusher->fields.server->solid;
 
 // 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))
+
+       numcheckentities = SV_EntitiesInBox(mins, maxs, MAX_EDICTS, checkentities);
+       for (e = 0;e < numcheckentities;e++)
        {
-               if (check->free)
-                       continue;
-               if (check->v->movetype == MOVETYPE_PUSH
-                || check->v->movetype == MOVETYPE_NONE
-                || check->v->movetype == MOVETYPE_FOLLOW
-                || check->v->movetype == MOVETYPE_NOCLIP)
+               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)
                        continue;
 
                // if the entity is standing on the pusher, it will definitely be moved
-               if (!(((int)check->v->flags & FL_ONGROUND) && PROG_TO_EDICT(check->v->groundentity) == pusher))
+               if (!(((int)check->fields.server->flags & FL_ONGROUND) && PRVM_PROG_TO_EDICT(check->fields.server->groundentity) == pusher))
                {
-                       if (check->v->absmin[0] >= maxs[0]
-                        || check->v->absmax[0] <= mins[0]
-                        || check->v->absmin[1] >= maxs[1]
-                        || check->v->absmax[1] <= mins[1]
-                        || check->v->absmin[2] >= maxs[2]
-                        || check->v->absmax[2] <= mins[2])
-                               continue;
-
-                       trace = SV_ClipMoveToEntity (pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin);
-                       if (!trace.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] < 0.999f) // quick way to check if any rotation is used
+
+               if (forward[0] != 1 || left[1] != 1) // quick way to check if any rotation is used
                {
-                       VectorSubtract (check->v->origin, pusher->v->origin, org);
+                       vec3_t org2;
+                       VectorSubtract (check->fields.server->origin, pusher->fields.server->origin, org);
                        org2[0] = DotProduct (org, forward);
                        org2[1] = DotProduct (org, left);
                        org2[2] = DotProduct (org, up);
@@ -605,67 +678,81 @@ void SV_PushMove (edict_t *pusher, float movetime)
                else
                        VectorCopy (move1, move);
 
-               // remove the onground flag for non-players
-               if (check->v->movetype != MOVETYPE_WALK)
-                       check->v->flags = (int)check->v->flags & ~FL_ONGROUND;
-
-               VectorCopy (check->v->origin, check->moved_from);
-               VectorCopy (check->v->angles, check->moved_fromangles);
+               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;
 
                // try moving the contacted entity
-               pusher->v->solid = SOLID_NOT;
-               trace = SV_PushEntity (check, move, moveangle);
-               pusher->v->solid = savesolid; // was SOLID_BSP
+               pusher->fields.server->solid = SOLID_NOT;
+               trace = SV_PushEntity (check, move);
+               // FIXME: turn players specially
+               check->fields.server->angles[1] += trace.fraction * moveangle[1];
+               pusher->fields.server->solid = savesolid; // was SOLID_BSP
 
                // if it is still inside the pusher, block
-               if (SV_TestEntityPosition (check))
+               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
-                       pusher->v->solid = SOLID_NOT;
-                       VectorScale(move, 0.1, move);
-                       trace = SV_PushEntity (check, move, vec3_origin);
-                       pusher->v->solid = savesolid;
-                       if (SV_TestEntityPosition (check))
+                       vec3_t move2;
+                       pusher->fields.server->solid = SOLID_NOT;
+                       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, 0, SUPERCONTENTS_SOLID).startsolid)
                        {
-                               // still inside pusher, so it's really blocked
-
-                               // fail the move
-                               if (check->v->mins[0] == check->v->maxs[0])
-                                       continue;
-                               if (check->v->solid == SOLID_NOT || check->v->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->v->mins[0] = check->v->mins[1] = 0;
-                                       VectorCopy (check->v->mins, check->v->maxs);
-                                       continue;
+                                       // 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)
+                                       {
+                                               // corpse
+                                               check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
+                                               VectorCopy (check->fields.server->mins, check->fields.server->maxs);
+                                               continue;
+                                       }
+
+                                       VectorCopy (pushorig, pusher->fields.server->origin);
+                                       VectorCopy (pushang, pusher->fields.server->angles);
+                                       pusher->fields.server->ltime = pushltime;
+                                       SV_LinkEdict (pusher, false);
+
+                                       // 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;
                                }
-
-                               VectorCopy (pushorig, pusher->v->origin);
-                               VectorCopy (pushang, pusher->v->angles);
-                               pusher->v->ltime = pushltime;
-                               SV_LinkEdict (pusher, false);
-
-                               // move back any entities we already moved
-                               for (i = 0;i < num_moved;i++)
-                               {
-                                       ed = sv.moved_edicts[i];
-                                       VectorCopy (ed->moved_from, ed->v->origin);
-                                       VectorCopy (ed->moved_fromangles, ed->v->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->v->blocked)
-                               {
-                                       pr_global_struct->self = EDICT_TO_PROG(pusher);
-                                       pr_global_struct->other = EDICT_TO_PROG(check);
-                                       PR_ExecuteProgram (pusher->v->blocked, "");
-                               }
-                               return;
                        }
                }
        }
+       pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
+       pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
+       pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
 }
 
 /*
@@ -674,16 +761,16 @@ SV_Physics_Pusher
 
 ================
 */
-void SV_Physics_Pusher (edict_t *ent)
+void SV_Physics_Pusher (prvm_edict_t *ent)
 {
        float thinktime, oldltime, movetime;
 
-       oldltime = ent->v->ltime;
+       oldltime = ent->fields.server->ltime;
 
-       thinktime = ent->v->nextthink;
-       if (thinktime < ent->v->ltime + sv.frametime)
+       thinktime = ent->fields.server->nextthink;
+       if (thinktime < ent->fields.server->ltime + sv.frametime)
        {
-               movetime = thinktime - ent->v->ltime;
+               movetime = thinktime - ent->fields.server->ltime;
                if (movetime < 0)
                        movetime = 0;
        }
@@ -691,20 +778,17 @@ void SV_Physics_Pusher (edict_t *ent)
                movetime = sv.frametime;
 
        if (movetime)
-               // advances ent->v->ltime if not blocked
+               // advances ent->fields.server->ltime if not blocked
                SV_PushMove (ent, movetime);
 
-       if (thinktime > oldltime && thinktime <= ent->v->ltime)
+       if (thinktime > oldltime && thinktime <= ent->fields.server->ltime)
        {
-               ent->v->nextthink = 0;
-               pr_global_struct->time = sv.time;
-               pr_global_struct->self = EDICT_TO_PROG(ent);
-               pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
-               PR_ExecuteProgram (ent->v->think, "NULL think function");
-               if (ent->free)
-                       return;
+               ent->fields.server->nextthink = 0;
+               prog->globals.server->time = sv.time;
+               prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+               prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
+               PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
        }
-
 }
 
 
@@ -724,22 +808,22 @@ This is a big hack to try and fix the rare case of getting stuck in the world
 clipping hull.
 =============
 */
-void SV_CheckStuck (edict_t *ent)
+void SV_CheckStuck (prvm_edict_t *ent)
 {
        int i, j, z;
        vec3_t org;
 
        if (!SV_TestEntityPosition(ent))
        {
-               VectorCopy (ent->v->origin, ent->v->oldorigin);
+               VectorCopy (ent->fields.server->origin, ent->fields.server->oldorigin);
                return;
        }
 
-       VectorCopy (ent->v->origin, org);
-       VectorCopy (ent->v->oldorigin, ent->v->origin);
+       VectorCopy (ent->fields.server->origin, org);
+       VectorCopy (ent->fields.server->oldorigin, ent->fields.server->origin);
        if (!SV_TestEntityPosition(ent))
        {
-               Con_DPrint("Unstuck.\n");
+               Con_DPrint("Unstuck.\n");
                SV_LinkEdict (ent, true);
                return;
        }
@@ -748,19 +832,19 @@ void SV_CheckStuck (edict_t *ent)
                for (i=-1 ; i <= 1 ; i++)
                        for (j=-1 ; j <= 1 ; j++)
                        {
-                               ent->v->origin[0] = org[0] + i;
-                               ent->v->origin[1] = org[1] + j;
-                               ent->v->origin[2] = org[2] + z;
+                               ent->fields.server->origin[0] = org[0] + i;
+                               ent->fields.server->origin[1] = org[1] + j;
+                               ent->fields.server->origin[2] = org[2] + z;
                                if (!SV_TestEntityPosition(ent))
                                {
-                                       Con_DPrint("Unstuck.\n");
+                                       Con_DPrint("Unstuck.\n");
                                        SV_LinkEdict (ent, true);
                                        return;
                                }
                        }
 
-       VectorCopy (org, ent->v->origin);
-       Con_DPrint("player is stuck.\n");
+       VectorCopy (org, ent->fields.server->origin);
+       Con_DPrint("player is stuck.\n");
 }
 
 
@@ -769,35 +853,33 @@ void SV_CheckStuck (edict_t *ent)
 SV_CheckWater
 =============
 */
-qboolean SV_CheckWater (edict_t *ent)
+qboolean SV_CheckWater (prvm_edict_t *ent)
 {
        int cont;
        vec3_t point;
 
-       point[0] = ent->v->origin[0];
-       point[1] = ent->v->origin[1];
-       point[2] = ent->v->origin[2] + ent->v->mins[2] + 1;
+       point[0] = ent->fields.server->origin[0];
+       point[1] = ent->fields.server->origin[1];
+       point[2] = ent->fields.server->origin[2] + ent->fields.server->mins[2] + 1;
 
-       ent->v->waterlevel = 0;
-       ent->v->watertype = CONTENTS_EMPTY;
-       cont = Mod_PointContents(point, sv.worldmodel);
-       if (cont <= CONTENTS_WATER)
+       ent->fields.server->waterlevel = 0;
+       ent->fields.server->watertype = CONTENTS_EMPTY;
+       cont = SV_PointSuperContents(point);
+       if (cont & (SUPERCONTENTS_LIQUIDSMASK))
        {
-               ent->v->watertype = cont;
-               ent->v->waterlevel = 1;
-               point[2] = ent->v->origin[2] + (ent->v->mins[2] + ent->v->maxs[2])*0.5;
-               cont = Mod_PointContents(point, sv.worldmodel);
-               if (cont <= CONTENTS_WATER)
+               ent->fields.server->watertype = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, cont);
+               ent->fields.server->waterlevel = 1;
+               point[2] = ent->fields.server->origin[2] + (ent->fields.server->mins[2] + ent->fields.server->maxs[2])*0.5;
+               if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
                {
-                       ent->v->waterlevel = 2;
-                       point[2] = ent->v->origin[2] + ent->v->view_ofs[2];
-                       cont = Mod_PointContents(point, sv.worldmodel);
-                       if (cont <= CONTENTS_WATER)
-                               ent->v->waterlevel = 3;
+                       ent->fields.server->waterlevel = 2;
+                       point[2] = ent->fields.server->origin[2] + ent->fields.server->view_ofs[2];
+                       if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
+                               ent->fields.server->waterlevel = 3;
                }
        }
 
-       return ent->v->waterlevel > 1;
+       return ent->fields.server->waterlevel > 1;
 }
 
 /*
@@ -806,25 +888,21 @@ SV_WallFriction
 
 ============
 */
-void SV_WallFriction (edict_t *ent, trace_t *trace)
+void SV_WallFriction (prvm_edict_t *ent, float *stepnormal)
 {
        float d, i;
        vec3_t forward, into, side;
 
-       AngleVectors (ent->v->v_angle, forward, NULL, NULL);
-       d = DotProduct (trace->plane.normal, forward);
-
-       d += 0.5;
-       if (d >= 0)
-               return;
-
-       // cut the tangential velocity
-       i = DotProduct (trace->plane.normal, ent->v->velocity);
-       VectorScale (trace->plane.normal, i, into);
-       VectorSubtract (ent->v->velocity, into, side);
-
-       ent->v->velocity[0] = side[0] * (1 + d);
-       ent->v->velocity[1] = side[1] * (1 + d);
+       AngleVectors (ent->fields.server->v_angle, forward, NULL, NULL);
+       if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
+       {
+               // cut the tangential velocity
+               i = DotProduct (stepnormal, ent->fields.server->velocity);
+               VectorScale (stepnormal, i, into);
+               VectorSubtract (ent->fields.server->velocity, into, side);
+               ent->fields.server->velocity[0] = side[0] * (1 + d);
+               ent->fields.server->velocity[1] = side[1] * (1 + d);
+       }
 }
 
 /*
@@ -839,13 +917,12 @@ 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 SV_TryUnstick (prvm_edict_t *ent, vec3_t oldvel)
 {
        int i, clip;
        vec3_t oldorg, dir;
-       trace_t steptrace;
 
-       VectorCopy (ent->v->origin, oldorg);
+       VectorCopy (ent->fields.server->origin, oldorg);
        VectorClear (dir);
 
        for (i=0 ; i<8 ; i++)
@@ -863,24 +940,28 @@ int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
                        case 7: dir[0] = -2; dir[1] = -2; break;
                }
 
-               SV_PushEntity (ent, dir, vec3_origin);
+               SV_PushEntity (ent, dir);
 
                // retry the original move
-               ent->v->velocity[0] = oldvel[0];
-               ent->v->velocity[1] = oldvel[1];
-               ent->v->velocity[2] = 0;
-               clip = SV_FlyMove (ent, 0.1, &steptrace);
+               ent->fields.server->velocity[0] = oldvel[0];
+               ent->fields.server->velocity[1] = oldvel[1];
+               ent->fields.server->velocity[2] = 0;
+               clip = SV_FlyMove (ent, 0.1, NULL);
 
-               if (fabs(oldorg[1] - ent->v->origin[1]) > 4
-                || fabs(oldorg[0] - ent->v->origin[0]) > 4)
+               if (fabs(oldorg[1] - ent->fields.server->origin[1]) > 4
+                || fabs(oldorg[0] - ent->fields.server->origin[0]) > 4)
+               {
+                       Con_DPrint("TryUnstick - success.\n");
                        return clip;
+               }
 
                // go back to the original pos and try again
-               VectorCopy (oldorg, ent->v->origin);
+               VectorCopy (oldorg, ent->fields.server->origin);
        }
 
        // still not moving
-       VectorClear (ent->v->velocity);
+       VectorClear (ent->fields.server->velocity);
+       Con_DPrint("TryUnstick - failure.\n");
        return 7;
 }
 
@@ -891,169 +972,132 @@ SV_WalkMove
 Only used by players
 ======================
 */
-void SV_WalkMove (edict_t *ent)
+void SV_WalkMove (prvm_edict_t *ent)
 {
-       int clip, oldonground;
-       vec3_t upmove, downmove, oldorg, oldvel, nosteporg, nostepvel;
-       trace_t steptrace, downtrace;
+       int clip, oldonground, originalmove_clip, originalmove_flags, originalmove_groundentity;
+       vec3_t upmove, downmove, start_origin, start_velocity, stepnormal, originalmove_origin, originalmove_velocity;
+       trace_t downtrace;
+
+       SV_CheckVelocity(ent);
 
        // 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;
+       oldonground = (int)ent->fields.server->flags & FL_ONGROUND;
+       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
 
-       VectorCopy (ent->v->origin, oldorg);
-       VectorCopy (ent->v->velocity, oldvel);
+       VectorCopy (ent->fields.server->origin, start_origin);
+       VectorCopy (ent->fields.server->velocity, start_velocity);
 
-       clip = SV_FlyMove (ent, sv.frametime, &steptrace);
+       clip = SV_FlyMove (ent, sv.frametime, NULL);
 
-       // if move didn't block on a step, return
-       if ( !(clip & 2) )
-               return;
+       SV_CheckVelocity(ent);
 
-       if (ent->v->movetype != MOVETYPE_FLY)
-       {
-               if (!oldonground && ent->v->waterlevel == 0 && !sv_jumpstep.integer)
-                       // don't stair up while jumping
-                       return;
+       VectorCopy(ent->fields.server->origin, originalmove_origin);
+       VectorCopy(ent->fields.server->velocity, originalmove_velocity);
+       originalmove_clip = clip;
+       originalmove_flags = (int)ent->fields.server->flags;
+       originalmove_groundentity = ent->fields.server->groundentity;
 
-               if (ent->v->movetype != MOVETYPE_WALK)
-                       // gibbed by a trigger
-                       return;
-       }
+       if ((int)ent->fields.server->flags & FL_WATERJUMP)
+               return;
 
        if (sv_nostep.integer)
                return;
 
-       if ( (int)sv_player->v->flags & FL_WATERJUMP )
-               return;
+       // if move didn't block on a step, return
+       if (clip & 2)
+       {
+               // if move was not trying to move into the step, return
+               if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
+                       return;
+
+               if (ent->fields.server->movetype != MOVETYPE_FLY)
+               {
+                       // return if gibbed by a trigger
+                       if (ent->fields.server->movetype != MOVETYPE_WALK)
+                               return;
 
-       VectorCopy (ent->v->origin, nosteporg);
-       VectorCopy (ent->v->velocity, nostepvel);
+                       // only step up while jumping if that is enabled
+                       if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))
+                               if (!oldonground && ent->fields.server->waterlevel == 0)
+                                       return;
+               }
 
-       // try moving up and forward to go up a step
-       // back to start pos
-       VectorCopy (oldorg, ent->v->origin);
+               // try moving up and forward to go up a step
+               // back to start pos
+               VectorCopy (start_origin, ent->fields.server->origin);
+               VectorCopy (start_velocity, ent->fields.server->velocity);
+
+               // move up
+               VectorClear (upmove);
+               upmove[2] = sv_stepheight.value;
+               // FIXME: don't link?
+               SV_PushEntity(ent, upmove);
+
+               // move forward
+               ent->fields.server->velocity[2] = 0;
+               clip = SV_FlyMove (ent, sv.frametime, stepnormal);
+               ent->fields.server->velocity[2] += start_velocity[2];
+
+               SV_CheckVelocity(ent);
+
+               // check for stuckness, possibly due to the limited precision of floats
+               // in the clipping hulls
+               if (clip
+                && fabs(originalmove_origin[1] - ent->fields.server->origin[1]) < 0.03125
+                && fabs(originalmove_origin[0] - ent->fields.server->origin[0]) < 0.03125)
+               {
+                       //Con_Printf("wall\n");
+                       // stepping up didn't make any progress, revert to original move
+                       VectorCopy(originalmove_origin, ent->fields.server->origin);
+                       VectorCopy(originalmove_velocity, ent->fields.server->velocity);
+                       //clip = originalmove_clip;
+                       ent->fields.server->flags = originalmove_flags;
+                       ent->fields.server->groundentity = originalmove_groundentity;
+                       // now try to unstick if needed
+                       //clip = SV_TryUnstick (ent, oldvel);
+                       return;
+               }
 
-       VectorClear (upmove);
-       VectorClear (downmove);
-       upmove[2] = sv_stepheight.value;
-       downmove[2] = -sv_stepheight.value + oldvel[2]*sv.frametime;
+               //Con_Printf("step - ");
 
-       // move up
-       // FIXME: don't link?
-       SV_PushEntity (ent, upmove, vec3_origin);
-
-       // move forward
-       ent->v->velocity[0] = oldvel[0];
-       ent->v->velocity[1] = oldvel[1];
-       ent->v->velocity[2] = 0;
-       clip = SV_FlyMove (ent, sv.frametime, &steptrace);
-       ent->v->velocity[2] += oldvel[2];
-
-       // check for stuckness, possibly due to the limited precision of floats
-       // in the clipping hulls
-       if (clip
-        && 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.integer)
-               SV_WallFriction (ent, &steptrace);
+               // extra friction based on view angle
+               if (clip & 2 && sv_wallfriction.integer)
+                       SV_WallFriction (ent, stepnormal);
+       }
+       // skip out if stepdown is enabled, moving downward, not in water, and the move started onground and ended offground
+       else if (!(sv_gameplayfix_stepdown.integer && ent->fields.server->waterlevel < 2 && start_velocity[2] < (1.0 / 32.0) && oldonground && !((int)ent->fields.server->flags & FL_ONGROUND)))
+               return;
 
        // move down
+       VectorClear (downmove);
+       downmove[2] = -sv_stepheight.value + start_velocity[2]*sv.frametime;
        // FIXME: don't link?
-       downtrace = SV_PushEntity (ent, downmove, vec3_origin);
+       downtrace = SV_PushEntity (ent, downmove);
 
-       if (downtrace.plane.normal[2] > 0.7)
+       if (downtrace.fraction < 1 && downtrace.plane.normal[2] > 0.7)
        {
-               // LordHavoc: disabled this so you can walk on monsters/players
-               //if (ent->v->solid == SOLID_BSP)
+               // LordHavoc: disabled this check so you can walk on monsters/players
+               //if (ent->fields.server->solid == SOLID_BSP)
                {
-                       ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
-                       ent->v->groundentity = EDICT_TO_PROG(downtrace.ent);
+                       //Con_Printf("onground\n");
+                       ent->fields.server->flags =     (int)ent->fields.server->flags | FL_ONGROUND;
+                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(downtrace.ent);
                }
        }
        else
        {
+               //Con_Printf("slope\n");
                // if the push down didn't end up on good ground, use the move without
                // the step up.  This happens near wall / slope combinations, and can
                // cause the player to hop up higher on a slope too steep to climb
-               VectorCopy (nosteporg, ent->v->origin);
-               VectorCopy (nostepvel, ent->v->velocity);
-       }
-}
-
-
-/*
-================
-SV_Physics_Client
-
-Player character actions
-================
-*/
-void SV_Physics_Client (edict_t *ent, int num)
-{
-       if (!svs.clients[num-1].active)
-               return;         // unconnected slot
-
-       // call standard client pre-think
-       pr_global_struct->time = sv.time;
-       pr_global_struct->self = EDICT_TO_PROG(ent);
-       PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
-
-       // 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, sv.frametime, NULL);
-               SV_WalkMove (ent);
-               break;
-
-       case MOVETYPE_NOCLIP:
-               if (!SV_RunThink (ent))
-                       return;
-               SV_CheckWater (ent);
-               VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
-               VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
-               break;
-
-       default:
-               Host_Error ("SV_Physics_client: bad movetype %i", (int)ent->v->movetype);
+               VectorCopy(originalmove_origin, ent->fields.server->origin);
+               VectorCopy(originalmove_velocity, ent->fields.server->velocity);
+               //clip = originalmove_clip;
+               ent->fields.server->flags = originalmove_flags;
+               ent->fields.server->groundentity = originalmove_groundentity;
        }
 
-       // call standard player post-think
-       SV_LinkEdict (ent, true);
-
-       pr_global_struct->time = sv.time;
-       pr_global_struct->self = EDICT_TO_PROG(ent);
-       PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
+       SV_CheckVelocity(ent);
 }
 
 //============================================================================
@@ -1065,63 +1109,44 @@ SV_Physics_Follow
 Entities that are "stuck" to another entity
 =============
 */
-void SV_Physics_Follow (edict_t *ent)
+void SV_Physics_Follow (prvm_edict_t *ent)
 {
        vec3_t vf, vr, vu, angles, v;
-       edict_t *e;
+       prvm_edict_t *e;
 
        // regular thinking
        if (!SV_RunThink (ent))
                return;
 
        // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
-       e = PROG_TO_EDICT(ent->v->aiment);
-       if (e->v->angles[0] == ent->v->punchangle[0] && e->v->angles[1] == ent->v->punchangle[1] && e->v->angles[2] == ent->v->punchangle[2])
+       e = PRVM_PROG_TO_EDICT(ent->fields.server->aiment);
+       if (e->fields.server->angles[0] == ent->fields.server->punchangle[0] && e->fields.server->angles[1] == ent->fields.server->punchangle[1] && e->fields.server->angles[2] == ent->fields.server->punchangle[2])
        {
                // quick case for no rotation
-               VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
+               VectorAdd(e->fields.server->origin, ent->fields.server->view_ofs, ent->fields.server->origin);
        }
        else
        {
-               angles[0] = -ent->v->punchangle[0];
-               angles[1] =  ent->v->punchangle[1];
-               angles[2] =  ent->v->punchangle[2];
+               angles[0] = -ent->fields.server->punchangle[0];
+               angles[1] =  ent->fields.server->punchangle[1];
+               angles[2] =  ent->fields.server->punchangle[2];
                AngleVectors (angles, vf, vr, vu);
-               v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
-               v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
-               v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
-               angles[0] = -e->v->angles[0];
-               angles[1] =  e->v->angles[1];
-               angles[2] =  e->v->angles[2];
+               v[0] = ent->fields.server->view_ofs[0] * vf[0] + ent->fields.server->view_ofs[1] * vr[0] + ent->fields.server->view_ofs[2] * vu[0];
+               v[1] = ent->fields.server->view_ofs[0] * vf[1] + ent->fields.server->view_ofs[1] * vr[1] + ent->fields.server->view_ofs[2] * vu[1];
+               v[2] = ent->fields.server->view_ofs[0] * vf[2] + ent->fields.server->view_ofs[1] * vr[2] + ent->fields.server->view_ofs[2] * vu[2];
+               angles[0] = -e->fields.server->angles[0];
+               angles[1] =  e->fields.server->angles[1];
+               angles[2] =  e->fields.server->angles[2];
                AngleVectors (angles, vf, vr, vu);
-               ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
-               ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
-               ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
+               ent->fields.server->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->fields.server->origin[0];
+               ent->fields.server->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->fields.server->origin[1];
+               ent->fields.server->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->fields.server->origin[2];
        }
-       VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
+       VectorAdd (e->fields.server->angles, ent->fields.server->v_angle, ent->fields.server->angles);
        SV_LinkEdict (ent, true);
 }
 
 /*
-=============
-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, sv.frametime, ent->v->avelocity, ent->v->angles);
-       VectorMA (ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
-
-       SV_LinkEdict (ent, false);
-}
-
-/*
 ==============================================================================
 
 TOSS / BOUNCE
@@ -1135,35 +1160,31 @@ SV_CheckWaterTransition
 
 =============
 */
-void SV_CheckWaterTransition (edict_t *ent)
+void SV_CheckWaterTransition (prvm_edict_t *ent)
 {
        int cont;
-       cont = Mod_PointContents(ent->v->origin, sv.worldmodel);
-       if (!ent->v->watertype)
+       cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(ent->fields.server->origin));
+       if (!ent->fields.server->watertype)
        {
                // just spawned here
-               ent->v->watertype = cont;
-               ent->v->waterlevel = 1;
+               ent->fields.server->watertype = cont;
+               ent->fields.server->waterlevel = 1;
                return;
        }
 
+       // check if the entity crossed into or out of water
+       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)
        {
-               if (ent->v->watertype == CONTENTS_EMPTY && cont != CONTENTS_LAVA)
-                       // just crossed into water
-                       SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
-
-               ent->v->watertype = cont;
-               ent->v->waterlevel = 1;
+               ent->fields.server->watertype = cont;
+               ent->fields.server->waterlevel = 1;
        }
        else
        {
-               if (ent->v->watertype != CONTENTS_EMPTY && ent->v->watertype != CONTENTS_LAVA)
-                       // just crossed into water
-                       SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
-
-               ent->v->watertype = CONTENTS_EMPTY;
-               ent->v->waterlevel = cont;
+               ent->fields.server->watertype = CONTENTS_EMPTY;
+               ent->fields.server->waterlevel = 0;
        }
 }
 
@@ -1174,88 +1195,98 @@ SV_Physics_Toss
 Toss, bounce, and fly movement.  When onground, do nothing.
 =============
 */
-void SV_Physics_Toss (edict_t *ent)
+void SV_Physics_Toss (prvm_edict_t *ent)
 {
        trace_t trace;
        vec3_t move;
-       edict_t *groundentity;
 
-       // regular thinking
-       if (!SV_RunThink (ent))
-               return;
+       // 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->v->flags & FL_ONGROUND)
+       if ((int)ent->fields.server->flags & FL_ONGROUND)
        {
-               VectorClear(ent->v->velocity);
-               if (ent->v->groundentity == 0)
+               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)
-               groundentity = PROG_TO_EDICT(ent->v->groundentity);
-               if (groundentity->v->solid == SOLID_BSP)
-               {
-                       ent->suspendedinairflag = true;
-                       return;
-               }
-               else if (ent->suspendedinairflag && groundentity->free)
+               if (ent->priv.server->suspendedinairflag && PRVM_PROG_TO_EDICT(ent->fields.server->groundentity)->priv.server->free)
                {
                        // leave it suspended in the air
-                       ent->v->groundentity = 0;
-                       ent->suspendedinairflag = false;
+                       ent->fields.server->groundentity = 0;
                        return;
                }
        }
-       ent->suspendedinairflag = false;
+       ent->priv.server->suspendedinairflag = false;
 
        SV_CheckVelocity (ent);
 
 // add gravity
-       if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
+       if (ent->fields.server->movetype == MOVETYPE_TOSS || ent->fields.server->movetype == MOVETYPE_BOUNCE)
                SV_AddGravity (ent);
 
 // move angles
-       VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
+       VectorMA (ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
 
 // move origin
-       VectorScale (ent->v->velocity, sv.frametime, move);
-       trace = SV_PushEntity (ent, move, vec3_origin);
-       if (ent->free)
+       VectorScale (ent->fields.server->velocity, sv.frametime, move);
+       trace = SV_PushEntity (ent, move);
+       if (ent->priv.server->free)
                return;
 
        if (trace.fraction < 1)
        {
-               if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
+               if (ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE)
                {
-                       ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
-                       ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
+                       ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 2.0);
+                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
                }
-               else if (ent->v->movetype == MOVETYPE_BOUNCE)
+               else if (ent->fields.server->movetype == MOVETYPE_BOUNCE)
                {
-                       ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
+                       float d;
+                       ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1.5);
                        // LordHavoc: fixed grenades not bouncing when fired down a slope
-                       if (trace.plane.normal[2] > 0.7 && DotProduct(trace.plane.normal, ent->v->velocity) < 60)
+                       if (sv_gameplayfix_grenadebouncedownslopes.integer)
                        {
-                               ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
-                               ent->v->groundentity = EDICT_TO_PROG(trace.ent);
-                               VectorClear (ent->v->velocity);
-                               VectorClear (ent->v->avelocity);
+                               d = DotProduct(trace.plane.normal, ent->fields.server->velocity);
+                               if (trace.plane.normal[2] > 0.7 && fabs(d) < 60)
+                               {
+                                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
+                                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                                       VectorClear (ent->fields.server->velocity);
+                                       VectorClear (ent->fields.server->avelocity);
+                               }
+                               else
+                                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
                        }
                        else
-                               ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
+                       {
+                               if (trace.plane.normal[2] > 0.7 && ent->fields.server->velocity[2] < 60)
+                               {
+                                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
+                                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                                       VectorClear (ent->fields.server->velocity);
+                                       VectorClear (ent->fields.server->avelocity);
+                               }
+                               else
+                                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+                       }
                }
                else
                {
-                       ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
+                       ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1.0);
                        if (trace.plane.normal[2] > 0.7)
                        {
-                               ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
-                               ent->v->groundentity = EDICT_TO_PROG(trace.ent);
-                               VectorClear (ent->v->velocity);
-                               VectorClear (ent->v->avelocity);
+                               ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
+                               ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                               if (((prvm_edict_t *)trace.ent)->fields.server->solid == SOLID_BSP)
+                                       ent->priv.server->suspendedinairflag = true;
+                               VectorClear (ent->fields.server->velocity);
+                               VectorClear (ent->fields.server->avelocity);
                        }
                        else
-                               ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
+                               ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
                }
        }
 
@@ -1282,55 +1313,180 @@ 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)
+void SV_Physics_Step (prvm_edict_t *ent)
 {
-       int flags, fall, hitsound;
+       // 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 fly/swim
-       fall = true;
-       flags = (int)ent->v->flags;
-       if (flags & (FL_FLY | FL_SWIM))
+       // freefall if not onground/fly/swim
+       if (!((int)ent->fields.server->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
        {
-               if (flags & FL_FLY)
-                       fall = false;
-               else if ((flags & FL_SWIM) && Mod_PointContents(ent->v->origin, sv.worldmodel) != CONTENTS_EMPTY)
-                       fall = false;
+               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);
+
+               // just hit ground
+               if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND && gamemode != GAME_NEXUIZ)
+                       SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
        }
-       if (fall && (flags & FL_ONGROUND) && ent->v->groundentity == 0)
-               fall = false;
 
-       if (fall)
+// regular thinking
+       SV_RunThink(ent);
+
+       SV_CheckWaterTransition(ent);
+}
+
+//============================================================================
+
+static void SV_Physics_Entity (prvm_edict_t *ent, qboolean runmove)
+{
+       switch ((int) ent->fields.server->movetype)
        {
-               if (ent->v->velocity[2] < sv_gravity.value*-0.1)
+       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))
                {
-                       hitsound = true;
-                       if (flags & FL_ONGROUND)
-                               hitsound = false;
+                       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
-                       hitsound = false;
+               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;
+       }
+}
 
-               SV_AddGravity (ent);
-               SV_CheckVelocity (ent);
-               SV_FlyMove (ent, sv.frametime, NULL);
-               SV_LinkEdict (ent, false);
+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 ((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);
 
-               // just hit ground
-               if ((int)ent->v->flags & FL_ONGROUND)
+       switch ((int) ent->fields.server->movetype)
+       {
+       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))
+               {
+                       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);
+               }
+               break;
+       case MOVETYPE_STEP:
+               SV_Physics_Step (ent);
+               break;
+       case MOVETYPE_WALK:
+               if (SV_RunThink (ent))
                {
-                       VectorClear(ent->v->velocity);
-                       if (hitsound)
-                               SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
+                       if (!SV_CheckWater (ent) && ! ((int)ent->fields.server->flags & FL_WATERJUMP) )
+                               SV_AddGravity (ent);
+                       SV_CheckStuck (ent);
+                       SV_WalkMove (ent);
                }
+               break;
+       case MOVETYPE_TOSS:
+       case MOVETYPE_BOUNCE:
+       case MOVETYPE_BOUNCEMISSILE:
+       case MOVETYPE_FLYMISSILE:
+               // regular thinking
+               if (SV_RunThink (ent))
+                       SV_Physics_Toss (ent);
+               break;
+       case MOVETYPE_FLY:
+               if (SV_RunThink (ent))
+               {
+                       SV_CheckWater (ent);
+                       SV_WalkMove (ent);
+               }
+               break;
+       default:
+               Con_Printf ("SV_Physics_ClientEntity: bad movetype %i", (int)ent->fields.server->movetype);
+               break;
        }
 
-// regular thinking
-       SV_RunThink (ent);
+       SV_CheckVelocity (ent);
 
-       SV_CheckWaterTransition (ent);
-}
+       // call standard player post-think
+       SV_LinkEdict (ent, true);
 
-//============================================================================
+       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");
+}
 
 /*
 ================
@@ -1340,113 +1496,93 @@ SV_Physics
 */
 void SV_Physics (void)
 {
-       int i;
-       edict_t *ent;
+       int i, newnum_edicts;
+       prvm_edict_t *ent;
+       unsigned char runmove[MAX_EDICTS];
 
 // 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, "QC function StartFrame is missing");
+       prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
+       prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
+       prog->globals.server->time = sv.time;
+       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))
+                       newnum_edicts = i + 1;
+       prog->num_edicts = max(svs.maxclients + 1, newnum_edicts);
 
 //
 // treat each object in turn
 //
-       ent = sv.edicts;
-       for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
-       {
-               if (ent->free)
-                       continue;
-
-               if (pr_global_struct->force_retouch)
-                       SV_LinkEdict (ent, true);       // force retouch even for stationary
 
-               if (i > 0 && i <= svs.maxclients)
-               {
-                       SV_Physics_Client (ent, i);
-                       continue;
-               }
+       // 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
 
-               switch ((int) ent->v->movetype)
+       // 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)
                {
-               case MOVETYPE_PUSH:
-                       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->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
-                               SV_RunThink (ent);
-                       break;
-               case MOVETYPE_FOLLOW:
-                       SV_Physics_Follow (ent);
-                       break;
-               case MOVETYPE_NOCLIP:
-                       SV_Physics_Noclip (ent);
-                       break;
-               case MOVETYPE_STEP:
-                       SV_Physics_Step (ent);
-                       break;
-               // LordHavoc: added support for MOVETYPE_WALK on normal entities! :)
-               case MOVETYPE_WALK:
-                       if (SV_RunThink (ent))
-                       {
-                               if (!SV_CheckWater (ent) && ! ((int)ent->v->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_FLY:
-               case MOVETYPE_FLYMISSILE:
-                       SV_Physics_Toss (ent);
-                       break;
-               default:
-                       Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
-                       break;
+                       // don't do physics on disconnected clients, FrikBot relies on this
+                       if (!host_client->spawned)
+                               memset(&host_client->cmd, 0, sizeof(host_client->cmd));
+                       // don't run physics here if running asynchronously
+                       else if (!host_client->movesequence)
+                               SV_Physics_ClientEntity(ent);
                }
        }
 
-       if (pr_global_struct->force_retouch)
-               pr_global_struct->force_retouch--;
+       // 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);
 
        // LordHavoc: endframe support
        if (EndFrameQC)
        {
-               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 ((func_t)(EndFrameQC - pr_functions), "");
+               prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
+               prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
+               prog->globals.server->time = sv.time;
+               PRVM_ExecuteProgram ((func_t)(EndFrameQC - prog->functions), "QC function EndFrame is missing");
        }
 
-       sv.time += sv.frametime;
+       if (!sv_freezenonclients.integer)
+               sv.time += sv.frametime;
 }
 
 
-trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
+trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
 {
        int i;
        float gravity, savesolid;
        vec3_t move, end;
-       edict_t tempent, *tent;
+       prvm_edict_t tempent, *tent;
        entvars_t vars;
-       eval_t *val;
+       prvm_eval_t *val;
        trace_t trace;
 
        // copy the vars over
-       memcpy(&vars, tossent->v, sizeof(entvars_t));
+       memcpy(&vars, tossent->fields.server, sizeof(entvars_t));
        // set up the temp entity to point to the copied vars
        tent = &tempent;
-       tent->v = &vars;
+       tent->fields.server = &vars;
 
-       savesolid = tossent->v->solid;
-       tossent->v->solid = SOLID_NOT;
+       savesolid = tossent->fields.server->solid;
+       tossent->fields.server->solid = SOLID_NOT;
 
        // this has to fetch the field from the original edict, since our copy is truncated
-       val = GETEDICTFIELDVALUE(tossent, eval_gravity);
+       val = PRVM_GETEDICTFIELDVALUE(tossent, eval_gravity);
        if (val != NULL && val->_float != 0)
                gravity = val->_float;
        else
@@ -1456,18 +1592,17 @@ trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
        for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
        {
                SV_CheckVelocity (tent);
-               tent->v->velocity[2] -= gravity;
-               VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
-               VectorScale (tent->v->velocity, 0.05, move);
-               VectorAdd (tent->v->origin, move, end);
-               trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
-               VectorCopy (trace.endpos, tent->v->origin);
-
-               if (trace.fraction < 1 && trace.ent)
-                       if (trace.ent != ignore)
-                               break;
+               tent->fields.server->velocity[2] -= gravity;
+               VectorMA (tent->fields.server->angles, 0.05, tent->fields.server->avelocity, tent->fields.server->angles);
+               VectorScale (tent->fields.server->velocity, 0.05, move);
+               VectorAdd (tent->fields.server->origin, move, end);
+               trace = SV_Move (tent->fields.server->origin, tent->fields.server->mins, tent->fields.server->maxs, end, MOVE_NORMAL, tent);
+               VectorCopy (trace.endpos, tent->fields.server->origin);
+
+               if (trace.fraction < 1 && trace.ent && trace.ent != ignore)
+                       break;
        }
-       tossent->v->solid = savesolid;
+       tossent->fields.server->solid = savesolid;
        trace.fraction = 0; // not relevant
        return trace;
 }