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