forgot to put a newline at the end of the file

[xonotic/darkplaces.git] / sv_phys.c

diff --git a/sv_phys.c b/sv_phys.c
index ffe1ce9c2b667086abbede91b1852bc94c4c4ac9..fcb8587ef751c52a85820a4b32e32d179b86e2cc 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 
 See the GNU General Public License for more details.
 
 
 See the GNU General Public License for more details.
 


@@ -26,7 +26,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 pushmove objects do not obey gravity, and do not interact with each other or trigger fields, but block normal movement and push normal objects when they move.
 
 
 pushmove objects do not obey gravity, and do not interact with each other or trigger fields, but block normal movement and push normal objects when they move.
 

-onground is set for toss objects when they come to a complete rest.  it is set for steping or walking objects 
+onground is set for toss objects when they come to a complete rest.  it is set for steping or walking objects

 
 doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
 bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
 
 doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
 bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS


@@ -39,11 +39,11 @@ solid_edge items only clip against bsp models.
 
 */
 
 
 */
 

-cvar_t sv_friction = {"sv_friction","4",false,true};
-cvar_t sv_stopspeed = {"sv_stopspeed","100"};
-cvar_t sv_gravity = {"sv_gravity","800",false,true};
-cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"};
-cvar_t sv_nostep = {"sv_nostep","0"};
+cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4"};
+cvar_t sv_stopspeed = {0, "sv_stopspeed","100"};
+cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800"};
+cvar_t sv_maxvelocity = {0, "sv_maxvelocity","2000"};
+cvar_t sv_nostep = {0, "sv_nostep","0"};

 
 #define        MOVE_EPSILON    0.01
 
 
 #define        MOVE_EPSILON    0.01
 


@@ -137,7 +137,7 @@ qboolean SV_RunThink (edict_t *ent)
        float   thinktime;
 
        thinktime = ent->v.nextthink;
        float   thinktime;
 
        thinktime = ent->v.nextthink;

-       if (thinktime <= 0 || thinktime > sv.time + host_frametime)
+       if (thinktime <= 0 || thinktime > sv.time + sv.frametime)

                return true;
                
        if (thinktime < sv.time)
                return true;
                
        if (thinktime < sv.time)


@@ -148,7 +148,7 @@ qboolean SV_RunThink (edict_t *ent)
        pr_global_struct->time = thinktime;
        pr_global_struct->self = EDICT_TO_PROG(ent);
        pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
        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);
+       PR_ExecuteProgram (ent->v.think, "NULL think function");

        return !ent->free;
 }
 
        return !ent->free;
 }
 


@@ -171,14 +171,14 @@ void SV_Impact (edict_t *e1, edict_t *e2)
        {
                pr_global_struct->self = EDICT_TO_PROG(e1);
                pr_global_struct->other = EDICT_TO_PROG(e2);
        {
                pr_global_struct->self = EDICT_TO_PROG(e1);
                pr_global_struct->other = EDICT_TO_PROG(e2);

-               PR_ExecuteProgram (e1->v.touch);
+               PR_ExecuteProgram (e1->v.touch, "");

        }
        
        if (e2->v.touch && e2->v.solid != SOLID_NOT)
        {
                pr_global_struct->self = EDICT_TO_PROG(e2);
                pr_global_struct->other = EDICT_TO_PROG(e1);
        }
        
        if (e2->v.touch && e2->v.solid != SOLID_NOT)
        {
                pr_global_struct->self = EDICT_TO_PROG(e2);
                pr_global_struct->other = EDICT_TO_PROG(e1);

-               PR_ExecuteProgram (e2->v.touch);
+               PR_ExecuteProgram (e2->v.touch, "");

        }
 
        pr_global_struct->self = old_self;
        }
 
        pr_global_struct->self = old_self;


