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