apparently M_ToggleMenu_f is not what to call... Call_MR_ToggleMenu_f is
[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, "NULL think function");
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, "");
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, "");
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         model_t *pushermodel;
567         trace_t trace;
568
569         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])
570         {
571                 pusher->v->ltime += movetime;
572                 return;
573         }
574
575         switch ((int) pusher->v->solid)
576         {
577         // LordHavoc: valid pusher types
578         case SOLID_BSP:
579         case SOLID_BBOX:
580         case SOLID_SLIDEBOX:
581         case SOLID_CORPSE: // LordHavoc: this would be weird...
582                 break;
583         // LordHavoc: no collisions
584         case SOLID_NOT:
585         case SOLID_TRIGGER:
586                 VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
587                 VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
588                 pusher->v->angles[0] -= 360.0 * floor(pusher->v->angles[0] * (1.0 / 360.0));
589                 pusher->v->angles[1] -= 360.0 * floor(pusher->v->angles[1] * (1.0 / 360.0));
590                 pusher->v->angles[2] -= 360.0 * floor(pusher->v->angles[2] * (1.0 / 360.0));
591                 pusher->v->ltime += movetime;
592                 SV_LinkEdict (pusher, false);
593                 return;
594         default:
595                 Con_DPrintf("SV_PushMove: unrecognized solid type %f\n", pusher->v->solid);
596                 return;
597         }
598         index = (int) pusher->v->modelindex;
599         if (index < 1 || index >= MAX_MODELS)
600         {
601                 Con_DPrintf("SV_PushMove: invalid modelindex %f\n", pusher->v->modelindex);
602                 return;
603         }
604         pushermodel = sv.models[index];
605
606         movetime2 = movetime;
607         VectorScale(pusher->v->velocity, movetime2, move1);
608         VectorScale(pusher->v->avelocity, movetime2, moveangle);
609         if (moveangle[0] || moveangle[2])
610         {
611                 for (i = 0;i < 3;i++)
612                 {
613                         if (move1[i] > 0)
614                         {
615                                 mins[i] = pushermodel->rotatedmins[i] + pusher->v->origin[i] - 1;
616                                 maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
617                         }
618                         else
619                         {
620                                 mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->v->origin[i] - 1;
621                                 maxs[i] = pushermodel->rotatedmaxs[i] + pusher->v->origin[i] + 1;
622                         }
623                 }
624         }
625         else if (moveangle[1])
626         {
627                 for (i = 0;i < 3;i++)
628                 {
629                         if (move1[i] > 0)
630                         {
631                                 mins[i] = pushermodel->yawmins[i] + pusher->v->origin[i] - 1;
632                                 maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
633                         }
634                         else
635                         {
636                                 mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->v->origin[i] - 1;
637                                 maxs[i] = pushermodel->yawmaxs[i] + pusher->v->origin[i] + 1;
638                         }
639                 }
640         }
641         else
642         {
643                 for (i = 0;i < 3;i++)
644                 {
645                         if (move1[i] > 0)
646                         {
647                                 mins[i] = pushermodel->normalmins[i] + pusher->v->origin[i] - 1;
648                                 maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->v->origin[i] + 1;
649                         }
650                         else
651                         {
652                                 mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->v->origin[i] - 1;
653                                 maxs[i] = pushermodel->normalmaxs[i] + pusher->v->origin[i] + 1;
654                         }
655                 }
656         }
657
658         VectorNegate (moveangle, a);
659         AngleVectorsFLU (a, forward, left, up);
660
661         VectorCopy (pusher->v->origin, pushorig);
662         VectorCopy (pusher->v->angles, pushang);
663         pushltime = pusher->v->ltime;
664
665 // move the pusher to it's final position
666
667         VectorMA (pusher->v->origin, movetime, pusher->v->velocity, pusher->v->origin);
668         VectorMA (pusher->v->angles, movetime, pusher->v->avelocity, pusher->v->angles);
669         pusher->v->ltime += movetime;
670         SV_LinkEdict (pusher, false);
671
672         savesolid = pusher->v->solid;
673
674 // see if any solid entities are inside the final position
675         num_moved = 0;
676         check = NEXT_EDICT(sv.edicts);
677         for (e = 1;e < sv.num_edicts;e++, check = NEXT_EDICT(check))
678         {
679                 if (check->e->free)
680                         continue;
681                 if (check->v->movetype == MOVETYPE_PUSH
682                  || check->v->movetype == MOVETYPE_NONE
683                  || check->v->movetype == MOVETYPE_FOLLOW
684                  || check->v->movetype == MOVETYPE_NOCLIP
685                  || check->v->movetype == MOVETYPE_FAKEPUSH)
686                         continue;
687
688                 // if the entity is standing on the pusher, it will definitely be moved
689                 if (!(((int)check->v->flags & FL_ONGROUND) && PROG_TO_EDICT(check->v->groundentity) == pusher))
690                 {
691                         if (check->v->absmin[0] >= maxs[0]
692                          || check->v->absmax[0] <= mins[0]
693                          || check->v->absmin[1] >= maxs[1]
694                          || check->v->absmax[1] <= mins[1]
695                          || check->v->absmin[2] >= maxs[2]
696                          || check->v->absmax[2] <= mins[2])
697                                 continue;
698
699                         if (!SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
700                                 continue;
701                 }
702
703                 if (forward[0] != 1) // quick way to check if any rotation is used
704                 {
705                         VectorSubtract (check->v->origin, pusher->v->origin, org);
706                         org2[0] = DotProduct (org, forward);
707                         org2[1] = DotProduct (org, left);
708                         org2[2] = DotProduct (org, up);
709                         VectorSubtract (org2, org, move);
710                         VectorAdd (move, move1, move);
711                 }
712                 else
713                         VectorCopy (move1, move);
714
715                 // remove the onground flag for non-players
716                 if (check->v->movetype != MOVETYPE_WALK)
717                         check->v->flags = (int)check->v->flags & ~FL_ONGROUND;
718
719                 VectorCopy (check->v->origin, check->e->moved_from);
720                 VectorCopy (check->v->angles, check->e->moved_fromangles);
721                 sv.moved_edicts[num_moved++] = check;
722
723                 // try moving the contacted entity
724                 pusher->v->solid = SOLID_NOT;
725                 trace = SV_PushEntity (check, move);
726                 // FIXME: turn players specially
727                 check->v->angles[1] += trace.fraction * moveangle[1];
728                 pusher->v->solid = savesolid; // was SOLID_BSP
729
730                 // if it is still inside the pusher, block
731                 if (SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
732                 {
733                         // try moving the contacted entity a tiny bit further to account for precision errors
734                         pusher->v->solid = SOLID_NOT;
735                         VectorScale(move, 0.1, move);
736                         SV_PushEntity (check, move);
737                         pusher->v->solid = savesolid;
738                         if (SV_ClipMoveToEntity(pusher, check->v->origin, check->v->mins, check->v->maxs, check->v->origin).startsolid)
739                         {
740                                 // still inside pusher, so it's really blocked
741
742                                 // fail the move
743                                 if (check->v->mins[0] == check->v->maxs[0])
744                                         continue;
745                                 if (check->v->solid == SOLID_NOT || check->v->solid == SOLID_TRIGGER)
746                                 {
747                                         // corpse
748                                         check->v->mins[0] = check->v->mins[1] = 0;
749                                         VectorCopy (check->v->mins, check->v->maxs);
750                                         continue;
751                                 }
752
753                                 VectorCopy (pushorig, pusher->v->origin);
754                                 VectorCopy (pushang, pusher->v->angles);
755                                 pusher->v->ltime = pushltime;
756                                 SV_LinkEdict (pusher, false);
757
758                                 // move back any entities we already moved
759                                 for (i = 0;i < num_moved;i++)
760                                 {
761                                         ed = sv.moved_edicts[i];
762                                         VectorCopy (ed->e->moved_from, ed->v->origin);
763                                         VectorCopy (ed->e->moved_fromangles, ed->v->angles);
764                                         SV_LinkEdict (ed, false);
765                                 }
766
767                                 // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
768                                 if (pusher->v->blocked)
769                                 {
770                                         pr_global_struct->self = EDICT_TO_PROG(pusher);
771                                         pr_global_struct->other = EDICT_TO_PROG(check);
772                                         PR_ExecuteProgram (pusher->v->blocked, "");
773                                 }
774                                 break;
775                         }
776                 }
777         }
778         pusher->v->angles[0] -= 360.0 * floor(pusher->v->angles[0] * (1.0 / 360.0));
779         pusher->v->angles[1] -= 360.0 * floor(pusher->v->angles[1] * (1.0 / 360.0));
780         pusher->v->angles[2] -= 360.0 * floor(pusher->v->angles[2] * (1.0 / 360.0));
781 }
782
783 /*
784 ================
785 SV_Physics_Pusher
786
787 ================
788 */
789 void SV_Physics_Pusher (edict_t *ent)
790 {
791         float thinktime, oldltime, movetime;
792
793         oldltime = ent->v->ltime;
794
795         thinktime = ent->v->nextthink;
796         if (thinktime < ent->v->ltime + sv.frametime)
797         {
798                 movetime = thinktime - ent->v->ltime;
799                 if (movetime < 0)
800                         movetime = 0;
801         }
802         else
803                 movetime = sv.frametime;
804
805         if (movetime)
806                 // advances ent->v->ltime if not blocked
807                 SV_PushMove (ent, movetime);
808
809         if (thinktime > oldltime && thinktime <= ent->v->ltime)
810         {
811                 ent->v->nextthink = 0;
812                 pr_global_struct->time = sv.time;
813                 pr_global_struct->self = EDICT_TO_PROG(ent);
814                 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
815                 PR_ExecuteProgram (ent->v->think, "NULL think function");
816         }
817 }
818
819
820 /*
821 ===============================================================================
822
823 CLIENT MOVEMENT
824
825 ===============================================================================
826 */
827
828 /*
829 =============
830 SV_CheckStuck
831
832 This is a big hack to try and fix the rare case of getting stuck in the world
833 clipping hull.
834 =============
835 */
836 void SV_CheckStuck (edict_t *ent)
837 {
838         int i, j, z;
839         vec3_t org;
840
841         if (!SV_TestEntityPosition(ent))
842         {
843                 VectorCopy (ent->v->origin, ent->v->oldorigin);
844                 return;
845         }
846
847         VectorCopy (ent->v->origin, org);
848         VectorCopy (ent->v->oldorigin, ent->v->origin);
849         if (!SV_TestEntityPosition(ent))
850         {
851                 Con_DPrint("Unstuck.\n");
852                 SV_LinkEdict (ent, true);
853                 return;
854         }
855
856         for (z=0 ; z< 18 ; z++)
857                 for (i=-1 ; i <= 1 ; i++)
858                         for (j=-1 ; j <= 1 ; j++)
859                         {
860                                 ent->v->origin[0] = org[0] + i;
861                                 ent->v->origin[1] = org[1] + j;
862                                 ent->v->origin[2] = org[2] + z;
863                                 if (!SV_TestEntityPosition(ent))
864                                 {
865                                         Con_DPrint("Unstuck.\n");
866                                         SV_LinkEdict (ent, true);
867                                         return;
868                                 }
869                         }
870
871         VectorCopy (org, ent->v->origin);
872         Con_DPrint("player is stuck.\n");
873 }
874
875
876 /*
877 =============
878 SV_CheckWater
879 =============
880 */
881 qboolean SV_CheckWater (edict_t *ent)
882 {
883         int cont;
884         vec3_t point;
885
886         point[0] = ent->v->origin[0];
887         point[1] = ent->v->origin[1];
888         point[2] = ent->v->origin[2] + ent->v->mins[2] + 1;
889
890         ent->v->waterlevel = 0;
891         ent->v->watertype = CONTENTS_EMPTY;
892         cont = SV_PointQ1Contents(point);
893         if (cont <= CONTENTS_WATER)
894         {
895                 ent->v->watertype = cont;
896                 ent->v->waterlevel = 1;
897                 point[2] = ent->v->origin[2] + (ent->v->mins[2] + ent->v->maxs[2])*0.5;
898                 cont = SV_PointQ1Contents(point);
899                 if (cont <= CONTENTS_WATER)
900                 {
901                         ent->v->waterlevel = 2;
902                         point[2] = ent->v->origin[2] + ent->v->view_ofs[2];
903                         cont = SV_PointQ1Contents(point);
904                         if (cont <= CONTENTS_WATER)
905                                 ent->v->waterlevel = 3;
906                 }
907         }
908
909         return ent->v->waterlevel > 1;
910 }
911
912 /*
913 ============
914 SV_WallFriction
915
916 ============
917 */
918 void SV_WallFriction (edict_t *ent, float *stepnormal)
919 {
920         float d, i;
921         vec3_t forward, into, side;
922
923         AngleVectors (ent->v->v_angle, forward, NULL, NULL);
924         if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
925         {
926                 // cut the tangential velocity
927                 i = DotProduct (stepnormal, ent->v->velocity);
928                 VectorScale (stepnormal, i, into);
929                 VectorSubtract (ent->v->velocity, into, side);
930                 ent->v->velocity[0] = side[0] * (1 + d);
931                 ent->v->velocity[1] = side[1] * (1 + d);
932         }
933 }
934
935 /*
936 =====================
937 SV_TryUnstick
938
939 Player has come to a dead stop, possibly due to the problem with limited
940 float precision at some angle joins in the BSP hull.
941
942 Try fixing by pushing one pixel in each direction.
943
944 This is a hack, but in the interest of good gameplay...
945 ======================
946 */
947 int SV_TryUnstick (edict_t *ent, vec3_t oldvel)
948 {
949         int i, clip;
950         vec3_t oldorg, dir;
951
952         VectorCopy (ent->v->origin, oldorg);
953         VectorClear (dir);
954
955         for (i=0 ; i<8 ; i++)
956         {
957                 // try pushing a little in an axial direction
958                 switch (i)
959                 {
960                         case 0: dir[0] = 2; dir[1] = 0; break;
961                         case 1: dir[0] = 0; dir[1] = 2; break;
962                         case 2: dir[0] = -2; dir[1] = 0; break;
963                         case 3: dir[0] = 0; dir[1] = -2; break;
964                         case 4: dir[0] = 2; dir[1] = 2; break;
965                         case 5: dir[0] = -2; dir[1] = 2; break;
966                         case 6: dir[0] = 2; dir[1] = -2; break;
967                         case 7: dir[0] = -2; dir[1] = -2; break;
968                 }
969
970                 SV_PushEntity (ent, dir);
971
972                 // retry the original move
973                 ent->v->velocity[0] = oldvel[0];
974                 ent->v->velocity[1] = oldvel[1];
975                 ent->v->velocity[2] = 0;
976                 clip = SV_FlyMove (ent, 0.1, NULL);
977
978                 if (fabs(oldorg[1] - ent->v->origin[1]) > 4
979                  || fabs(oldorg[0] - ent->v->origin[0]) > 4)
980                 {
981                         Con_DPrint("TryUnstick - success.\n");
982                         return clip;
983                 }
984
985                 // go back to the original pos and try again
986                 VectorCopy (oldorg, ent->v->origin);
987         }
988
989         // still not moving
990         VectorClear (ent->v->velocity);
991         Con_DPrint("TryUnstick - failure.\n");
992         return 7;
993 }
994
995 /*
996 =====================
997 SV_WalkMove
998
999 Only used by players
1000 ======================
1001 */
1002 void SV_WalkMove (edict_t *ent)
1003 {
1004         int clip, oldonground, originalmove_clip, originalmove_flags, originalmove_groundentity;
1005         vec3_t upmove, downmove, start_origin, start_velocity, stepnormal, originalmove_origin, originalmove_velocity;
1006         trace_t downtrace;
1007
1008         SV_CheckVelocity(ent);
1009
1010         // do a regular slide move unless it looks like you ran into a step
1011         oldonground = (int)ent->v->flags & FL_ONGROUND;
1012         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1013
1014         VectorCopy (ent->v->origin, start_origin);
1015         VectorCopy (ent->v->velocity, start_velocity);
1016
1017         clip = SV_FlyMove (ent, sv.frametime, NULL);
1018
1019         SV_SetOnGround (ent);
1020         SV_CheckVelocity(ent);
1021
1022         VectorCopy(ent->v->origin, originalmove_origin);
1023         VectorCopy(ent->v->velocity, originalmove_velocity);
1024         originalmove_clip = clip;
1025         originalmove_flags = (int)ent->v->flags;
1026         originalmove_groundentity = ent->v->groundentity;
1027
1028         if ((int)ent->v->flags & FL_WATERJUMP)
1029                 return;
1030
1031         if (sv_nostep.integer)
1032                 return;
1033         
1034         // if move didn't block on a step, return
1035         if (clip & 2)
1036         {
1037                 // if move was not trying to move into the step, return
1038                 if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
1039                         return;
1040         
1041                 if (ent->v->movetype != MOVETYPE_FLY)
1042                 {
1043                         // return if gibbed by a trigger
1044                         if (ent->v->movetype != MOVETYPE_WALK)
1045                                 return;
1046         
1047                         // only step up while jumping if that is enabled
1048                         if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))
1049                                 if (!oldonground && ent->v->waterlevel == 0)
1050                                         return;
1051                 }
1052         
1053                 // try moving up and forward to go up a step
1054                 // back to start pos
1055                 VectorCopy (start_origin, ent->v->origin);
1056                 VectorCopy (start_velocity, ent->v->velocity);
1057         
1058                 // move up
1059                 VectorClear (upmove);
1060                 upmove[2] = sv_stepheight.value;
1061                 // FIXME: don't link?
1062                 SV_PushEntity(ent, upmove);
1063         
1064                 // move forward
1065                 ent->v->velocity[2] = 0;
1066                 clip = SV_FlyMove (ent, sv.frametime, stepnormal);
1067                 ent->v->velocity[2] += start_velocity[2];
1068         
1069                 SV_CheckVelocity(ent);
1070         
1071                 // check for stuckness, possibly due to the limited precision of floats
1072                 // in the clipping hulls
1073                 if (clip
1074                  && fabs(originalmove_origin[1] - ent->v->origin[1]) < 0.03125
1075                  && fabs(originalmove_origin[0] - ent->v->origin[0]) < 0.03125)
1076                 {
1077                         //Con_Printf("wall\n");
1078                         // stepping up didn't make any progress, revert to original move
1079                         VectorCopy(originalmove_origin, ent->v->origin);
1080                         VectorCopy(originalmove_velocity, ent->v->velocity);
1081                         //clip = originalmove_clip;
1082                         ent->v->flags = originalmove_flags;
1083                         ent->v->groundentity = originalmove_groundentity; 
1084                         // now try to unstick if needed
1085                         //clip = SV_TryUnstick (ent, oldvel);
1086                         return;
1087                 }
1088
1089                 //Con_Printf("step - ");
1090
1091                 // extra friction based on view angle
1092                 if (clip & 2 && sv_wallfriction.integer)
1093                         SV_WallFriction (ent, stepnormal);
1094         }
1095         else if (!sv_gameplayfix_stepdown.integer || !oldonground || start_velocity[2] > 0 || ((int)ent->v->flags & FL_ONGROUND) || ent->v->waterlevel >= 2)
1096                 return;
1097
1098         // move down
1099         VectorClear (downmove);
1100         downmove[2] = -sv_stepheight.value + start_velocity[2]*sv.frametime;
1101         // FIXME: don't link?
1102         downtrace = SV_PushEntity (ent, downmove);
1103
1104         if (downtrace.fraction < 1 && downtrace.plane.normal[2] > 0.7)
1105         {
1106                 // LordHavoc: disabled this check so you can walk on monsters/players
1107                 //if (ent->v->solid == SOLID_BSP)
1108                 {
1109                         //Con_Printf("onground\n");
1110                         ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1111                         ent->v->groundentity = EDICT_TO_PROG(downtrace.ent);
1112                 }
1113         }
1114         else
1115         {
1116                 //Con_Printf("slope\n");
1117                 // if the push down didn't end up on good ground, use the move without
1118                 // the step up.  This happens near wall / slope combinations, and can
1119                 // cause the player to hop up higher on a slope too steep to climb
1120                 VectorCopy(originalmove_origin, ent->v->origin);
1121                 VectorCopy(originalmove_velocity, ent->v->velocity);
1122                 //clip = originalmove_clip;
1123                 ent->v->flags = originalmove_flags;
1124                 ent->v->groundentity = originalmove_groundentity; 
1125         }
1126
1127         SV_SetOnGround (ent);
1128         SV_CheckVelocity(ent);
1129 }
1130
1131 //============================================================================
1132
1133 /*
1134 =============
1135 SV_Physics_Follow
1136
1137 Entities that are "stuck" to another entity
1138 =============
1139 */
1140 void SV_Physics_Follow (edict_t *ent)
1141 {
1142         vec3_t vf, vr, vu, angles, v;
1143         edict_t *e;
1144
1145         // regular thinking
1146         if (!SV_RunThink (ent))
1147                 return;
1148
1149         // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1150         e = PROG_TO_EDICT(ent->v->aiment);
1151         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])
1152         {
1153                 // quick case for no rotation
1154                 VectorAdd(e->v->origin, ent->v->view_ofs, ent->v->origin);
1155         }
1156         else
1157         {
1158                 angles[0] = -ent->v->punchangle[0];
1159                 angles[1] =  ent->v->punchangle[1];
1160                 angles[2] =  ent->v->punchangle[2];
1161                 AngleVectors (angles, vf, vr, vu);
1162                 v[0] = ent->v->view_ofs[0] * vf[0] + ent->v->view_ofs[1] * vr[0] + ent->v->view_ofs[2] * vu[0];
1163                 v[1] = ent->v->view_ofs[0] * vf[1] + ent->v->view_ofs[1] * vr[1] + ent->v->view_ofs[2] * vu[1];
1164                 v[2] = ent->v->view_ofs[0] * vf[2] + ent->v->view_ofs[1] * vr[2] + ent->v->view_ofs[2] * vu[2];
1165                 angles[0] = -e->v->angles[0];
1166                 angles[1] =  e->v->angles[1];
1167                 angles[2] =  e->v->angles[2];
1168                 AngleVectors (angles, vf, vr, vu);
1169                 ent->v->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->v->origin[0];
1170                 ent->v->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->v->origin[1];
1171                 ent->v->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->v->origin[2];
1172         }
1173         VectorAdd (e->v->angles, ent->v->v_angle, ent->v->angles);
1174         SV_LinkEdict (ent, true);
1175 }
1176
1177 /*
1178 ==============================================================================
1179
1180 TOSS / BOUNCE
1181
1182 ==============================================================================
1183 */
1184
1185 /*
1186 =============
1187 SV_CheckWaterTransition
1188
1189 =============
1190 */
1191 void SV_CheckWaterTransition (edict_t *ent)
1192 {
1193         int cont;
1194         cont = SV_PointQ1Contents(ent->v->origin);
1195         if (!ent->v->watertype)
1196         {
1197                 // just spawned here
1198                 ent->v->watertype = cont;
1199                 ent->v->waterlevel = 1;
1200                 return;
1201         }
1202
1203         // check if the entity crossed into or out of water
1204         if ((ent->v->watertype == CONTENTS_WATER || ent->v->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME))
1205                 SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
1206
1207         if (cont <= CONTENTS_WATER)
1208         {
1209                 ent->v->watertype = cont;
1210                 ent->v->waterlevel = 1;
1211         }
1212         else
1213         {
1214                 ent->v->watertype = CONTENTS_EMPTY;
1215                 ent->v->waterlevel = 0;
1216         }
1217 }
1218
1219 /*
1220 =============
1221 SV_Physics_Toss
1222
1223 Toss, bounce, and fly movement.  When onground, do nothing.
1224 =============
1225 */
1226 void SV_Physics_Toss (edict_t *ent)
1227 {
1228         trace_t trace;
1229         vec3_t move;
1230         edict_t *groundentity;
1231
1232         // regular thinking
1233         if (!SV_RunThink (ent))
1234                 return;
1235
1236 // if onground, return without moving
1237         if ((int)ent->v->flags & FL_ONGROUND)
1238         {
1239                 if (!sv_gameplayfix_noairborncorpse.integer)
1240                         return;
1241                 if (ent->v->groundentity == 0)
1242                         return;
1243                 // if ent was supported by a brush model on previous frame,
1244                 // and groundentity is now freed, set groundentity to 0 (floating)
1245                 groundentity = PROG_TO_EDICT(ent->v->groundentity);
1246                 if (groundentity->v->solid == SOLID_BSP)
1247                 {
1248                         ent->e->suspendedinairflag = true;
1249                         return;
1250                 }
1251                 else if (ent->e->suspendedinairflag && groundentity->e->free)
1252                 {
1253                         // leave it suspended in the air
1254                         ent->v->groundentity = 0;
1255                         ent->e->suspendedinairflag = false;
1256                         return;
1257                 }
1258         }
1259         ent->e->suspendedinairflag = false;
1260
1261         SV_CheckVelocity (ent);
1262
1263 // add gravity
1264         if (ent->v->movetype == MOVETYPE_TOSS || ent->v->movetype == MOVETYPE_BOUNCE)
1265                 SV_AddGravity (ent);
1266
1267 // move angles
1268         VectorMA (ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1269
1270 // move origin
1271         VectorScale (ent->v->velocity, sv.frametime, move);
1272         trace = SV_PushEntity (ent, move);
1273         if (ent->e->free)
1274                 return;
1275
1276         if (trace.fraction < 1)
1277         {
1278                 if (ent->v->movetype == MOVETYPE_BOUNCEMISSILE)
1279                 {
1280                         ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 2.0);
1281                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1282                 }
1283                 else if (ent->v->movetype == MOVETYPE_BOUNCE)
1284                 {
1285                         float d;
1286                         ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.5);
1287                         // LordHavoc: fixed grenades not bouncing when fired down a slope
1288                         if (sv_gameplayfix_grenadebouncedownslopes.integer)
1289                         {
1290                                 d = DotProduct(trace.plane.normal, ent->v->velocity);
1291                                 if (trace.plane.normal[2] > 0.7 && fabs(d) < 60)
1292                                 {
1293                                         ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1294                                         ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1295                                         VectorClear (ent->v->velocity);
1296                                         VectorClear (ent->v->avelocity);
1297                                 }
1298                                 else
1299                                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1300                         }
1301                         else
1302                         {
1303                                 if (trace.plane.normal[2] > 0.7 && ent->v->velocity[2] < 60)
1304                                 {
1305                                         ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1306                                         ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1307                                         VectorClear (ent->v->velocity);
1308                                         VectorClear (ent->v->avelocity);
1309                                 }
1310                                 else
1311                                         ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1312                         }
1313                 }
1314                 else
1315                 {
1316                         ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, 1.0);
1317                         if (trace.plane.normal[2] > 0.7)
1318                         {
1319                                 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1320                                 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1321                                 VectorClear (ent->v->velocity);
1322                                 VectorClear (ent->v->avelocity);
1323                         }
1324                         else
1325                                 ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
1326                 }
1327         }
1328
1329 // check for in water
1330         SV_CheckWaterTransition (ent);
1331 }
1332
1333 /*
1334 ===============================================================================
1335
1336 STEPPING MOVEMENT
1337
1338 ===============================================================================
1339 */
1340
1341 /*
1342 =============
1343 SV_Physics_Step
1344
1345 Monsters freefall when they don't have a ground entity, otherwise
1346 all movement is done with discrete steps.
1347
1348 This is also used for objects that have become still on the ground, but
1349 will fall if the floor is pulled out from under them.
1350 =============
1351 */
1352 void SV_Physics_Step (edict_t *ent)
1353 {
1354         // freefall if not onground/fly/swim
1355         if (!((int)ent->v->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
1356         {
1357                 int hitsound = ent->v->velocity[2] < sv_gravity.value * -0.1;
1358
1359                 SV_AddGravity(ent);
1360                 SV_CheckVelocity(ent);
1361                 SV_FlyMove(ent, sv.frametime, NULL);
1362                 SV_LinkEdict(ent, true);
1363
1364                 // just hit ground
1365                 if (hitsound && (int)ent->v->flags & FL_ONGROUND)
1366                         SV_StartSound(ent, 0, "demon/dland2.wav", 255, 1);
1367         }
1368
1369 // regular thinking
1370         SV_RunThink(ent);
1371
1372         SV_CheckWaterTransition(ent);
1373 }
1374
1375 //============================================================================
1376
1377 /*
1378 ================
1379 SV_Physics
1380
1381 ================
1382 */
1383 void SV_Physics (void)
1384 {
1385         int i;
1386         edict_t *ent;
1387
1388 // let the progs know that a new frame has started
1389         pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1390         pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1391         pr_global_struct->time = sv.time;
1392         PR_ExecuteProgram (pr_global_struct->StartFrame, "QC function StartFrame is missing");
1393
1394 //
1395 // treat each object in turn
1396 //
1397         ent = sv.edicts;
1398         for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1399         {
1400                 if (ent->e->free)
1401                         continue;
1402
1403                 if (pr_global_struct->force_retouch)
1404                         SV_LinkEdict (ent, true);       // force retouch even for stationary
1405
1406                 if (i <= svs.maxclients)
1407                 {
1408                         if (i > 0)
1409                         {
1410                                 if (!svs.clients[i-1].spawned)
1411                                         continue;
1412                                 // connected slot
1413                                 // call standard client pre-think
1414                                 SV_CheckVelocity (ent);
1415                                 pr_global_struct->time = sv.time;
1416                                 pr_global_struct->self = EDICT_TO_PROG(ent);
1417                                 PR_ExecuteProgram (pr_global_struct->PlayerPreThink, "QC function PlayerPreThink is missing");
1418                                 SV_CheckVelocity (ent);
1419                         }
1420                 }
1421                 else if (sv_freezenonclients.integer)
1422                         continue;
1423
1424                 // LordHavoc: merged client and normal entity physics
1425                 switch ((int) ent->v->movetype)
1426                 {
1427                 case MOVETYPE_PUSH:
1428                 case MOVETYPE_FAKEPUSH:
1429                         SV_Physics_Pusher (ent);
1430                         break;
1431                 case MOVETYPE_NONE:
1432                         // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1433                         if (ent->v->nextthink > 0 && ent->v->nextthink <= sv.time + sv.frametime)
1434                                 SV_RunThink (ent);
1435                         break;
1436                 case MOVETYPE_FOLLOW:
1437                         SV_Physics_Follow (ent);
1438                         break;
1439                 case MOVETYPE_NOCLIP:
1440                         if (SV_RunThink(ent))
1441                         {
1442                                 SV_CheckWater(ent);
1443                                 VectorMA(ent->v->origin, sv.frametime, ent->v->velocity, ent->v->origin);
1444                                 VectorMA(ent->v->angles, sv.frametime, ent->v->avelocity, ent->v->angles);
1445                         }
1446                         // relink normal entities here, players always get relinked so don't relink twice
1447                         if (!(i > 0 && i <= svs.maxclients))
1448                                 SV_LinkEdict(ent, false);
1449                         break;
1450                 case MOVETYPE_STEP:
1451                         SV_Physics_Step (ent);
1452                         break;
1453                 case MOVETYPE_WALK:
1454                         if (SV_RunThink (ent))
1455                         {
1456                                 if (!SV_CheckWater (ent) && ! ((int)ent->v->flags & FL_WATERJUMP) )
1457                                         SV_AddGravity (ent);
1458                                 SV_CheckStuck (ent);
1459                                 SV_WalkMove (ent);
1460                                 // relink normal entities here, players always get relinked so don't relink twice
1461                                 if (!(i > 0 && i <= svs.maxclients))
1462                                         SV_LinkEdict (ent, true);
1463                         }
1464                         break;
1465                 case MOVETYPE_TOSS:
1466                 case MOVETYPE_BOUNCE:
1467                 case MOVETYPE_BOUNCEMISSILE:
1468                 case MOVETYPE_FLYMISSILE:
1469                         SV_Physics_Toss (ent);
1470                         break;
1471                 case MOVETYPE_FLY:
1472                         if (i > 0 && i <= svs.maxclients)
1473                         {
1474                                 if (SV_RunThink (ent))
1475                                 {
1476                                         SV_CheckWater (ent);
1477                                         SV_WalkMove (ent);
1478                                 }
1479                         }
1480                         else
1481                                 SV_Physics_Toss (ent);
1482                         break;
1483                 default:
1484                         Host_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
1485                         break;
1486                 }
1487
1488                 if (i <= svs.maxclients && i > 0 && !ent->e->free)
1489                 {
1490                         SV_CheckVelocity (ent);
1491
1492                         // call standard player post-think
1493                         SV_LinkEdict (ent, true);
1494
1495                         SV_CheckVelocity (ent);
1496
1497                         pr_global_struct->time = sv.time;
1498                         pr_global_struct->self = EDICT_TO_PROG(ent);
1499                         PR_ExecuteProgram (pr_global_struct->PlayerPostThink, "QC function PlayerPostThink is missing");
1500                 }
1501         }
1502
1503         if (pr_global_struct->force_retouch)
1504                 pr_global_struct->force_retouch--;
1505
1506         // LordHavoc: endframe support
1507         if (EndFrameQC)
1508         {
1509                 pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
1510                 pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
1511                 pr_global_struct->time = sv.time;
1512                 PR_ExecuteProgram ((func_t)(EndFrameQC - pr_functions), "");
1513         }
1514
1515         if (!sv_freezenonclients.integer)
1516                 sv.time += sv.frametime;
1517 }
1518
1519
1520 trace_t SV_Trace_Toss (edict_t *tossent, edict_t *ignore)
1521 {
1522         int i;
1523         float gravity, savesolid;
1524         vec3_t move, end;
1525         edict_t tempent, *tent;
1526         entvars_t vars;
1527         eval_t *val;
1528         trace_t trace;
1529
1530         // copy the vars over
1531         memcpy(&vars, tossent->v, sizeof(entvars_t));
1532         // set up the temp entity to point to the copied vars
1533         tent = &tempent;
1534         tent->v = &vars;
1535
1536         savesolid = tossent->v->solid;
1537         tossent->v->solid = SOLID_NOT;
1538
1539         // this has to fetch the field from the original edict, since our copy is truncated
1540         val = GETEDICTFIELDVALUE(tossent, eval_gravity);
1541         if (val != NULL && val->_float != 0)
1542                 gravity = val->_float;
1543         else
1544                 gravity = 1.0;
1545         gravity *= sv_gravity.value * 0.05;
1546
1547         for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1548         {
1549                 SV_CheckVelocity (tent);
1550                 tent->v->velocity[2] -= gravity;
1551                 VectorMA (tent->v->angles, 0.05, tent->v->avelocity, tent->v->angles);
1552                 VectorScale (tent->v->velocity, 0.05, move);
1553                 VectorAdd (tent->v->origin, move, end);
1554                 trace = SV_Move (tent->v->origin, tent->v->mins, tent->v->maxs, end, MOVE_NORMAL, tent);
1555                 VectorCopy (trace.endpos, tent->v->origin);
1556
1557                 if (trace.fraction < 1 && trace.ent && trace.ent != ignore)
1558                         break;
1559         }
1560         tossent->v->solid = savesolid;
1561         trace.fraction = 0; // not relevant
1562         return trace;
1563 }
1564