@@ -234,7 +234,11 @@ Returns the clipflags if the velocity was modified (hit something solid)
 If steptrace is not NULL, the trace of any vertical wall hit will be stored
 ============
 */
 If steptrace is not NULL, the trace of any vertical wall hit will be stored
 ============
 */

-#define        MAX_CLIP_PLANES 5
+// LordHavoc: increased from 5 to 20, to partially fix angled corner sticking
+// (example - start.bsp hall to e1m4, leading to the pool there are two
+//  angled corners, which you could get stuck on, now they are just a one
+//  frame hiccup)
+#define        MAX_CLIP_PLANES 20

 int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
 {
        int                     bumpcount, numbumps;
 int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
 {
        int                     bumpcount, numbumps;


@@ -266,11 +270,11 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
                for (i=0 ; i<3 ; i++)
                        end[i] = ent->v.origin[i] + time_left * ent->v.velocity[i];
 
                for (i=0 ; i<3 ; i++)
                        end[i] = ent->v.origin[i] + time_left * ent->v.velocity[i];
 

-               trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent);
+               trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);

 
                if (trace.allsolid)
                {       // entity is trapped in another solid
 
                if (trace.allsolid)
                {       // entity is trapped in another solid

-                       VectorCopy (vec3_origin, ent->v.velocity);
+                       VectorClear(ent->v.velocity);

                        return 3;
                }
 
                        return 3;
                }
 


@@ -316,7 +320,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
        // cliped to another plane
                if (numplanes >= MAX_CLIP_PLANES)
                {       // this shouldn't really happen
        // cliped to another plane
                if (numplanes >= MAX_CLIP_PLANES)
                {       // this shouldn't really happen

-                       VectorCopy (vec3_origin, ent->v.velocity);
+                       VectorClear(ent->v.velocity);

                        return 3;
                }
 
                        return 3;
                }
 


@@ -348,7 +352,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
                        if (numplanes != 2)
                        {
 //                             Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
                        if (numplanes != 2)
                        {
 //                             Con_Printf ("clip velocity, numplanes == %i\n",numplanes);

-                               VectorCopy (vec3_origin, ent->v.velocity);
+                               VectorClear(ent->v.velocity);

                                return 7;
                        }
                        CrossProduct (planes[0], planes[1], dir);
                                return 7;
                        }
                        CrossProduct (planes[0], planes[1], dir);


@@ -362,7 +366,7 @@ int SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
 //
                if (DotProduct (ent->v.velocity, primal_velocity) <= 0)
                {
 //
                if (DotProduct (ent->v.velocity, primal_velocity) <= 0)
                {

-                       VectorCopy (vec3_origin, ent->v.velocity);
+                       VectorClear(ent->v.velocity);

                        return blocked;
                }
        }
                        return blocked;
                }
        }


@@ -388,7 +392,7 @@ void SV_AddGravity (edict_t *ent)
                ent_gravity = val->_float;
        else
                ent_gravity = 1.0;
                ent_gravity = val->_float;
        else
                ent_gravity = 1.0;

-       ent->v.velocity[2] -= ent_gravity * sv_gravity.value * host_frametime;
+       ent->v.velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;

 }
 
 
 }
 
 


@@ -560,7 +564,7 @@ void SV_PushMove (edict_t *pusher, float movetime)
                                {
                                        pr_global_struct->self = EDICT_TO_PROG(pusher);
                                        pr_global_struct->other = EDICT_TO_PROG(check);
                                {
                                        pr_global_struct->self = EDICT_TO_PROG(pusher);
                                        pr_global_struct->other = EDICT_TO_PROG(check);

-                                       PR_ExecuteProgram (pusher->v.blocked);
+                                       PR_ExecuteProgram (pusher->v.blocked, "");

                                }
                                
                                // move back any entities we already moved
                                }
                                
                                // move back any entities we already moved


@@ -598,6 +602,24 @@ void SV_PushRotate (edict_t *pusher, float movetime)
        vec3_t          forward, right, up;
        float           savesolid;
 
        vec3_t          forward, right, up;
        float           savesolid;
 

