24513b06c63066f9a6c25315114e23b35aa1d1c2
[divverent/darkplaces.git] / sv_phys.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // sv_phys.c
21
22 #include "quakedef.h"
23
24 /*
25
26
27 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.
28
29 onground is set for toss objects when they come to a complete rest.  it is set for steping or walking objects
30
31 doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
32 bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
33 corpses are SOLID_NOT and MOVETYPE_TOSS
34 crates are SOLID_BBOX and MOVETYPE_TOSS
35 walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP
36 flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY
37
38 solid_edge items only clip against bsp models.
39
40 */
41
42 cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4"};
43 cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100"};
44 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800"};
45 cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000"};
46 cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0"};
47 cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18"};
48 cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1"};
49 cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1"};
50 cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0"};
51 cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0"};
52
53 #define MOVE_EPSILON    0.01
54
55 void SV_Physics_Toss (edict_t *ent);
56
57 void SV_Phys_Init (void)
58 {
59         Cvar_RegisterVariable(&sv_stepheight);
60         Cvar_RegisterVariable(&sv_jumpstep);
61         Cvar_RegisterVariable(&sv_wallfriction);
62         Cvar_RegisterVariable(&sv_newflymove);
63         Cvar_RegisterVariable(&sv_freezenonclients);
64 }
65
66 /*
67 ================
68 SV_CheckAllEnts
69 ================
70 */
71 void SV_CheckAllEnts (void)
72 {
73         int e;
74         edict_t *check;
75
76         // see if any solid entities are inside the final position
77         check = NEXT_EDICT(sv.edicts);
78         for (e = 1;e < sv.num_edicts;e++, check = NEXT_EDICT(check))
79         {
80                 if (check->e->free)
81                         continue;
82                 if (check->v->movetype == MOVETYPE_PUSH
83                  || check->v->movetype == MOVETYPE_NONE
84                  || check->v->movetype == MOVETYPE_FOLLOW
85                  || check->v->movetype == MOVETYPE_NOCLIP)
86                         continue;
87
88                 if (SV_TestEntityPosition (check))
89                         Con_Print("entity in invalid position\n");
90         }
91 }
92
93 /*
94 ================
95 SV_CheckVelocity
96 ================
97 */
98 void SV_CheckVelocity (edict_t *ent)
99 {
100         int i;
101         float wishspeed;
102
103 //
104 // bound velocity
105 //
106         for (i=0 ; i<3 ; i++)
107         {
108                 if (IS_NAN(ent->v->velocity[i]))
109                 {
110                         Con_Printf("Got a NaN velocity on %s\n", PR_GetString(ent->v->classname));
111                         ent->v->velocity[i] = 0;
112                 }
113                 if (IS_NAN(ent->v->origin[i]))
114                 {
115                         Con_Printf("Got a NaN origin on %s\n", PR_GetString(ent->v->classname));
116                         ent->v->origin[i] = 0;
117                 }
118         }
119
120         // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
121         wishspeed = DotProduct(ent->v->velocity, ent->v->velocity);
122         if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
123         {
124                 wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
125                 ent->v->velocity[0] *= wishspeed;
126                 ent->v->velocity[1] *= wishspeed;
127                 ent->v->velocity[2] *= wishspeed;
128         }
129 }
130
131 /*
132 =============
133 SV_RunThink
134
135 Runs thinking code if time.  There is some play in the exact time the think
136 function will be called, because it is called before any movement is done
137 in a frame.  Not used for pushmove objects, because they must be exact.
138 Returns false if the entity removed itself.
139 =============
140 */
141 qboolean SV_RunThink (edict_t *ent)
142 {
143         float thinktime;
144
145         thinktime = ent->v->nextthink;
146         if (thinktime <= 0 || thinktime > sv.time + sv.frametime)
147                 return true;
148
149         // don't let things stay in the past.
150         // it is possible to start that way by a trigger with a local time.
151         if (thinktime < sv.time)
152                 thinktime = sv.time;
153
154         ent->v->nextthink = 0;
155         pr_global_struct->time = thinktime;
156         pr_global_struct->self = EDICT_TO_PROG(ent);
157         pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
158         PR_ExecuteProgram (ent->v->think, "QC function self.think is missing");
159         return !ent->e->free;
160 }
161
162 /*
163 ==================
164 SV_Impact
165
166 Two entities have touched, so run their touch functions
167 ==================
168 */
169 void SV_Impact (edict_t *e1, edict_t *e2)
170 {
171         int old_self, old_other;
172
173         old_self = pr_global_struct->self;
174         old_other = pr_global_struct->other;
175
176         pr_global_struct->time = sv.time;
177         if (e1->v->touch && e1->v->solid != SOLID_NOT)
178         {
179                 pr_global_struct->self = EDICT_TO_PROG(e1);
180                 pr_global_struct->other = EDICT_TO_PROG(e2);
181                 PR_ExecuteProgram (e1->v->touch, "QC function self.touch is missing");
182         }
183
184         if (e2->v->touch && e2->v->solid != SOLID_NOT)
185         {
186                 pr_global_struct->self = EDICT_TO_PROG(e2);
187                 pr_global_struct->other = EDICT_TO_PROG(e1);
188                 PR_ExecuteProgram (e2->v->touch, "QC function self.touch is missing");
189         }
190
191         pr_global_struct->self = old_self;
192         pr_global_struct->other = old_other;
193 }
194
195
196 /*
197 ==================
198 ClipVelocity
199
200 Slide off of the impacting object
201 returns the blocked flags (1 = floor, 2 = step / wall)
202 ==================
203 */
204 #define STOP_EPSILON 0.1
205 void ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
206 {
207         int i;
208         float backoff;
209
210         backoff = -DotProduct (in, normal) * overbounce;
211         VectorMA(in, backoff, normal, out);
212
213         for (i = 0;i < 3;i++)
214                 if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
215                         out[i] = 0;
216 }
217
218
219 /*
220 ============
221 SV_FlyMove
222
223 The basic solid body movement clip that slides along multiple planes
224 Returns the clipflags if the velocity was modified (hit something solid)
225 1 = floor
226 2 = wall / step
227 4 = dead stop
228 If stepnormal is not NULL, the plane normal of any vertical wall hit will be stored
229 ============
230 */
231 // LordHavoc: increased from 5 to 32
232 #define MAX_CLIP_PLANES 32
233 int SV_FlyMove (edict_t *ent, float time, float *stepnormal)
234 {
235         int blocked, bumpcount;
236         int i, j, impact, numplanes;
237         float d, time_left;
238         vec3_t dir, end, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, new_velocity;
239         trace_t trace;
240         blocked = 0;
241         VectorCopy(ent->v->velocity, original_velocity);
242         VectorCopy(ent->v->velocity, primal_velocity);
243         numplanes = 0;
244         time_left = time;
245         for (bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
246         {
247                 if (!ent->v->velocity[0] && !ent->v->velocity[1] && !ent->v->velocity[2])
248                         break;
249
250                 VectorMA(ent->v->origin, time_left, ent->v->velocity, end);
251                 trace = SV_Move(ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
252 #if 0
253                 //if (trace.fraction < 0.002)
254                 {
255 #if 1
256                         vec3_t start;
257                         trace_t testtrace;
258                         VectorCopy(ent->v->origin, start);
259                         start[2] += 3;//0.03125;
260                         VectorMA(ent->v->origin, time_left, ent->v->velocity, end);
261                         end[2] += 3;//0.03125;
262                         testtrace = SV_Move(start, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
263                         if (trace.fraction < testtrace.fraction && !testtrace.startsolid && (testtrace.fraction == 1 || DotProduct(trace.plane.normal, ent->v->velocity) < DotProduct(testtrace.plane.normal, ent->v->velocity)))
264                         {
265                                 Con_Printf("got further (new %f > old %f)\n", testtrace.fraction, trace.fraction);
266                                 trace = testtrace;
267                         }
268 #endif
269 #if 0
270                         //j = -1;
271                         for (i = 0;i < numplanes;i++)
272                         {
273                                 VectorCopy(ent->v->origin, start);
274                                 VectorMA(ent->v->origin, time_left, ent->v->velocity, end);
275                                 VectorMA(start, 3, planes[i], start);
276                                 VectorMA(end, 3, planes[i], end);
277                                 testtrace = SV_Move(start, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
278                                 if (trace.fraction < testtrace.fraction)
279                                 {
280                                         trace = testtrace;
281                                         VectorCopy(start, ent->v->origin);
282                                         //j = i;
283                                 }
284                         }
285                         //if (j >= 0)
286                         //      VectorAdd(ent->v->origin, planes[j], start);
287 #endif
288                 }
289 #endif
290
291 #if 0
292                 Con_Printf("entity %i bump %i: velocity %f %f %f trace %f", ent - sv.edicts, bumpcount, ent->v->velocity[0], ent->v->velocity[1], ent->v->velocity[2], trace.fraction);
293                 if (trace.fraction < 1)
294                         Con_Printf(" : %f %f %f", trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2]);
295                 Con_Print("\n");
296 #endif
297
298                 /*
299                 if (trace.startsolid)
300                 {
301                         // LordHavoc: note: this code is what makes entities stick in place if embedded in another object (which can be the world)
302                         // entity is trapped in another solid
303                         VectorClear(ent->v->velocity);
304                         return 3;
305                 }
306                 */
307
308                 // break if it moved the entire distance
309                 if (trace.fraction == 1)
310                 {
311                         VectorCopy(trace.endpos, ent->v->origin);
312                         break;
313                 }
314
315                 if (!trace.ent)
316                         Host_Error("SV_FlyMove: !trace.ent");
317
318                 if (((int) ent->v->flags & FL_ONGROUND) && ent->v->groundentity == EDICT_TO_PROG(trace.ent))
319                         impact = false;
320                 else
321                 {
322                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
323                         impact = true;
324                 }
325
326                 if (trace.plane.normal[2])
327                 {
328                         if (trace.plane.normal[2] > 0.7)
329                         {
330                                 // floor
331                                 blocked |= 1;
332                                 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
333                                 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
334                         }
335                 }
336                 else
337                 {
338                         // step
339                         blocked |= 2;
340                         // save the trace for player extrafriction
341                         if (stepnormal)
342                                 VectorCopy(trace.plane.normal, stepnormal);
343                 }
344
345                 if (trace.fraction >= 0.001)
346                 {
347                         // actually covered some distance
348                         VectorCopy(trace.endpos, ent->v->origin);
349                         VectorCopy(ent->v->velocity, original_velocity);
350                         numplanes = 0;
351                 }
352
353                 // run the impact function
354                 if (impact)
355                 {
356                         SV_Impact(ent, trace.ent);
357
358                         // break if removed by the impact function
359                         if (ent->e->free)
360                                 break;
361                 }
362
363                 time_left *= 1 - trace.fraction;
364
365                 // clipped to another plane
366                 if (numplanes >= MAX_CLIP_PLANES)
367                 {
368                         // this shouldn't really happen
369                         VectorClear(ent->v->velocity);
370                         blocked = 3;
371                         break;
372                 }
373
374                 /*
375                 for (i = 0;i < numplanes;i++)
376                         if (DotProduct(trace.plane.normal, planes[i]) > 0.99)
377                                 break;
378                 if (i < numplanes)
379                 {
380                         VectorAdd(ent->v->velocity, trace.plane.normal, ent->v->velocity);
381                         continue;
382                 }
383                 */
384
385                 VectorCopy(trace.plane.normal, planes[numplanes]);
386                 numplanes++;
387
388                 if (sv_newflymove.integer)
389                         ClipVelocity(ent->v->velocity, trace.plane.normal, ent->v->velocity, 1);
390                 else
391                 {
392                         // modify original_velocity so it parallels all of the clip planes
393                         for (i = 0;i < numplanes;i++)
394                         {
395                                 ClipVelocity(original_velocity, planes[i], new_velocity, 1);
396                                 for (j = 0;j < numplanes;j++)
397                                 {
398                                         if (j != i)
399                                         {
400                                                 // not ok
401                                                 if (DotProduct(new_velocity, planes[j]) < 0)
402                                                         break;
403                                         }
404                                 }
405                                 if (j == numplanes)
406                                         break;
407                         }
408
409                         if (i != numplanes)
410                         {
411                                 // go along this plane
412                                 VectorCopy(new_velocity, ent->v->velocity);
413                         }
414                         else
415                         {
416                                 // go along the crease
417                                 if (numplanes != 2)
418                                 {
419                                         VectorClear(ent->v->velocity);
420                                         blocked = 7;
421                                         break;
422                                 }
423                                 CrossProduct(planes[0], planes[1], dir);
424                                 // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
425                                 VectorNormalize(dir);
426                                 d = DotProduct(dir, ent->v->velocity);
427                                 VectorScale(dir, d, ent->v->velocity);
428                         }
429                 }
430
431                 // if current velocity is against the original velocity,
432                 // stop dead to avoid tiny occilations in sloping corners
433                 if (DotProduct(ent->v->velocity, primal_velocity) <= 0)
434                 {
435                         VectorClear(ent->v->velocity);
436                         break;
437                 }
438         }
439
440         //Con_Printf("entity %i final: blocked %i velocity %f %f %f\n", ent - sv.edicts, blocked, ent->v->velocity[0], ent->v->velocity[1], ent->v->velocity[2]);
441
442         /*
443         if ((blocked & 1) == 0 && bumpcount > 1)
444         {
445                 // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
446                 // flag ONGROUND if there's ground under it
447                 trace = SV_Move(ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
448         }
449         */
450         return blocked;
451 }
452
453 int SV_SetOnGround (edict_t *ent)
454 {
455         vec3_t end;
456         trace_t trace;
457         if ((int)ent->v->flags & FL_ONGROUND)
458                 return 1;
459         VectorSet(end, ent->v->origin[0], ent->v->origin[1], ent->v->origin[2] - 1);
460         trace = SV_Move(ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
461         if (trace.fraction < 1 && trace.plane.normal[2] >= 0.7)
462         {
463                 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
464                 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
465                 return 1;
466         }
467         return 0;
468 }
469
470 /*
471 ============
472 SV_AddGravity
473
474 ============
475 */
476 void SV_AddGravity (edict_t *ent)
477 {
478         float ent_gravity;
479         eval_t *val;
480
481         val = GETEDICTFIELDVALUE(ent, eval_gravity);
482         if (val!=0 && val->_float)
483                 ent_gravity = val->_float;
484         else
485                 ent_gravity = 1.0;
486         ent->v->velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;
487 }
488
489
490 /*
491 ===============================================================================
492
493 PUSHMOVE
494
495 ===============================================================================
496 */
497
498 /*
499 ============
500 SV_PushEntity
501
502 Does not change the entities velocity at all
503 ============
504 */
505 trace_t SV_PushEntity (edict_t *ent, vec3_t push)
506 {
507         int type;
508         trace_t trace;
509         vec3_t end;
510
511         VectorAdd (ent->v->origin, push, end);
512
513         if (ent->v->movetype == MOVETYPE_FLYMISSILE)
514                 type = MOVE_MISSILE;
515         else if (ent->v->solid == SOLID_TRIGGER || ent->v->solid == SOLID_NOT)
516                 type = MOVE_NOMONSTERS; // only clip against bmodels
517         else
518                 type = MOVE_NORMAL;
519
520         trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, type, ent);
521
522         VectorCopy (trace.endpos, ent->v->origin);
523         SV_LinkEdict (ent, true);
524
525         if (trace.ent && (!((int)ent->v->flags & FL_ONGROUND) || ent->v->groundentity != EDICT_TO_PROG(trace.ent)))
526                 SV_Impact (ent, trace.ent);
527         return trace;
528 }
529
530
531 /*
532 ============
533 SV_PushMove
534
535 ============
536 */
537 trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
538 void SV_PushMove (edict_t *pusher, float movetime)
539 {
540         int i, e, index;
541         edict_t *check, *ed;
542         float savesolid, movetime2, pushltime;
543         vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org, org2;
544         int num_moved;
545         int numcheckentities;
546         static edict_t *checkentities[MAX_EDICTS];
547         model_t *pushermodel;
548         trace_t trace;
549
550         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])
551         {
552                 pusher->v->ltime += movetime;
553                 return;
554         }
555
556         switch ((int) pusher->v->solid)
557         {
558         // LordHavoc: valid pusher types
559         case SOLID_BSP:
560         case SOLID_BBOX:
561         case SOLID_SLIDEBOX:
562         case SOLID_CORPSE: // LordHavoc: this would be weird...
563                 break;
564         // LordHavoc: no collisions
565         case SOLID_NOT:
566         case SOLID_TRIGGER:
567                 VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
568                 VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
569                 pusher->v->angles[0] -= 360.0 * floor(pusher->v->angles[0] * (1.0 / 360.0));
570                 pusher->v->angles[1] -= 360.0 * floor(pusher->v->angles[1] * (1.0 / 360.0));
571                 pusher->v->angles[2] -= 360.0 * floor(pusher->v->angles[2] * (1.0 / 360.0));
572                 pusher->v->ltime += movetime;
573                 SV_LinkEdict (pusher, false);
574                 return;
575         default:
576                 Con_Printf("SV_PushMove: unrecognized solid type %f\n", pusher->v->solid);
577                 return;
578         }
579         index = (int) pusher->v->modelindex;
580         if (index < 1 || index >= MAX_MODELS)
581         {
582                 Con_Printf("SV_PushMove: invalid modelindex %f\n", pusher->v->modelindex);
583                 return;
584         }
585         pushermodel = sv.models[index];
586
587         movetime2 = movetime;
588         VectorScale(pusher->v->velocity, movetime2, move1);
589         VectorScale(pusher->v->avelocity, movetime2, moveangle);
590         if (moveangle[0] || moveangle[2])
591         {
592                 for (i = 0;i < 3;i++)
593                 {
594                         if (move1[i] > 0)
595                         {
596                                 mins[i] = pushermodel->rotatedmins[i] + pusher->v->origin[i] - 1;
597                                 maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
598                         }
599                         else
600                         {
601                                 mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->v->origin[i] - 1;
602                                 maxs[i] = pushermodel->rotatedmaxs[i] + pusher->v->origin[i] + 1;
603                         }
604                 }
605         }
606         else if (moveangle[1])
607         {
608                 for (i = 0;i < 3;i++)
609                 {
610                         if (move1[i] > 0)
611                         {
612                                 mins[i] = pushermodel->yawmins[i] + pusher->v->origin[i] - 1;
613                                 maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
614                         }
615                         else
616                         {
617                                 mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->v->origin[i] - 1;
618                                 maxs[i] = pushermodel->yawmaxs[i] + pusher->v->origin[i] + 1;
619                         }
620                 }
621         }
622         else
623         {
624                 for (i = 0;i < 3;i++)
625                 {
626                         if (move1[i] > 0)
627                         {
628                                 mins[i] = pushermodel->normalmins[i] + pusher->v->origin[i] - 1;
629                                 maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
630                         }
631                         else
632                         {
633                                 mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->v->origin[i] - 1;
634                                 maxs[i] = pushermodel->normalmaxs[i] + pusher->v->origin[i] + 1;
635                         }
636                 }
637         }
638
639         VectorNegate (moveangle, a);
640         AngleVectorsFLU (a, forward, left, up);
641
642         VectorCopy (pusher->v->origin, pushorig);
643         VectorCopy (pusher->v->angles, pushang);
644         pushltime = pusher->v->ltime;
645
646 // move the pusher to it's final position
647
648         VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
649         VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
650         pusher->v->ltime += movetime;
651         SV_LinkEdict (pusher, false);
652
653         savesolid = pusher->v->solid;
654
655 // see if any solid entities are inside the final position
656         num_moved = 0;
657
658         numcheckentities = SV_EntitiesInBox(mins, maxs, MAX_EDICTS, checkentities);
659         for (e = 0;e < numcheckentities;e++)
660         {
661                 check = checkentities[e];
662                 if (check->v->movetype == MOVETYPE_PUSH
663                  || check->v->movetype == MOVETYPE_NONE
664                  || check->v->movetype == MOVETYPE_FOLLOW
665                  || check->v->movetype == MOVETYPE_NOCLIP
666                  || check->v->movetype == MOVETYPE_FAKEPUSH)
667                         continue;
668
669                 // if the entity is standing on the pusher, it will definitely be moved
670                 if (!(((int)check->v->flags & FL_ONGROUND) && PROG_TO_EDICT(check->v->groundentity) == pusher))
671                         if (!SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
672                                 continue;
673
674                 if (forward[0] != 1 || left[1] != 1) // quick way to check if any rotation is used
675                 {
676                         VectorSubtract (check->v->origin, pusher->v->origin, org);
677                         org2[0] = DotProduct (org, forward);
678                         org2[1] = DotProduct (org, left);
679                         org2[2] = DotProduct (org, up);
680                         VectorSubtract (org2, org, move);
681                         VectorAdd (move, move1, move);
682                 }
683                 else
684                         VectorCopy (move1, move);
685
686                 // remove the onground flag for non-players
687                 if (check->v->movetype != MOVETYPE_WALK)
688                         check->v->flags = (int)check->v->flags & ~FL_ONGROUND;
689
690                 VectorCopy (check->v->origin, check->e->moved_from);
691                 VectorCopy (check->v->angles, check->e->moved_fromangles);
692                 sv.moved_edicts[num_moved++] = check;
693
694                 // try moving the contacted entity
695                 pusher->v->solid = SOLID_NOT;
696                 trace = SV_PushEntity (check, move);
697                 // FIXME: turn players specially
698                 check->v->angles[1] += trace.fraction * moveangle[1];
699                 pusher->v->solid = savesolid; // was SOLID_BSP
700
701                 // if it is still inside the pusher, block
702                 if (SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
703                 {
704                         // try moving the contacted entity a tiny bit further to account for precision errors
705                         pusher->v->solid = SOLID_NOT;
706                         VectorScale(move, 0.1, move);
707                         SV_PushEntity (check, move);
708                         pusher->v->solid = savesolid;
709                         if (SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
710                         {
711                                 // still inside pusher, so it's really blocked
712
713                                 // fail the move
714                                 if (check->v->mins[0] == check->v->maxs[0])
715                                         continue;
716                                 if (check->v->solid == SOLID_NOT || check->v->solid == SOLID_TRIGGER)
717                                 {
718                                         // corpse
719                                         check->v->mins[0] = check->v->mins[1] = 0;
720                                         VectorCopy (check->v->mins, check->v->maxs);
721                                         continue;
722                                 }
723
724                                 VectorCopy (pushorig, pusher->v->origin);
725                                 VectorCopy (pushang, pusher->v->angles);
726                                 pusher->v->ltime = pushltime;
727                                 SV_LinkEdict (pusher, false);
728
729                                 // move back any entities we already moved
730                                 for (i = 0;i < num_moved;i++)
731                                 {
732                                         ed = sv.moved_edicts[i];
733                                         VectorCopy (ed->e->moved_from, ed->v->origin);
734                                         VectorCopy (ed->e->moved_fromangles, ed->v->angles);
735                                         SV_LinkEdict (ed, false);
736                                 }
737
738                                 // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
739                                 if (pusher->v->blocked)
740                                 {
741                                         pr_global_struct->self = EDICT_TO_PROG(pusher);
742                                         pr_global_struct->other = EDICT_TO_PROG(check);
743                                         PR_ExecuteProgram (pusher->v->blocked, "QC function self.blocked is missing");
744                                 }
745                                 break;
746                         }
747                 }
748         }
749         pusher->v->angles[0] -= 360.0 * floor(pusher->v->angles[0] * (1.0 / 360.0));
750         pusher->v->angles[1] -= 360.0 * floor(pusher->v->angles[1] * (1.0 / 360.0));
751         pusher->v->angles[2] -= 360.0 * floor(pusher->v->angles[2] * (1.0 / 360.0));
752 }
753
754 /*
755 ================
756 SV_Physics_Pusher
757
758 ================
759 */
760 void SV_Physics_Pusher (edict_t *ent)
761 {
762         float thinktime, oldltime, movetime;
763
764         oldltime = ent->v->ltime;
765
766         thinktime = ent->v->nextthink;
767         if (thinktime < ent->v->ltime + sv.frametime)
768         {
769                 movetime = thinktime - ent->v->ltime;
770                 if (movetime < 0)
771                         movetime = 0;
772         }
773         else
774                 movetime = sv.frametime;
775
776         if (movetime)
777                 // advances ent->v->ltime if not blocked
778                 SV_PushMove (ent, movetime);
779
780         if (thinktime > oldltime && thinktime <= ent->v->ltime)
781         {
782                 ent->v->nextthink = 0;
783                 pr_global_struct->time = sv.time;
784                 pr_global_struct->self = EDICT_TO_PROG(ent);
785                 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
786                 PR_ExecuteProgram (ent->v->think, "QC function self.think is missing");
787         }
788 }
789
790
791 /*
792 ===============================================================================
793
794 CLIENT MOVEMENT
795
796 ===============================================================================
797 */
798
799 /*
800 =============
801 SV_CheckStuck
802
803 This is a big hack to try and fix the rare case of getting stuck in the world
804 clipping hull.
805 =============
806 */
807 void SV_CheckStuck (edict_t *ent)
808 {
809         int i, j, z;
810         vec3_t org;
811
812         if (!SV_TestEntityPosition(ent))
813         {
814                 VectorCopy (ent->v->origin, ent->v->oldorigin);
815                 return;
816         }
817
818         VectorCopy (ent->v->origin, org);
819         VectorCopy (ent->v->oldorigin, ent->v->origin);
820         if (!SV_TestEntityPosition(ent))
821         {
822                 Con_DPrint("Unstuck.\n");
823                 SV_LinkEdict (ent, true);
824                 return;
825         }
826
827         for (z=0 ; z< 18 ; z++)
828                 for (i=-1 ; i <= 1 ; i++)
829                         for (j=-1 ; j <= 1 ; j++)
830                         {
831                                 ent->v->origin[0] = org[0] + i;
832                                 ent->v->origin[1] = org[1] + j;
833                                 ent->v->origin[2] = org[2] + z;
834                                 if (!SV_TestEntityPosition(ent))
835                                 {
836                                         Con_DPrint("Unstuck.\n");
837                                         SV_LinkEdict (ent, true);
838                                         return;
839                                 }
840                         }
841
842         VectorCopy (org, ent->v->origin);
843         Con_DPrint("player is stuck.\n");
844 }
845
846
847 /*
848 =============
849 SV_CheckWater
850 =============
851 */
852 qboolean SV_CheckWater (edict_t *ent)
853 {
854         int cont;
855         vec3_t point;
856
857         point[0] = ent->v->origin[0];
858         point[1] = ent->v->origin[1];
859         point[2] = ent->v->origin[2] + ent->v->mins[2] + 1;
860
861         ent->v->waterlevel = 0;
862         ent->v->watertype = CONTENTS_EMPTY;
863         cont = SV_PointSuperContents(point);
864         if (cont & (SUPERCONTENTS_LIQUIDSMASK))
865         {
866                 ent->v->watertype = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, cont);
867                 ent->v->waterlevel = 1;
868                 point[2] = ent->v->origin[2] + (ent->v->mins[2] + ent->v->maxs[2])*0.5;
869                 if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
870                 {
871                         ent->v->waterlevel = 2;
872                         point[2] = ent->v->origin[2] + ent->v->view_ofs[2];
873                         if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
874                                 ent->v->waterlevel = 3;
875                 }
876         }
877
878         return ent->v->waterlevel > 1;
879 }
880
881 /*
882 ============
883 SV_WallFriction
884
885 ============
886 */
887 void SV_WallFriction (edict_t *ent, float *stepnormal)
888 {
889         float d, i;
890         vec3_t forward, into, side;
891
892         AngleVectors (ent->v->v_angle, forward, NULL, NULL);
893         if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
894         {
895                 // cut the tangential velocity
896                 i = DotProduct (stepnormal, ent->v->velocity);
897                 VectorScale (stepnormal, i, into);
898                 VectorSubtract (ent->v->velocity, into, side);
899                 ent->v->velocity[0] = side[0] * (1 + d);
900                 ent->v->velocity[1] = side[1] * (1 + d);
901         }
902 }
903
904 /*
905 =====================
906 SV_TryUnstick
907
908 Player has come to a dead stop, possibly due to the problem with limited
909 float precision at some angle joins in the BSP hull.
910
911 Try fixing by pushing one pixel in each direction.
912
913 This is a hack, but in the interest of good gameplay...
914 ======================
915 */
916 int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
917 {
918         int i, clip;
919         vec3_t oldorg, dir;
920
921         VectorCopy (ent->v->origin, oldorg);
922         VectorClear (dir);
923
924         for (i=0 ; i<8 ; i++)
925         {
926                 // try pushing a little in an axial direction
927                 switch (i)
928                 {
929                         case 0: dir[0] = 2; dir[1] = 0; break;
930                         case 1: dir[0] = 0; dir[1] = 2; break;
931                         case 2: dir[0] = -2; dir[1] = 0; break;
932                         case 3: dir[0] = 0; dir[1] = -2; break;
933                         case 4: dir[0] = 2; dir[1] = 2; break;
934                         case 5: dir[0] = -2; dir[1] = 2; break;
935                         case 6: dir[0] = 2; dir[1] = -2; break;
936                         case 7: dir[0] = -2; dir[1] = -2; break;
937                 }
938
939                 SV_PushEntity (ent, dir);
940
941                 // retry the original move
942                 ent->v->velocity[0] = oldvel[0];
943                 ent->v->velocity[1] = oldvel[1];
944                 ent->v->velocity[2] = 0;
945                 clip = SV_FlyMove (ent, 0.1, NULL);
946
947                 if (fabs(oldorg[1] - ent->v->origin[1]) > 4
948                  || fabs(oldorg[0] - ent->v->origin[0]) > 4)
949                 {
950                         Con_DPrint("TryUnstick - success.\n");
951                         return clip;
952                 }
953
954                 // go back to the original pos and try again
955                 VectorCopy (oldorg, ent->v->origin);
956         }
957
958         // still not moving
959         VectorClear (ent->v->velocity);
960         Con_DPrint("TryUnstick - failure.\n");
961         return 7;
962 }
963
964 /*
965 =====================
966 SV_WalkMove
967
968 Only used by players
969 ======================
970 */
971 void SV_WalkMove (edict_t *ent)
972 {
973         int clip, oldonground, originalmove_clip, originalmove_flags, originalmove_groundentity;
974         vec3_t upmove, downmove, start_origin, start_velocity, stepnormal, originalmove_origin, originalmove_velocity;
975         trace_t downtrace;
976
977         SV_CheckVelocity(ent);
978
979         // do a regular slide move unless it looks like you ran into a step
980         oldonground = (int)ent->v->flags & FL_ONGROUND;
981         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
982
983         VectorCopy (ent->v->origin, start_origin);
984         VectorCopy (ent->v->velocity, start_velocity);
985
986         clip = SV_FlyMove (ent, sv.frametime, NULL);
987
988         SV_SetOnGround (ent);
989         SV_CheckVelocity(ent);
990
991         VectorCopy(ent->v->origin, originalmove_origin);
992         VectorCopy(ent->v->velocity, originalmove_velocity);
993         originalmove_clip = clip;
994         originalmove_flags = (int)ent->v->flags;
995         originalmove_groundentity = ent->v->groundentity;
996
997         if ((int)ent->v->flags & FL_WATERJUMP)
998                 return;
999
1000         if (sv_nostep.integer)
1001                 return;
1002
1003         // if move didn't block on a step, return
1004         if (clip & 2)
1005         {
1006                 // if move was not trying to move into the step, return
1007                 if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
1008                         return;
1009
1010                 if (ent->v->movetype != MOVETYPE_FLY)
1011                 {
1012                         // return if gibbed by a trigger
1013                         if (ent->v->movetype != MOVETYPE_WALK)
1014                                 return;
1015
1016                         // only step up while jumping if that is enabled
1017                         if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))
1018                                 if (!oldonground && ent->v->waterlevel == 0)
1019                                         return;
1020                 }
1021
1022                 // try moving up and forward to go up a step
1023                 // back to start pos
1024                 VectorCopy (start_origin, ent->v->origin);
1025                 VectorCopy (start_velocity, ent->v->velocity);
1026
1027                 // move up
1028                 VectorClear (upmove);
1029                 upmove[2] = sv_stepheight.value;
1030                 // FIXME: don't link?
1031                 SV_PushEntity(ent, upmove);
1032
1033                 // move forward
1034                 ent->v->velocity[2] = 0;
1035                 clip = SV_FlyMove (ent, sv.frametime, stepnormal);
1036                 ent->v->velocity[2] += start_velocity[2];
1037
1038                 SV_CheckVelocity(ent);
1039
1040                 // check for stuckness, possibly due to the limited precision of floats
1041                 // in the clipping hulls
1042                 if (clip
1043                  && fabs(originalmove_origin[1] - ent->v->origin[1]) < 0.03125
1044                  && fabs(originalmove_origin[0] - ent->v->origin[0]) < 0.03125)
1045                 {
1046                         //Con_Printf("wall\n");
1047                         // stepping up didn't make any progress, revert to original move
1048                         VectorCopy(originalmove_origin, ent->v->origin);
1049                         VectorCopy(originalmove_velocity, ent->v->velocity);
1050                         //clip = originalmove_clip;
1051                         ent->v->flags = originalmove_flags;
1052                         ent->v->groundentity = originalmove_groundentity;
1053                         // now try to unstick if needed
1054                         //clip = SV_TryUnstick (ent, oldvel);
1055                         return;
1056                 }
1057
1058                 //Con_Printf("step - ");
1059
1060                 // extra friction based on view angle
1061                 if (clip & 2 && sv_wallfriction.integer)
1062                         SV_WallFriction (ent, stepnormal);
1063         }
1064         // skip out if stepdown is enabled, moving downward, not in water, and the move started onground and ended offground
1065         else if (!(sv_gameplayfix_stepdown.integer && ent->v->waterlevel < 2 && start_velocity[2] < (1.0 / 32.0) && oldonground && !((int)ent->v->flags & FL_ONGROUND)))
1066                 return;
1067
1068         // move down
1069         VectorClear (downmove);
1070         downmove[2] = -sv_stepheight.value + start_velocity[2]*sv.frametime;
1071         // FIXME: don't link?
1072         downtrace = SV_PushEntity (ent, downmove);
1073
1074         if (downtrace.fraction < 1 && downtrace.plane.normal[2] > 0.7)
1075         {
1076                 // LordHavoc: disabled this check so you can walk on monsters/players
1077                 //if (ent->v->solid == SOLID_BSP)
1078                 {
1079                         //Con_Printf("onground\n");
1080                         ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1081                         ent->v->groundentity = EDICT_TO_PROG(downtrace.ent);
1082                 }
1083         }
1084         else
1085         {
1086                 //Con_Printf("slope\n");
1087                 // if the push down didn't end up on good ground, use the move without
1088                 // the step up.  This happens near wall / slope combinations, and can
1089                 // cause the player to hop up higher on a slope too steep to climb
1090                 VectorCopy(originalmove_origin, ent->v->origin);
1091                 VectorCopy(originalmove_velocity, ent->v->velocity);
1092                 //clip = originalmove_clip;
1093                 ent->v->flags = originalmove_flags;
1094                 ent->v->groundentity = originalmove_groundentity;
1095         }
1096
1097         SV_SetOnGround (ent);
1098         SV_CheckVelocity(ent);
1099 }
1100
1101 //============================================================================
1102
1103 /*
1104 =============
1105 SV_Physics_Follow
1106
1107 Entities that are "stuck" to another entity
1108 =============
1109 */
1110 void SV_Physics_Follow (edict_t *ent)
1111 {
1112         vec3_t vf, vr, vu, angles, v;
1113         edict_t *e;
1114
1115         // regular thinking
1116         if (!SV_RunThink (ent))
1117                 return;
1118
1119         // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1120         e = PROG_TO_EDICT(ent->v->aiment);
1121         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])
1122         {
1123                 // quick case for no rotation
1124                 VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
1125         }
1126         else
1127         {
1128                 angles[0] = -ent->v->punchangle[0];
1129                 angles[1] =  ent->v->punchangle[1];
1130                 angles[2] =  ent->v->punchangle[2];
1131                 AngleVectors (angles, vf, vr, vu);
1132                 v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
1133                 v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
1134                 v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
1135                 angles[0] = -e->v->angles[0];
1136                 angles[1] =  e->v->angles[1];
1137                 angles[2] =  e->v->angles[2];
1138                 AngleVectors (angles, vf, vr, vu);
1139                 ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
1140                 ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
1141                 ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
1142         }
1143         VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
1144         SV_LinkEdict (ent, true);
1145 }
1146
1147 /*
1148 ==============================================================================
1149
1150 TOSS / BOUNCE
1151
1152 ==============================================================================
1153 */
1154
1155 /*
1156 =============
1157 SV_CheckWaterTransition
1158
1159 =============
1160 */
1161 void SV_CheckWaterTransition (edict_t *ent)
1162 {
1163         int cont;
1164         cont = SV_PointQ1Contents(ent->v->origin);
1165         if (!ent->v->watertype)
1166         {
1167                 // just spawned here
1168                 ent->v->watertype = cont;
1169                 ent->v->waterlevel = 1;
1170                 return;
1171         }
1172
1173         // check if the entity crossed into or out of water
1174         if ((ent->v->watertype == CONTENTS_WATER || ent->v->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME))
1175                 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1176
1177         if (cont <= CONTENTS_WATER)
1178         {
1179                 ent->v->watertype = cont;
1180                 ent->v->waterlevel = 1;
1181         }
1182         else
1183         {
1184                 ent->v->watertype = CONTENTS_EMPTY;
1185                 ent->v->waterlevel = 0;
1186         }
1187 }
1188
1189 /*
1190 =============
1191 SV_Physics_Toss
1192
1193 Toss, bounce, and fly movement.  When onground, do nothing.
1194 =============
1195 */
1196 void SV_Physics_Toss (edict_t *ent)
1197 {
1198         trace_t trace;
1199         vec3_t move;
1200
1201         // don't stick to ground if onground and moving upward
1202         if (ent->v->velocity[2] >= (1.0 / 32.0) && ((int)ent->v->flags & FL_ONGROUND))
1203                 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1204
1205 // if onground, return without moving
1206         if ((int)ent->v->flags & FL_ONGROUND)
1207         {
1208                 if (ent->v->groundentity == 0 || sv_gameplayfix_noairborncorpse.integer)
1209                         return;
1210                 // if ent was supported by a brush model on previous frame,
1211                 // and groundentity is now freed, set groundentity to 0 (floating)
1212                 if (ent->e->suspendedinairflag && PROG_TO_EDICT(ent->v->groundentity)->e->free)
1213                 {
1214                         // leave it suspended in the air
1215                         ent->v->groundentity = 0;
1216                         return;
1217                 }
1218         }
1219         ent->e->suspendedinairflag = false;
1220
1221         SV_CheckVelocity (ent);
1222
1223 // add gravity
1224         if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
1225                 SV_AddGravity (ent);
1226
1227 // move angles
1228         VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1229
1230 // move origin
1231         VectorScale (ent->v->velocity, sv.frametime, move);
1232         trace = SV_PushEntity (ent, move);
1233         if (ent->e->free)
1234                 return;
1235
1236         if (trace.fraction < 1)
1237         {
1238                 if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
1239                 {
1240                         ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
1241                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1242                 }
1243                 else if (ent->v->movetype == MOVETYPE_BOUNCE)
1244                 {
1245                         float d;
1246                         ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
1247                         // LordHavoc: fixed grenades not bouncing when fired down a slope
1248                         if (sv_gameplayfix_grenadebouncedownslopes.integer)
1249                         {
1250                                 d = DotProduct(trace.plane.normal, ent->v->velocity);
1251                                 if (trace.plane.normal[2] > 0.7 && fabs(d) < 60)
1252                                 {
1253                                         ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1254                                         ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1255                                         VectorClear (ent->v->velocity);
1256                                         VectorClear (ent->v->avelocity);
1257                                 }
1258                                 else
1259                                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1260                         }
1261                         else
1262                         {
1263                                 if (trace.plane.normal[2] > 0.7 && ent->v->velocity[2] < 60)
1264                                 {
1265                                         ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1266                                         ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1267                                         VectorClear (ent->v->velocity);
1268                                         VectorClear (ent->v->avelocity);
1269                                 }
1270                                 else
1271                                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1272                         }
1273                 }
1274                 else
1275                 {
1276                         ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
1277                         if (trace.plane.normal[2] > 0.7)
1278                         {
1279                                 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1280                                 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1281                                 if (((edict_t *)trace.ent)->v->solid == SOLID_BSP)
1282                                         ent->e->suspendedinairflag = true;
1283                                 VectorClear (ent->v->velocity);
1284                                 VectorClear (ent->v->avelocity);
1285                         }
1286                         else
1287                                 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1288                 }
1289         }
1290
1291 // check for in water
1292         SV_CheckWaterTransition (ent);
1293 }
1294
1295 /*
1296 ===============================================================================
1297
1298 STEPPING MOVEMENT
1299
1300 ===============================================================================
1301 */
1302
1303 /*
1304 =============
1305 SV_Physics_Step
1306
1307 Monsters freefall when they don't have a ground entity, otherwise
1308 all movement is done with discrete steps.
1309
1310 This is also used for objects that have become still on the ground, but
1311 will fall if the floor is pulled out from under them.
1312 =============
1313 */
1314 void SV_Physics_Step (edict_t *ent)
1315 {
1316         // don't stick to ground if onground and moving upward
1317         if (ent->v->velocity[2] >= (1.0 / 32.0) && ((int)ent->v->flags & FL_ONGROUND))
1318                 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1319
1320         // freefall if not onground/fly/swim
1321         if (!((int)ent->v->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
1322         {
1323                 int hitsound = ent->v->velocity[2] < sv_gravity.value * -0.1;
1324
1325                 SV_AddGravity(ent);
1326                 SV_CheckVelocity(ent);
1327                 SV_FlyMove(ent, sv.frametime, NULL);
1328                 SV_LinkEdict(ent, true);
1329
1330                 // just hit ground
1331                 if (hitsound && (int)ent->v->flags & FL_ONGROUND && gamemode != GAME_NEXUIZ)
1332                         SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
1333         }
1334
1335 // regular thinking
1336         SV_RunThink(ent);
1337
1338         SV_CheckWaterTransition(ent);
1339 }
1340
1341 //============================================================================
1342
1343 /*
1344 ================
1345 SV_Physics
1346
1347 ================
1348 */
1349 void SV_Physics (void)
1350 {
1351         int i, newnum_edicts;
1352         edict_t *ent;
1353         qbyte runmove[MAX_EDICTS];
1354
1355 // let the progs know that a new frame has started
1356         pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1357         pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1358         pr_global_struct->time = sv.time;
1359         PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
1360
1361         newnum_edicts = 0;
1362         for (i = 0, ent = sv.edicts;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
1363                 if ((runmove[i] = !ent->e->free))
1364                         newnum_edicts = i + 1;
1365         sv.num_edicts = max(svs.maxclients + 1, newnum_edicts);
1366
1367 //
1368 // treat each object in turn
1369 //
1370
1371         for (i = 0, ent = sv.edicts;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
1372         {
1373                 if (ent->e->free)
1374                         continue;
1375
1376                 if (pr_global_struct->force_retouch)
1377                         SV_LinkEdict (ent, true);       // force retouch even for stationary
1378
1379                 if (i >= 1 && i <= svs.maxclients)
1380                 {
1381                         host_client = svs.clients + i - 1;
1382                         // don't do physics on disconnected clients, FrikBot relies on this
1383                         if (!host_client->spawned)
1384                         {
1385                                 memset(&host_client->cmd, 0, sizeof(host_client->cmd));
1386                                 continue;
1387                         }
1388                         // connected slot
1389                         // apply the latest accepted move to the entity fields
1390                         SV_ApplyClientMove();
1391                         // make sure the velocity is sane (not a NaN)
1392                         SV_CheckVelocity(ent);
1393                         // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
1394                         if (SV_PlayerPhysicsQC)
1395                         {
1396                                 pr_global_struct->time = sv.time;
1397                                 pr_global_struct->self = EDICT_TO_PROG(ent);
1398                                 PR_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - pr_functions), "QC function SV_PlayerPhysics is missing");
1399                         }
1400                         else
1401                                 SV_ClientThink ();
1402                         // make sure the velocity is sane (not a NaN)
1403                         SV_CheckVelocity(ent);
1404                         // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
1405                         // player_run/player_stand1 does not horribly malfunction if the
1406                         // velocity becomes a number that is both == 0 and != 0
1407                         // (sounds to me like NaN but to be absolutely safe...)
1408                         if (DotProduct(ent->v->velocity, ent->v->velocity) < 0.0001)
1409                                 VectorClear(ent->v->velocity);
1410                         // call standard client pre-think
1411                         pr_global_struct->time = sv.time;
1412                         pr_global_struct->self = EDICT_TO_PROG(ent);
1413                         PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
1414                         SV_CheckVelocity (ent);
1415                 }
1416                 else if (sv_freezenonclients.integer)
1417                         continue;
1418
1419                 // LordHavoc: merged client and normal entity physics
1420                 switch ((int) ent->v->movetype)
1421                 {
1422                 case MOVETYPE_PUSH:
1423                 case MOVETYPE_FAKEPUSH:
1424                         SV_Physics_Pusher (ent);
1425                         break;
1426                 case MOVETYPE_NONE:
1427                         // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1428                         if (ent->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
1429                                 SV_RunThink (ent);
1430                         break;
1431                 case MOVETYPE_FOLLOW:
1432                         SV_Physics_Follow (ent);
1433                         break;
1434                 case MOVETYPE_NOCLIP:
1435                         if (SV_RunThink(ent))
1436                         {
1437                                 SV_CheckWater(ent);
1438                                 VectorMA(ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1439                                 VectorMA(ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1440                         }
1441                         // relink normal entities here, players always get relinked so don't relink twice
1442                         if (!(i > 0 && i <= svs.maxclients))
1443                                 SV_LinkEdict(ent, false);
1444                         break;
1445                 case MOVETYPE_STEP:
1446                         SV_Physics_Step (ent);
1447                         break;
1448                 case MOVETYPE_WALK:
1449                         if (SV_RunThink (ent))
1450                         {
1451                                 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1452                                         SV_AddGravity (ent);
1453                                 SV_CheckStuck (ent);
1454                                 SV_WalkMove (ent);
1455                                 // relink normal entities here, players always get relinked so don't relink twice
1456                                 if (!(i > 0 && i <= svs.maxclients))
1457                                         SV_LinkEdict (ent, true);
1458                         }
1459                         break;
1460                 case MOVETYPE_TOSS:
1461                 case MOVETYPE_BOUNCE:
1462                 case MOVETYPE_BOUNCEMISSILE:
1463                 case MOVETYPE_FLYMISSILE:
1464                         // regular thinking
1465                         if (SV_RunThink (ent) && runmove[i])
1466                                 SV_Physics_Toss (ent);
1467                         break;
1468                 case MOVETYPE_FLY:
1469                         if (SV_RunThink (ent) && runmove[i])
1470                         {
1471                                 if (i > 0 && i <= svs.maxclients)
1472                                 {
1473                                         SV_CheckWater (ent);
1474                                         SV_WalkMove (ent);
1475                                 }
1476                                 else
1477                                         SV_Physics_Toss (ent);
1478                         }
1479                         break;
1480                 default:
1481                         Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
1482                         break;
1483                 }
1484
1485                 if (i >= 1 && i <= svs.maxclients)
1486                 {
1487                         SV_CheckVelocity (ent);
1488
1489                         // call standard player post-think
1490                         SV_LinkEdict (ent, true);
1491
1492                         SV_CheckVelocity (ent);
1493
1494                         pr_global_struct->time = sv.time;
1495                         pr_global_struct->self = EDICT_TO_PROG(ent);
1496                         PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
1497                 }
1498         }
1499
1500         if (pr_global_struct->force_retouch > 0)
1501                 pr_global_struct->force_retouch = max(0, pr_global_struct->force_retouch - 1);
1502
1503         // LordHavoc: endframe support
1504         if (EndFrameQC)
1505         {
1506                 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1507                 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1508                 pr_global_struct->time = sv.time;
1509                 PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "QC function EndFrame is missing");
1510         }
1511
1512         if (!sv_freezenonclients.integer)
1513                 sv.time += sv.frametime;
1514 }
1515
1516
1517 trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
1518 {
1519         int i;
1520         float gravity, savesolid;
1521         vec3_t move, end;
1522         edict_t tempent, *tent;
1523         entvars_t vars;
1524         eval_t *val;
1525         trace_t trace;
1526
1527         // copy the vars over
1528         memcpy(&vars, tossent->v, sizeof(entvars_t));
1529         // set up the temp entity to point to the copied vars
1530         tent = &tempent;
1531         tent->v = &vars;
1532
1533         savesolid = tossent->v->solid;
1534         tossent->v->solid = SOLID_NOT;
1535
1536         // this has to fetch the field from the original edict, since our copy is truncated
1537         val = GETEDICTFIELDVALUE(tossent, eval_gravity);
1538         if (val != NULL && val->_float != 0)
1539                 gravity = val->_float;
1540         else
1541                 gravity = 1.0;
1542         gravity *= sv_gravity.value * 0.05;
1543
1544         for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1545         {
1546                 SV_CheckVelocity (tent);
1547                 tent->v->velocity[2] -= gravity;
1548                 VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
1549                 VectorScale (tent->v->velocity, 0.05, move);
1550                 VectorAdd (tent->v->origin, move, end);
1551                 trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
1552                 VectorCopy (trace.endpos, tent->v->origin);
1553
1554                 if (trace.fraction < 1 && trace.ent && trace.ent != ignore)
1555                         break;
1556         }
1557         tossent->v->solid = savesolid;
1558         trace.fraction = 0; // not relevant
1559         return trace;
1560 }
1561