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