+       switch ((int) pusher->v.solid)
+       {
+       // LordHavoc: valid pusher types
+       case SOLID_BSP:
+       case SOLID_BBOX:
+       case SOLID_SLIDEBOX:
+       case SOLID_CORPSE: // LordHavoc: this would be weird...
+               break;
+       // LordHavoc: no collisions
+       case SOLID_NOT:
+       case SOLID_TRIGGER:
+               VectorMA (pusher->v.angles, movetime, pusher->v.avelocity, pusher->v.angles);
+               pusher->v.ltime += movetime;
+               SV_LinkEdict (pusher, false);
+               return;
+       default:
+               Host_Error("SV_PushRotate: unrecognized solid type %f\n", pusher->v.solid);
+       }

        if (!pusher->v.avelocity[0] && !pusher->v.avelocity[1] && !pusher->v.avelocity[2])
        {
                pusher->v.ltime += movetime;
        if (!pusher->v.avelocity[0] && !pusher->v.avelocity[1] && !pusher->v.avelocity[2])
        {
                pusher->v.ltime += movetime;


@@ -607,7 +629,7 @@ void SV_PushRotate (edict_t *pusher, float movetime)
        for (i=0 ; i<3 ; i++)
                amove[i] = pusher->v.avelocity[i] * movetime;
 
        for (i=0 ; i<3 ; i++)
                amove[i] = pusher->v.avelocity[i] * movetime;
 

-       VectorSubtract (vec3_origin, amove, a);
+       VectorNegate (amove, a);

        AngleVectors (a, forward, right, up);
 
        VectorCopy (pusher->v.origin, pushorigin);
        AngleVectors (a, forward, right, up);
 
        VectorCopy (pusher->v.origin, pushorigin);


@@ -701,7 +723,7 @@ void SV_PushRotate (edict_t *pusher, float movetime)
                        {
                                pr_global_struct->self = EDICT_TO_PROG(pusher);
                                pr_global_struct->other = EDICT_TO_PROG(check);
                        {
                                pr_global_struct->self = EDICT_TO_PROG(pusher);
                                pr_global_struct->other = EDICT_TO_PROG(check);

-                               PR_ExecuteProgram (pusher->v.blocked);
+                               PR_ExecuteProgram (pusher->v.blocked, "");

                        }
                        
                // move back any entities we already moved
                        }
                        
                // move back any entities we already moved


@@ -731,16 +753,15 @@ void SV_Physics_Pusher (edict_t *ent)
 
        oldltime = ent->v.ltime;
        
 
        oldltime = ent->v.ltime;
        

-       /*

        thinktime = ent->v.nextthink;
        thinktime = ent->v.nextthink;

-       if (thinktime < ent->v.ltime + host_frametime)
+       if (thinktime < ent->v.ltime + sv.frametime)

        {
                movetime = thinktime - ent->v.ltime;
                if (movetime < 0)
                        movetime = 0;
        }
        else
        {
                movetime = thinktime - ent->v.ltime;
                if (movetime < 0)
                        movetime = 0;
        }
        else

-               movetime = host_frametime;
+               movetime = sv.frametime;

 
        if (movetime)
        {
 
        if (movetime)
        {


@@ -749,23 +770,6 @@ void SV_Physics_Pusher (edict_t *ent)
                else
                        SV_PushMove (ent, movetime);    // advances ent->v.ltime if not blocked
        }
                else
                        SV_PushMove (ent, movetime);    // advances ent->v.ltime if not blocked
        }

-       */
-       if (ent->v.avelocity[0] || ent->v.avelocity[1] || ent->v.avelocity[2])
-               SV_PushRotate (ent, host_frametime);
-       else
-       {
-               thinktime = ent->v.nextthink;
-               if (thinktime < ent->v.ltime + host_frametime)
-               {
-                       movetime = thinktime - ent->v.ltime;
-                       if (movetime < 0)
-                               movetime = 0;
-               }
-               else
-                       movetime = host_frametime;
-               if (movetime)
-                       SV_PushMove (ent, movetime);    // advances ent->v.ltime if not blocked
-       }

                
        if (thinktime > oldltime && thinktime <= ent->v.ltime)
        {
                
        if (thinktime > oldltime && thinktime <= ent->v.ltime)
        {


@@ -773,7 +777,7 @@ void SV_Physics_Pusher (edict_t *ent)
                pr_global_struct->time = sv.time;
                pr_global_struct->self = EDICT_TO_PROG(ent);
                pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
                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);
+               PR_ExecuteProgram (ent->v.think, "NULL think function");

                if (ent->free)
                        return;
        }
                if (ent->free)
                        return;
        }


@@ -882,11 +886,11 @@ SV_WallFriction
 */
 void SV_WallFriction (edict_t *ent, trace_t *trace)
 {
 */
 void SV_WallFriction (edict_t *ent, trace_t *trace)
 {

-       vec3_t          forward, right, up;
+       vec3_t          forward;

        float           d, i;
        vec3_t          into, side;
        
        float           d, i;
        vec3_t          into, side;
        

-       AngleVectors (ent->v.v_angle, forward, right, up);
+       AngleVectors (ent->v.v_angle, forward, NULL, NULL);

        d = DotProduct (trace->plane.normal, forward);
        
        d += 0.5;
        d = DotProduct (trace->plane.normal, forward);
        
        d += 0.5;


@@ -923,7 +927,7 @@ int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
        trace_t steptrace;
        
        VectorCopy (ent->v.origin, oldorg);
        trace_t steptrace;
        
        VectorCopy (ent->v.origin, oldorg);

-       VectorCopy (vec3_origin, dir);
+       VectorClear (dir);

 
        for (i=0 ; i<8 ; i++)
        {
 
        for (i=0 ; i<8 ; i++)
        {


@@ -944,8 +948,8 @@ int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
 
 // retry the original move
                ent->v.velocity[0] = oldvel[0];
 
 // retry the original move
                ent->v.velocity[0] = oldvel[0];

-               ent->v. velocity[1] = oldvel[1];
-               ent->v. velocity[2] = 0;
+               ent->v.velocity[1] = oldvel[1];
+               ent->v.velocity[2] = 0;

                clip = SV_FlyMove (ent, 0.1, &steptrace);
 
                if ( fabs(oldorg[1] - ent->v.origin[1]) > 4
                clip = SV_FlyMove (ent, 0.1, &steptrace);
 
                if ( fabs(oldorg[1] - ent->v.origin[1]) > 4


@@ -959,7 +963,7 @@ int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
                VectorCopy (oldorg, ent->v.origin);
        }
        
                VectorCopy (oldorg, ent->v.origin);
        }
        

-       VectorCopy (vec3_origin, ent->v.velocity);
+       VectorClear (ent->v.velocity);

        return 7;               // still not moving
 }
 
        return 7;               // still not moving
 }
 


@@ -989,7 +993,7 @@ void SV_WalkMove (edict_t *ent)
        VectorCopy (ent->v.origin, oldorg);
        VectorCopy (ent->v.velocity, oldvel);
        
        VectorCopy (ent->v.origin, oldorg);
        VectorCopy (ent->v.velocity, oldvel);
        

-       clip = SV_FlyMove (ent, host_frametime, &steptrace);
+       clip = SV_FlyMove (ent, sv.frametime, &steptrace);

 
        if ( !(clip & 2) )
                return;         // move didn't block on a step
 
        if ( !(clip & 2) )
                return;         // move didn't block on a step


@@ -1014,10 +1018,10 @@ void SV_WalkMove (edict_t *ent)
 //
        VectorCopy (oldorg, ent->v.origin);     // back to start pos
 
 //
        VectorCopy (oldorg, ent->v.origin);     // back to start pos
 

-       VectorCopy (vec3_origin, upmove);
-       VectorCopy (vec3_origin, downmove);
+       VectorClear (upmove);
+       VectorClear (downmove);

        upmove[2] = STEPSIZE;
        upmove[2] = STEPSIZE;

-       downmove[2] = -STEPSIZE + oldvel[2]*host_frametime;
+       downmove[2] = -STEPSIZE + oldvel[2]*sv.frametime;

 
 // move up
        SV_PushEntity (ent, upmove);    // FIXME: don't link?
 
 // move up
        SV_PushEntity (ent, upmove);    // FIXME: don't link?


@@ -1026,7 +1030,7 @@ void SV_WalkMove (edict_t *ent)
        ent->v.velocity[0] = oldvel[0];
        ent->v. velocity[1] = oldvel[1];
        ent->v. velocity[2] = 0;
        ent->v.velocity[0] = oldvel[0];
        ent->v. velocity[1] = oldvel[1];
        ent->v. velocity[2] = 0;

-       clip = SV_FlyMove (ent, host_frametime, &steptrace);
+       clip = SV_FlyMove (ent, sv.frametime, &steptrace);

 
 // check for stuckness, possibly due to the limited precision of floats
 // in the clipping hulls
 
 // check for stuckness, possibly due to the limited precision of floats
 // in the clipping hulls


@@ -1082,7 +1086,7 @@ void SV_Physics_Client (edict_t   *ent, int num)
 //     
        pr_global_struct->time = sv.time;
        pr_global_struct->self = EDICT_TO_PROG(ent);
 //     
        pr_global_struct->time = sv.time;
        pr_global_struct->self = EDICT_TO_PROG(ent);

-       PR_ExecuteProgram (pr_global_struct->PlayerPreThink);
+       PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");

        
 //
 // do a move
        
 //
 // do a move


@@ -1116,13 +1120,15 @@ void SV_Physics_Client (edict_t *ent, int num)
        case MOVETYPE_FLY:
                if (!SV_RunThink (ent))
                        return;
        case MOVETYPE_FLY:
                if (!SV_RunThink (ent))
                        return;

-               SV_FlyMove (ent, host_frametime, NULL);
+               SV_CheckWater (ent);
+               SV_FlyMove (ent, sv.frametime, NULL);

                break;
                
        case MOVETYPE_NOCLIP:
                if (!SV_RunThink (ent))
                        return;
                break;
                
        case MOVETYPE_NOCLIP:
                if (!SV_RunThink (ent))
                        return;

-               VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
+               SV_CheckWater (ent);
+               VectorMA (ent->v.origin, sv.frametime, ent->v.velocity, ent->v.origin);

                break;
                
        default:
                break;
                
        default:


@@ -1136,7 +1142,7 @@ void SV_Physics_Client (edict_t   *ent, int num)
 
        pr_global_struct->time = sv.time;
        pr_global_struct->self = EDICT_TO_PROG(ent);
 
        pr_global_struct->time = sv.time;
        pr_global_struct->self = EDICT_TO_PROG(ent);

-       PR_ExecuteProgram (pr_global_struct->PlayerPostThink);
+       PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");

 }
 
 //============================================================================
 }
 
 //============================================================================


@@ -1148,11 +1154,14 @@ SV_Physics_None
 Non moving objects can only think
 =============
 */
 Non moving objects can only think
 =============
 */

+// LordHavoc: inlined manually because it was a real time waster
+/*

 void SV_Physics_None (edict_t *ent)
 {
 // regular thinking
        SV_RunThink (ent);
 }
 void SV_Physics_None (edict_t *ent)
 {
 // regular thinking
        SV_RunThink (ent);
 }

+*/

 
 /*
 =============
 
 /*
 =============


@@ -1163,19 +1172,40 @@ Entities that are "stuck" to another entity
 */
 void SV_Physics_Follow (edict_t *ent)
 {
 */
 void SV_Physics_Follow (edict_t *ent)
 {

-       vec3_t vf, vu, vr, angles;
+       vec3_t vf, vr, vu, angles, v;

        edict_t *e;
 // regular thinking
        edict_t *e;
 // regular thinking

-       SV_RunThink (ent);
+       if (!SV_RunThink (ent))
+               return;

        // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
        e = PROG_TO_EDICT(ent->v.aiment);
        // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
        e = PROG_TO_EDICT(ent->v.aiment);

-       angles[0] = -e->v.angles[0];
-       angles[1] = e->v.angles[1];
-       angles[2] = e->v.angles[2];
-       AngleVectors (angles, vf, vr, vu);
-       VectorMA (e->v.origin, ent->v.view_ofs[0], vf, ent->v.origin);
-       VectorMA (ent->v.origin, ent->v.view_ofs[1], vr, ent->v.origin);
-       VectorMA (ent->v.origin, ent->v.view_ofs[2], vu, ent->v.origin);
+       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])
+       {
+               // quick case for no rotation
+               VectorAdd(e->v.origin, ent->v.view_ofs, ent->v.origin);
+       }
+       else
+       {
+               angles[0] = -ent->v.punchangle[0];
+               angles[1] =  ent->v.punchangle[1];
+               angles[2] =  ent->v.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];
+               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->v.origin[0] = ent->v.view_ofs[0] * vf[0] + ent->v.view_ofs[0] * vf[1] + ent->v.view_ofs[0] * vf[2] + e->v.origin[0];
+               ent->v.origin[1] = ent->v.view_ofs[1] * vr[0] + ent->v.view_ofs[1] * vr[1] + ent->v.view_ofs[1] * vr[2] + e->v.origin[1];
+               ent->v.origin[2] = ent->v.view_ofs[2] * vu[0] + ent->v.view_ofs[2] * vu[1] + ent->v.view_ofs[2] * vu[2] + e->v.origin[2];
+               */
+       }

        VectorAdd (e->v.angles, ent->v.v_angle, ent->v.angles);
 //     VectorAdd (PROG_TO_EDICT(ent->v.aiment)->v.origin, ent->v.v_angle, ent->v.origin);
        SV_LinkEdict (ent, true);
        VectorAdd (e->v.angles, ent->v.v_angle, ent->v.angles);
 //     VectorAdd (PROG_TO_EDICT(ent->v.aiment)->v.origin, ent->v.v_angle, ent->v.origin);
        SV_LinkEdict (ent, true);


