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