@@ -1194,8 +1224,8 @@ void SV_Physics_Noclip (edict_t *ent)
        if (!SV_RunThink (ent))
                return;
        
        if (!SV_RunThink (ent))
                return;
        

-       VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles);
-       VectorMA (ent->v.origin, host_frametime, ent->v.velocity, ent->v.origin);
+       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);
 }
 
        SV_LinkEdict (ent, false);
 }


@@ -1274,10 +1304,10 @@ void SV_Physics_Toss (edict_t *ent)
                SV_AddGravity (ent);
 
 // move angles
                SV_AddGravity (ent);
 
 // move angles

-       VectorMA (ent->v.angles, host_frametime, ent->v.avelocity, ent->v.angles);
+       VectorMA (ent->v.angles, sv.frametime, ent->v.avelocity, ent->v.angles);

 
 // move origin
 
 // move origin

-       VectorScale (ent->v.velocity, host_frametime, move);
+       VectorScale (ent->v.velocity, sv.frametime, move);

        trace = SV_PushEntity (ent, move);
        if (trace.fraction == 1)
                return;
        trace = SV_PushEntity (ent, move);
        if (trace.fraction == 1)
                return;


@@ -1300,8 +1330,8 @@ void SV_Physics_Toss (edict_t *ent)
                {
                        ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
                        ent->v.groundentity = EDICT_TO_PROG(trace.ent);
                {
                        ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
                        ent->v.groundentity = EDICT_TO_PROG(trace.ent);

-                       VectorCopy (vec3_origin, ent->v.velocity);
-                       VectorCopy (vec3_origin, ent->v.avelocity);
+                       VectorClear (ent->v.velocity);
+                       VectorClear (ent->v.avelocity);

                }
        }
        
                }
        }
        


@@ -1342,7 +1372,7 @@ void SV_Physics_Step (edict_t *ent)
 
                SV_AddGravity (ent);
                SV_CheckVelocity (ent);
 
                SV_AddGravity (ent);
                SV_CheckVelocity (ent);

-               SV_FlyMove (ent, host_frametime, NULL);
+               SV_FlyMove (ent, sv.frametime, NULL);

                SV_LinkEdict (ent, true);
 
                if ( (int)ent->v.flags & FL_ONGROUND )  // just hit ground
                SV_LinkEdict (ent, true);
 
                if ( (int)ent->v.flags & FL_ONGROUND )  // just hit ground


@@ -1366,7 +1396,6 @@ SV_Physics
 
 ================
 */
 
 ================
 */

-extern dfunction_t *EndFrameQC;

 void SV_Physics (void)
 {
        int             i;
 void SV_Physics (void)
 {
        int             i;


@@ -1376,7 +1405,7 @@ void SV_Physics (void)
        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_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);
+       PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");

 
 //SV_CheckAllEnts ();
 
 
 //SV_CheckAllEnts ();
 


@@ -1404,7 +1433,10 @@ void SV_Physics (void)
                        SV_Physics_Pusher (ent);
                        break;
                case MOVETYPE_NONE:
                        SV_Physics_Pusher (ent);
                        break;
                case MOVETYPE_NONE:

-                       SV_Physics_None (ent);
+//                     SV_Physics_None (ent);
+                       // 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_FOLLOW:
                        SV_Physics_Follow (ent);


@@ -1423,6 +1455,7 @@ void SV_Physics (void)
                                        SV_AddGravity (ent);
                                SV_CheckStuck (ent);
                                SV_WalkMove (ent);
                                        SV_AddGravity (ent);
                                SV_CheckStuck (ent);
                                SV_WalkMove (ent);

+                               SV_LinkEdict (ent, true);

                        }
                        break;
                case MOVETYPE_TOSS:
                        }
                        break;
                case MOVETYPE_TOSS:


@@ -1447,10 +1480,10 @@ void SV_Physics (void)
                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_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));
+               PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");

        }
 
        }
 

-       sv.time += host_frametime;
+       sv.time += sv.frametime;

 }
 
 
 }
 
 


@@ -1461,10 +1494,6 @@ trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore)
        trace_t trace;
        vec3_t  move;
        vec3_t  end;
        trace_t trace;
        vec3_t  move;
        vec3_t  end;

-       double  save_frametime;
-
-       save_frametime = host_frametime;
-       host_frametime = 0.05;

 
        memcpy(&tempent, ent, sizeof(edict_t));
        tent = &tempent;
 
        memcpy(&tempent, ent, sizeof(edict_t));
        tent = &tempent;


@@ -1473,8 +1502,8 @@ trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore)
        {
                SV_CheckVelocity (tent);
                SV_AddGravity (tent);
        {
                SV_CheckVelocity (tent);
                SV_AddGravity (tent);

-               VectorMA (tent->v.angles, host_frametime, tent->v.avelocity, tent->v.angles);
-               VectorScale (tent->v.velocity, host_frametime, move);
+               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);
                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);


@@ -1483,6 +1512,6 @@ trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore)
                        if (trace.ent != ignore)
                                break;
        }
                        if (trace.ent != ignore)
                                break;
        }

-       host_frametime = save_frametime;
+       trace.fraction = 0; // not relevant

        return trace;
 }
        return trace;
 }