removed an unneeded extern prototype
[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", "how fast you slow down"};
43 cvar_t sv_waterfriction = {CVAR_NOTIFY, "sv_waterfriction","-1", "how fast you slow down, if less than 0 the sv_friction variable is used instead"};
44 cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
45 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
46 cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
47 cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
48 cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
49 cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
50 cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
51 cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0", "enables simpler/buggier player physics (not recommended)"};
52 cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
53 cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
54
55 cvar_t sv_sound_watersplash = {0, "sv_sound_watersplash", "misc/h2ohit1.wav", "sound to play when MOVETYPE_FLY/TOSS/BOUNCE/STEP entity enters or leaves water (empty cvar disables the sound)"};
56 cvar_t sv_sound_land = {0, "sv_sound_land", "demon/dland2.wav", "sound to play when MOVETYPE_STEP entity hits the ground at high speed (empty cvar disables the sound)"};
57
58 // TODO: move this extern to server.h
59 extern cvar_t sv_clmovement_waitforinput;
60
61 #define MOVE_EPSILON    0.01
62
63 void SV_Physics_Toss (prvm_edict_t *ent);
64
65 void SV_Phys_Init (void)
66 {
67         Cvar_RegisterVariable(&sv_stepheight);
68         Cvar_RegisterVariable(&sv_jumpstep);
69         Cvar_RegisterVariable(&sv_wallfriction);
70         Cvar_RegisterVariable(&sv_newflymove);
71         Cvar_RegisterVariable(&sv_freezenonclients);
72
73         Cvar_RegisterVariable(&sv_playerphysicsqc);
74
75         Cvar_RegisterVariable(&sv_sound_watersplash);
76         Cvar_RegisterVariable(&sv_sound_land);
77 }
78
79 /*
80 ============
81 SV_TestEntityPosition
82
83 returns true if the entity is in solid currently
84 ============
85 */
86 static int SV_TestEntityPosition (prvm_edict_t *ent)
87 {
88         trace_t trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->origin, MOVE_NOMONSTERS, ent);
89         if (trace.startsupercontents & SUPERCONTENTS_SOLID)
90                 return true;
91         else
92         {
93                 if (sv.worldmodel->brushq1.numclipnodes && !VectorCompare(ent->fields.server->mins, ent->fields.server->maxs))
94                 {
95                         // q1bsp/hlbsp use hulls and if the entity does not exactly match
96                         // a hull size it is incorrectly tested, so this code tries to
97                         // 'fix' it slightly...
98                         int i;
99                         vec3_t v;
100                         for (i = 0;i < 8;i++)
101                         {
102                                 v[0] = ent->fields.server->origin[0] + (i & 1) ? ent->fields.server->maxs[0] : ent->fields.server->mins[0];
103                                 v[1] = ent->fields.server->origin[1] + (i & 2) ? ent->fields.server->maxs[1] : ent->fields.server->mins[1];
104                                 v[2] = ent->fields.server->origin[2] + (i & 4) ? ent->fields.server->maxs[2] : ent->fields.server->mins[2];
105                                 if (SV_PointSuperContents(v) & SUPERCONTENTS_SOLID)
106                                         return true;
107                         }
108                 }
109                 return false;
110         }
111 }
112
113 /*
114 ================
115 SV_CheckAllEnts
116 ================
117 */
118 void SV_CheckAllEnts (void)
119 {
120         int e;
121         prvm_edict_t *check;
122
123         // see if any solid entities are inside the final position
124         check = PRVM_NEXT_EDICT(prog->edicts);
125         for (e = 1;e < prog->num_edicts;e++, check = PRVM_NEXT_EDICT(check))
126         {
127                 if (check->priv.server->free)
128                         continue;
129                 if (check->fields.server->movetype == MOVETYPE_PUSH
130                  || check->fields.server->movetype == MOVETYPE_NONE
131                  || check->fields.server->movetype == MOVETYPE_FOLLOW
132                  || check->fields.server->movetype == MOVETYPE_NOCLIP)
133                         continue;
134
135                 if (SV_TestEntityPosition (check))
136                         Con_Print("entity in invalid position\n");
137         }
138 }
139
140 // DRESK - Support for Entity Contents Transition Event
141 /*
142 ================
143 SV_CheckContentsTransition
144
145 returns true if entity had a valid contentstransition function call
146 ================
147 */
148 int SV_CheckContentsTransition(prvm_edict_t *ent, const int nContents)
149 {
150         int bValidFunctionCall;
151         prvm_eval_t *contentstransition;
152
153         // Default Valid Function Call to False
154         bValidFunctionCall = false;
155
156         if(ent->fields.server->watertype != nContents)
157         { // Changed Contents
158                 // Acquire Contents Transition Function from QC
159                 contentstransition = PRVM_GETEDICTFIELDVALUE(ent, eval_contentstransition);
160
161                 if(contentstransition->function)
162                 { // Valid Function; Execute
163                         // Assign Valid Function
164                         bValidFunctionCall = true;
165                         // Prepare Parameters (Original Contents, New Contents)
166                                 // Original Contents
167                                 PRVM_G_FLOAT(OFS_PARM0) = ent->fields.server->watertype;
168                                 // New Contents
169                                 PRVM_G_FLOAT(OFS_PARM1) = nContents;
170                         // Execute VM Function
171                         PRVM_ExecuteProgram(contentstransition->function, "contentstransition: NULL function");
172                 }
173         }
174
175         // Return if Function Call was Valid
176         return bValidFunctionCall;
177 }
178
179
180 /*
181 ================
182 SV_CheckVelocity
183 ================
184 */
185 void SV_CheckVelocity (prvm_edict_t *ent)
186 {
187         int i;
188         float wishspeed;
189
190 //
191 // bound velocity
192 //
193         for (i=0 ; i<3 ; i++)
194         {
195                 if (IS_NAN(ent->fields.server->velocity[i]))
196                 {
197                         Con_Printf("Got a NaN velocity on %s\n", PRVM_GetString(ent->fields.server->classname));
198                         ent->fields.server->velocity[i] = 0;
199                 }
200                 if (IS_NAN(ent->fields.server->origin[i]))
201                 {
202                         Con_Printf("Got a NaN origin on %s\n", PRVM_GetString(ent->fields.server->classname));
203                         ent->fields.server->origin[i] = 0;
204                 }
205         }
206
207         // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
208         wishspeed = DotProduct(ent->fields.server->velocity, ent->fields.server->velocity);
209         if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
210         {
211                 wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
212                 ent->fields.server->velocity[0] *= wishspeed;
213                 ent->fields.server->velocity[1] *= wishspeed;
214                 ent->fields.server->velocity[2] *= wishspeed;
215         }
216 }
217
218 /*
219 =============
220 SV_RunThink
221
222 Runs thinking code if time.  There is some play in the exact time the think
223 function will be called, because it is called before any movement is done
224 in a frame.  Not used for pushmove objects, because they must be exact.
225 Returns false if the entity removed itself.
226 =============
227 */
228 qboolean SV_RunThink (prvm_edict_t *ent)
229 {
230         float thinktime;
231
232         thinktime = ent->fields.server->nextthink;
233         if (thinktime <= 0 || thinktime > sv.time + sv.frametime)
234                 return true;
235
236         // don't let things stay in the past.
237         // it is possible to start that way by a trigger with a local time.
238         if (thinktime < sv.time)
239                 thinktime = sv.time;
240
241         ent->fields.server->nextthink = 0;
242         prog->globals.server->time = thinktime;
243         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
244         prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
245         PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
246         return !ent->priv.server->free;
247 }
248
249 /*
250 ==================
251 SV_Impact
252
253 Two entities have touched, so run their touch functions
254 ==================
255 */
256 void SV_Impact (prvm_edict_t *e1, trace_t *trace)
257 {
258         int old_self, old_other;
259         prvm_edict_t *e2 = (prvm_edict_t *)trace->ent;
260         prvm_eval_t *val;
261
262         old_self = prog->globals.server->self;
263         old_other = prog->globals.server->other;
264
265         prog->globals.server->time = sv.time;
266         if (!e1->priv.server->free && !e2->priv.server->free && e1->fields.server->touch && e1->fields.server->solid != SOLID_NOT)
267         {
268                 prog->globals.server->self = PRVM_EDICT_TO_PROG(e1);
269                 prog->globals.server->other = PRVM_EDICT_TO_PROG(e2);
270                 prog->globals.server->trace_allsolid = trace->allsolid;
271                 prog->globals.server->trace_startsolid = trace->startsolid;
272                 prog->globals.server->trace_fraction = trace->fraction;
273                 prog->globals.server->trace_inwater = trace->inwater;
274                 prog->globals.server->trace_inopen = trace->inopen;
275                 VectorCopy (trace->endpos, prog->globals.server->trace_endpos);
276                 VectorCopy (trace->plane.normal, prog->globals.server->trace_plane_normal);
277                 prog->globals.server->trace_plane_dist =  trace->plane.dist;
278                 if (trace->ent)
279                         prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(trace->ent);
280                 else
281                         prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
282                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dpstartcontents)))
283                         val->_float = trace->startsupercontents;
284                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dphitcontents)))
285                         val->_float = trace->hitsupercontents;
286                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dphitq3surfaceflags)))
287                         val->_float = trace->hitq3surfaceflags;
288                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dphittexturename)))
289                 {
290                         if (trace->hittexture)
291                                 val->string = PRVM_SetTempString(trace->hittexture->name);
292                         else
293                                 val->string = 0;
294                 }
295                 PRVM_ExecuteProgram (e1->fields.server->touch, "QC function self.touch is missing");
296         }
297
298         if (!e1->priv.server->free && !e2->priv.server->free && e2->fields.server->touch && e2->fields.server->solid != SOLID_NOT)
299         {
300                 prog->globals.server->self = PRVM_EDICT_TO_PROG(e2);
301                 prog->globals.server->other = PRVM_EDICT_TO_PROG(e1);
302                 prog->globals.server->trace_allsolid = false;
303                 prog->globals.server->trace_startsolid = false;
304                 prog->globals.server->trace_fraction = 1;
305                 prog->globals.server->trace_inwater = false;
306                 prog->globals.server->trace_inopen = true;
307                 VectorCopy (e2->fields.server->origin, prog->globals.server->trace_endpos);
308                 VectorSet (prog->globals.server->trace_plane_normal, 0, 0, 1);
309                 prog->globals.server->trace_plane_dist = 0;
310                 prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(e1);
311                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dpstartcontents)))
312                         val->_float = 0;
313                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dphitcontents)))
314                         val->_float = 0;
315                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dphitq3surfaceflags)))
316                         val->_float = 0;
317                 if ((val = PRVM_GETGLOBALFIELDVALUE(gval_trace_dphittexturename)))
318                         val->string = 0;
319                 PRVM_ExecuteProgram (e2->fields.server->touch, "QC function self.touch is missing");
320         }
321
322         prog->globals.server->self = old_self;
323         prog->globals.server->other = old_other;
324 }
325
326
327 /*
328 ==================
329 ClipVelocity
330
331 Slide off of the impacting object
332 returns the blocked flags (1 = floor, 2 = step / wall)
333 ==================
334 */
335 #define STOP_EPSILON 0.1
336 void ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
337 {
338         int i;
339         float backoff;
340
341         backoff = -DotProduct (in, normal) * overbounce;
342         VectorMA(in, backoff, normal, out);
343
344         for (i = 0;i < 3;i++)
345                 if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
346                         out[i] = 0;
347 }
348
349
350 /*
351 ============
352 SV_FlyMove
353
354 The basic solid body movement clip that slides along multiple planes
355 Returns the clipflags if the velocity was modified (hit something solid)
356 1 = floor
357 2 = wall / step
358 4 = dead stop
359 If stepnormal is not NULL, the plane normal of any vertical wall hit will be stored
360 ============
361 */
362 // LordHavoc: increased from 5 to 32
363 #define MAX_CLIP_PLANES 32
364 int SV_FlyMove (prvm_edict_t *ent, float time, float *stepnormal)
365 {
366         int blocked, bumpcount;
367         int i, j, impact, numplanes;
368         float d, time_left;
369         vec3_t dir, end, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, new_velocity;
370         trace_t trace;
371         blocked = 0;
372         VectorCopy(ent->fields.server->velocity, original_velocity);
373         VectorCopy(ent->fields.server->velocity, primal_velocity);
374         numplanes = 0;
375         time_left = time;
376         for (bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
377         {
378                 if (!ent->fields.server->velocity[0] && !ent->fields.server->velocity[1] && !ent->fields.server->velocity[2])
379                         break;
380
381                 VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
382                 trace = SV_Move(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
383 #if 0
384                 //if (trace.fraction < 0.002)
385                 {
386 #if 1
387                         vec3_t start;
388                         trace_t testtrace;
389                         VectorCopy(ent->fields.server->origin, start);
390                         start[2] += 3;//0.03125;
391                         VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
392                         end[2] += 3;//0.03125;
393                         testtrace = SV_Move(start, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
394                         if (trace.fraction < testtrace.fraction && !testtrace.startsolid && (testtrace.fraction == 1 || DotProduct(trace.plane.normal, ent->fields.server->velocity) < DotProduct(testtrace.plane.normal, ent->fields.server->velocity)))
395                         {
396                                 Con_Printf("got further (new %f > old %f)\n", testtrace.fraction, trace.fraction);
397                                 trace = testtrace;
398                         }
399 #endif
400 #if 0
401                         //j = -1;
402                         for (i = 0;i < numplanes;i++)
403                         {
404                                 VectorCopy(ent->fields.server->origin, start);
405                                 VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
406                                 VectorMA(start, 3, planes[i], start);
407                                 VectorMA(end, 3, planes[i], end);
408                                 testtrace = SV_Move(start, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
409                                 if (trace.fraction < testtrace.fraction)
410                                 {
411                                         trace = testtrace;
412                                         VectorCopy(start, ent->fields.server->origin);
413                                         //j = i;
414                                 }
415                         }
416                         //if (j >= 0)
417                         //      VectorAdd(ent->fields.server->origin, planes[j], start);
418 #endif
419                 }
420 #endif
421
422 #if 0
423                 Con_Printf("entity %i bump %i: velocity %f %f %f trace %f", ent - prog->edicts, bumpcount, ent->fields.server->velocity[0], ent->fields.server->velocity[1], ent->fields.server->velocity[2], trace.fraction);
424                 if (trace.fraction < 1)
425                         Con_Printf(" : %f %f %f", trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2]);
426                 Con_Print("\n");
427 #endif
428
429 #if 0
430                 if (trace.bmodelstartsolid)
431                 {
432                         // LordHavoc: note: this code is what makes entities stick in place
433                         // if embedded in world only (you can walk through other objects if
434                         // stuck)
435                         // entity is trapped in another solid
436                         VectorClear(ent->fields.server->velocity);
437                         return 3;
438                 }
439 #endif
440
441                 // break if it moved the entire distance
442                 if (trace.fraction == 1)
443                 {
444                         VectorCopy(trace.endpos, ent->fields.server->origin);
445                         break;
446                 }
447
448                 if (!trace.ent)
449                 {
450                         Con_Printf ("SV_FlyMove: !trace.ent");
451                         trace.ent = prog->edicts;
452                 }
453
454                 if (((int) ent->fields.server->flags & FL_ONGROUND) && ent->fields.server->groundentity == PRVM_EDICT_TO_PROG(trace.ent))
455                         impact = false;
456                 else
457                 {
458                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
459                         impact = true;
460                 }
461
462                 if (trace.plane.normal[2])
463                 {
464                         if (trace.plane.normal[2] > 0.7)
465                         {
466                                 // floor
467                                 blocked |= 1;
468                                 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
469                                 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
470                         }
471                 }
472                 else
473                 {
474                         // step
475                         blocked |= 2;
476                         // save the trace for player extrafriction
477                         if (stepnormal)
478                                 VectorCopy(trace.plane.normal, stepnormal);
479                 }
480
481                 if (trace.fraction >= 0.001)
482                 {
483                         // actually covered some distance
484                         VectorCopy(trace.endpos, ent->fields.server->origin);
485                         VectorCopy(ent->fields.server->velocity, original_velocity);
486                         numplanes = 0;
487                 }
488
489                 // run the impact function
490                 if (impact)
491                 {
492                         SV_Impact(ent, &trace);
493
494                         // break if removed by the impact function
495                         if (ent->priv.server->free)
496                                 break;
497                 }
498
499                 time_left *= 1 - trace.fraction;
500
501                 // clipped to another plane
502                 if (numplanes >= MAX_CLIP_PLANES)
503                 {
504                         // this shouldn't really happen
505                         VectorClear(ent->fields.server->velocity);
506                         blocked = 3;
507                         break;
508                 }
509
510                 /*
511                 for (i = 0;i < numplanes;i++)
512                         if (DotProduct(trace.plane.normal, planes[i]) > 0.99)
513                                 break;
514                 if (i < numplanes)
515                 {
516                         VectorAdd(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity);
517                         continue;
518                 }
519                 */
520
521                 VectorCopy(trace.plane.normal, planes[numplanes]);
522                 numplanes++;
523
524                 if (sv_newflymove.integer)
525                         ClipVelocity(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1);
526                 else
527                 {
528                         // modify original_velocity so it parallels all of the clip planes
529                         for (i = 0;i < numplanes;i++)
530                         {
531                                 ClipVelocity(original_velocity, planes[i], new_velocity, 1);
532                                 for (j = 0;j < numplanes;j++)
533                                 {
534                                         if (j != i)
535                                         {
536                                                 // not ok
537                                                 if (DotProduct(new_velocity, planes[j]) < 0)
538                                                         break;
539                                         }
540                                 }
541                                 if (j == numplanes)
542                                         break;
543                         }
544
545                         if (i != numplanes)
546                         {
547                                 // go along this plane
548                                 VectorCopy(new_velocity, ent->fields.server->velocity);
549                         }
550                         else
551                         {
552                                 // go along the crease
553                                 if (numplanes != 2)
554                                 {
555                                         VectorClear(ent->fields.server->velocity);
556                                         blocked = 7;
557                                         break;
558                                 }
559                                 CrossProduct(planes[0], planes[1], dir);
560                                 // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
561                                 VectorNormalize(dir);
562                                 d = DotProduct(dir, ent->fields.server->velocity);
563                                 VectorScale(dir, d, ent->fields.server->velocity);
564                         }
565                 }
566
567                 // if current velocity is against the original velocity,
568                 // stop dead to avoid tiny occilations in sloping corners
569                 if (DotProduct(ent->fields.server->velocity, primal_velocity) <= 0)
570                 {
571                         VectorClear(ent->fields.server->velocity);
572                         break;
573                 }
574         }
575
576         //Con_Printf("entity %i final: blocked %i velocity %f %f %f\n", ent - prog->edicts, blocked, ent->fields.server->velocity[0], ent->fields.server->velocity[1], ent->fields.server->velocity[2]);
577
578         /*
579         if ((blocked & 1) == 0 && bumpcount > 1)
580         {
581                 // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
582                 // flag ONGROUND if there's ground under it
583                 trace = SV_Move(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
584         }
585         */
586
587         // LordHavoc: this came from QW and allows you to get out of water more easily
588         if (sv_gameplayfix_qwplayerphysics.integer && ((int)ent->fields.server->flags & FL_WATERJUMP))
589                 VectorCopy(primal_velocity, ent->fields.server->velocity);
590         return blocked;
591 }
592
593 /*
594 ============
595 SV_AddGravity
596
597 ============
598 */
599 void SV_AddGravity (prvm_edict_t *ent)
600 {
601         float ent_gravity;
602         prvm_eval_t *val;
603
604         val = PRVM_GETEDICTFIELDVALUE(ent, eval_gravity);
605         if (val!=0 && val->_float)
606                 ent_gravity = val->_float;
607         else
608                 ent_gravity = 1.0;
609         ent->fields.server->velocity[2] -= ent_gravity * sv_gravity.value * sv.frametime;
610 }
611
612
613 /*
614 ===============================================================================
615
616 PUSHMOVE
617
618 ===============================================================================
619 */
620
621 /*
622 ============
623 SV_PushEntity
624
625 Does not change the entities velocity at all
626 ============
627 */
628 static trace_t SV_PushEntity (prvm_edict_t *ent, vec3_t push, qboolean failonbmodelstartsolid)
629 {
630         int type;
631         trace_t trace;
632         vec3_t end;
633
634         VectorAdd (ent->fields.server->origin, push, end);
635
636         if (ent->fields.server->movetype == MOVETYPE_FLYMISSILE)
637                 type = MOVE_MISSILE;
638         else if (ent->fields.server->solid == SOLID_TRIGGER || ent->fields.server->solid == SOLID_NOT)
639                 type = MOVE_NOMONSTERS; // only clip against bmodels
640         else
641                 type = MOVE_NORMAL;
642
643         trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, type, ent);
644         if (trace.bmodelstartsolid && failonbmodelstartsolid)
645                 return trace;
646
647         VectorCopy (trace.endpos, ent->fields.server->origin);
648         SV_LinkEdict (ent, true);
649
650         if (ent->fields.server->solid >= SOLID_TRIGGER && trace.ent && (!((int)ent->fields.server->flags & FL_ONGROUND) || ent->fields.server->groundentity != PRVM_EDICT_TO_PROG(trace.ent)))
651                 SV_Impact (ent, &trace);
652         return trace;
653 }
654
655
656 /*
657 ============
658 SV_PushMove
659
660 ============
661 */
662 void SV_PushMove (prvm_edict_t *pusher, float movetime)
663 {
664         int i, e, index;
665         float savesolid, movetime2, pushltime;
666         vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org;
667         int num_moved;
668         int numcheckentities;
669         static prvm_edict_t *checkentities[MAX_EDICTS];
670         model_t *pushermodel;
671         trace_t trace;
672
673         if (!pusher->fields.server->velocity[0] && !pusher->fields.server->velocity[1] && !pusher->fields.server->velocity[2] && !pusher->fields.server->avelocity[0] && !pusher->fields.server->avelocity[1] && !pusher->fields.server->avelocity[2])
674         {
675                 pusher->fields.server->ltime += movetime;
676                 return;
677         }
678
679         switch ((int) pusher->fields.server->solid)
680         {
681         // LordHavoc: valid pusher types
682         case SOLID_BSP:
683         case SOLID_BBOX:
684         case SOLID_SLIDEBOX:
685         case SOLID_CORPSE: // LordHavoc: this would be weird...
686                 break;
687         // LordHavoc: no collisions
688         case SOLID_NOT:
689         case SOLID_TRIGGER:
690                 VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
691                 VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
692                 pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
693                 pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
694                 pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
695                 pusher->fields.server->ltime += movetime;
696                 SV_LinkEdict (pusher, false);
697                 return;
698         default:
699                 Con_Printf("SV_PushMove: entity #%i, unrecognized solid type %f\n", PRVM_NUM_FOR_EDICT(pusher), pusher->fields.server->solid);
700                 return;
701         }
702         index = (int) pusher->fields.server->modelindex;
703         if (index < 1 || index >= MAX_MODELS)
704         {
705                 Con_Printf("SV_PushMove: entity #%i has an invalid modelindex %f\n", PRVM_NUM_FOR_EDICT(pusher), pusher->fields.server->modelindex);
706                 return;
707         }
708         pushermodel = sv.models[index];
709
710         movetime2 = movetime;
711         VectorScale(pusher->fields.server->velocity, movetime2, move1);
712         VectorScale(pusher->fields.server->avelocity, movetime2, moveangle);
713         if (moveangle[0] || moveangle[2])
714         {
715                 for (i = 0;i < 3;i++)
716                 {
717                         if (move1[i] > 0)
718                         {
719                                 mins[i] = pushermodel->rotatedmins[i] + pusher->fields.server->origin[i] - 1;
720                                 maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
721                         }
722                         else
723                         {
724                                 mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
725                                 maxs[i] = pushermodel->rotatedmaxs[i] + pusher->fields.server->origin[i] + 1;
726                         }
727                 }
728         }
729         else if (moveangle[1])
730         {
731                 for (i = 0;i < 3;i++)
732                 {
733                         if (move1[i] > 0)
734                         {
735                                 mins[i] = pushermodel->yawmins[i] + pusher->fields.server->origin[i] - 1;
736                                 maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
737                         }
738                         else
739                         {
740                                 mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
741                                 maxs[i] = pushermodel->yawmaxs[i] + pusher->fields.server->origin[i] + 1;
742                         }
743                 }
744         }
745         else
746         {
747                 for (i = 0;i < 3;i++)
748                 {
749                         if (move1[i] > 0)
750                         {
751                                 mins[i] = pushermodel->normalmins[i] + pusher->fields.server->origin[i] - 1;
752                                 maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
753                         }
754                         else
755                         {
756                                 mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
757                                 maxs[i] = pushermodel->normalmaxs[i] + pusher->fields.server->origin[i] + 1;
758                         }
759                 }
760         }
761
762         VectorNegate (moveangle, a);
763         AngleVectorsFLU (a, forward, left, up);
764
765         VectorCopy (pusher->fields.server->origin, pushorig);
766         VectorCopy (pusher->fields.server->angles, pushang);
767         pushltime = pusher->fields.server->ltime;
768
769 // move the pusher to its final position
770
771         VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
772         VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
773         pusher->fields.server->ltime += movetime;
774         SV_LinkEdict (pusher, false);
775
776         savesolid = pusher->fields.server->solid;
777
778 // see if any solid entities are inside the final position
779         num_moved = 0;
780
781         numcheckentities = SV_EntitiesInBox(mins, maxs, MAX_EDICTS, checkentities);
782         for (e = 0;e < numcheckentities;e++)
783         {
784                 prvm_edict_t *check = checkentities[e];
785                 if (check->fields.server->movetype == MOVETYPE_NONE
786                  || check->fields.server->movetype == MOVETYPE_PUSH
787                  || check->fields.server->movetype == MOVETYPE_FOLLOW
788                  || check->fields.server->movetype == MOVETYPE_NOCLIP
789                  || check->fields.server->movetype == MOVETYPE_FAKEPUSH)
790                         continue;
791
792                 // if the entity is standing on the pusher, it will definitely be moved
793                 if (((int)check->fields.server->flags & FL_ONGROUND) && PRVM_PROG_TO_EDICT(check->fields.server->groundentity) == pusher)
794                 {
795                         // remove the onground flag for non-players
796                         if (check->fields.server->movetype != MOVETYPE_WALK)
797                                 check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
798                 }
799                 else
800                 {
801                         // if the entity is not inside the pusher's final position, leave it alone
802                         if (!SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY).startsolid)
803                                 continue;
804                 }
805
806
807                 if (forward[0] != 1 || left[1] != 1) // quick way to check if any rotation is used
808                 {
809                         vec3_t org2;
810                         VectorSubtract (check->fields.server->origin, pusher->fields.server->origin, org);
811                         org2[0] = DotProduct (org, forward);
812                         org2[1] = DotProduct (org, left);
813                         org2[2] = DotProduct (org, up);
814                         VectorSubtract (org2, org, move);
815                         VectorAdd (move, move1, move);
816                 }
817                 else
818                         VectorCopy (move1, move);
819
820                 VectorCopy (check->fields.server->origin, check->priv.server->moved_from);
821                 VectorCopy (check->fields.server->angles, check->priv.server->moved_fromangles);
822                 sv.moved_edicts[num_moved++] = check;
823
824                 // try moving the contacted entity
825                 pusher->fields.server->solid = SOLID_NOT;
826                 trace = SV_PushEntity (check, move, true);
827                 // FIXME: turn players specially
828                 check->fields.server->angles[1] += trace.fraction * moveangle[1];
829                 pusher->fields.server->solid = savesolid; // was SOLID_BSP
830                 //Con_Printf("%s:%d frac %f startsolid %d bmodelstartsolid %d allsolid %d\n", __FILE__, __LINE__, trace.fraction, trace.startsolid, trace.bmodelstartsolid, trace.allsolid);
831
832                 // if it is still inside the pusher, block
833                 if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY).startsolid)
834                 {
835                         // try moving the contacted entity a tiny bit further to account for precision errors
836                         vec3_t move2;
837                         pusher->fields.server->solid = SOLID_NOT;
838                         VectorScale(move, 1.1, move2);
839                         VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
840                         VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
841                         SV_PushEntity (check, move2, true);
842                         pusher->fields.server->solid = savesolid;
843                         if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY).startsolid)
844                         {
845                                 // try moving the contacted entity a tiny bit less to account for precision errors
846                                 pusher->fields.server->solid = SOLID_NOT;
847                                 VectorScale(move, 0.9, move2);
848                                 VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
849                                 VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
850                                 SV_PushEntity (check, move2, true);
851                                 pusher->fields.server->solid = savesolid;
852                                 if (SV_ClipMoveToEntity(pusher, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, 0, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY).startsolid)
853                                 {
854                                         // still inside pusher, so it's really blocked
855
856                                         // fail the move
857                                         if (check->fields.server->mins[0] == check->fields.server->maxs[0])
858                                                 continue;
859                                         if (check->fields.server->solid == SOLID_NOT || check->fields.server->solid == SOLID_TRIGGER)
860                                         {
861                                                 // corpse
862                                                 check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
863                                                 VectorCopy (check->fields.server->mins, check->fields.server->maxs);
864                                                 continue;
865                                         }
866
867                                         VectorCopy (pushorig, pusher->fields.server->origin);
868                                         VectorCopy (pushang, pusher->fields.server->angles);
869                                         pusher->fields.server->ltime = pushltime;
870                                         SV_LinkEdict (pusher, false);
871
872                                         // move back any entities we already moved
873                                         for (i = 0;i < num_moved;i++)
874                                         {
875                                                 prvm_edict_t *ed = sv.moved_edicts[i];
876                                                 VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
877                                                 VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
878                                                 SV_LinkEdict (ed, false);
879                                         }
880
881                                         // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
882                                         if (pusher->fields.server->blocked)
883                                         {
884                                                 prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
885                                                 prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
886                                                 PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
887                                         }
888                                         break;
889                                 }
890                         }
891                 }
892         }
893         pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
894         pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
895         pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
896 }
897
898 /*
899 ================
900 SV_Physics_Pusher
901
902 ================
903 */
904 void SV_Physics_Pusher (prvm_edict_t *ent)
905 {
906         float thinktime, oldltime, movetime;
907
908         oldltime = ent->fields.server->ltime;
909
910         thinktime = ent->fields.server->nextthink;
911         if (thinktime < ent->fields.server->ltime + sv.frametime)
912         {
913                 movetime = thinktime - ent->fields.server->ltime;
914                 if (movetime < 0)
915                         movetime = 0;
916         }
917         else
918                 movetime = sv.frametime;
919
920         if (movetime)
921                 // advances ent->fields.server->ltime if not blocked
922                 SV_PushMove (ent, movetime);
923
924         if (thinktime > oldltime && thinktime <= ent->fields.server->ltime)
925         {
926                 ent->fields.server->nextthink = 0;
927                 prog->globals.server->time = sv.time;
928                 prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
929                 prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
930                 PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
931         }
932 }
933
934
935 /*
936 ===============================================================================
937
938 CLIENT MOVEMENT
939
940 ===============================================================================
941 */
942
943 /*
944 =============
945 SV_CheckStuck
946
947 This is a big hack to try and fix the rare case of getting stuck in the world
948 clipping hull.
949 =============
950 */
951 void SV_CheckStuck (prvm_edict_t *ent)
952 {
953         int i, j, z;
954         vec3_t org;
955
956         if (!SV_TestEntityPosition(ent))
957         {
958                 VectorCopy (ent->fields.server->origin, ent->fields.server->oldorigin);
959                 return;
960         }
961
962         VectorCopy (ent->fields.server->origin, org);
963         VectorCopy (ent->fields.server->oldorigin, ent->fields.server->origin);
964         if (!SV_TestEntityPosition(ent))
965         {
966                 Con_DPrintf("Unstuck player entity %i (classname \"%s\") by restoring oldorigin.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
967                 SV_LinkEdict (ent, true);
968                 return;
969         }
970
971         for (z=-1 ; z< 18 ; z++)
972                 for (i=-1 ; i <= 1 ; i++)
973                         for (j=-1 ; j <= 1 ; j++)
974                         {
975                                 ent->fields.server->origin[0] = org[0] + i;
976                                 ent->fields.server->origin[1] = org[1] + j;
977                                 ent->fields.server->origin[2] = org[2] + z;
978                                 if (!SV_TestEntityPosition(ent))
979                                 {
980                                         Con_DPrintf("Unstuck player entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname), (float)i, (float)j, (float)z);
981                                         SV_LinkEdict (ent, true);
982                                         return;
983                                 }
984                         }
985
986         VectorCopy (org, ent->fields.server->origin);
987         Con_DPrintf("Stuck player entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
988 }
989
990 static void SV_UnstickEntity (prvm_edict_t *ent)
991 {
992         int i, j, z;
993         vec3_t org;
994
995         // if not stuck in a bmodel, just return
996         if (!SV_TestEntityPosition(ent))
997                 return;
998
999         VectorCopy (ent->fields.server->origin, org);
1000
1001         for (z=-1 ; z< 18 ; z += 6)
1002                 for (i=-1 ; i <= 1 ; i++)
1003                         for (j=-1 ; j <= 1 ; j++)
1004                         {
1005                                 ent->fields.server->origin[0] = org[0] + i;
1006                                 ent->fields.server->origin[1] = org[1] + j;
1007                                 ent->fields.server->origin[2] = org[2] + z;
1008                                 if (!SV_TestEntityPosition(ent))
1009                                 {
1010                                         Con_DPrintf("Unstuck entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname), (float)i, (float)j, (float)z);
1011                                         SV_LinkEdict (ent, true);
1012                                         return;
1013                                 }
1014                         }
1015
1016         VectorCopy (org, ent->fields.server->origin);
1017         if (developer.integer >= 100)
1018                 Con_Printf("Stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
1019 }
1020
1021
1022 /*
1023 =============
1024 SV_CheckWater
1025 =============
1026 */
1027 qboolean SV_CheckWater (prvm_edict_t *ent)
1028 {
1029         int cont;
1030         int nNativeContents;
1031         vec3_t point;
1032
1033         point[0] = ent->fields.server->origin[0];
1034         point[1] = ent->fields.server->origin[1];
1035         point[2] = ent->fields.server->origin[2] + ent->fields.server->mins[2] + 1;
1036
1037         // DRESK - Support for Entity Contents Transition Event
1038         // NOTE: Some logic needed to be slightly re-ordered
1039         // to not affect performance and allow for the feature.
1040
1041         // Acquire Super Contents Prior to Resets
1042         cont = SV_PointSuperContents(point);
1043         // Acquire Native Contents Here
1044         nNativeContents = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, cont);
1045
1046         // DRESK - Support for Entity Contents Transition Event
1047         if(ent->fields.server->watertype)
1048                 // Entity did NOT Spawn; Check
1049                 SV_CheckContentsTransition(ent, nNativeContents);
1050
1051
1052         ent->fields.server->waterlevel = 0;
1053         ent->fields.server->watertype = CONTENTS_EMPTY;
1054         cont = SV_PointSuperContents(point);
1055         if (cont & (SUPERCONTENTS_LIQUIDSMASK))
1056         {
1057                 ent->fields.server->watertype = nNativeContents;
1058                 ent->fields.server->waterlevel = 1;
1059                 point[2] = ent->fields.server->origin[2] + (ent->fields.server->mins[2] + ent->fields.server->maxs[2])*0.5;
1060                 if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
1061                 {
1062                         ent->fields.server->waterlevel = 2;
1063                         point[2] = ent->fields.server->origin[2] + ent->fields.server->view_ofs[2];
1064                         if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
1065                                 ent->fields.server->waterlevel = 3;
1066                 }
1067         }
1068
1069         return ent->fields.server->waterlevel > 1;
1070 }
1071
1072 /*
1073 ============
1074 SV_WallFriction
1075
1076 ============
1077 */
1078 void SV_WallFriction (prvm_edict_t *ent, float *stepnormal)
1079 {
1080         float d, i;
1081         vec3_t forward, into, side;
1082
1083         AngleVectors (ent->fields.server->v_angle, forward, NULL, NULL);
1084         if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
1085         {
1086                 // cut the tangential velocity
1087                 i = DotProduct (stepnormal, ent->fields.server->velocity);
1088                 VectorScale (stepnormal, i, into);
1089                 VectorSubtract (ent->fields.server->velocity, into, side);
1090                 ent->fields.server->velocity[0] = side[0] * (1 + d);
1091                 ent->fields.server->velocity[1] = side[1] * (1 + d);
1092         }
1093 }
1094
1095 /*
1096 =====================
1097 SV_TryUnstick
1098
1099 Player has come to a dead stop, possibly due to the problem with limited
1100 float precision at some angle joins in the BSP hull.
1101
1102 Try fixing by pushing one pixel in each direction.
1103
1104 This is a hack, but in the interest of good gameplay...
1105 ======================
1106 */
1107 int SV_TryUnstick (prvm_edict_t *ent, vec3_t oldvel)
1108 {
1109         int i, clip;
1110         vec3_t oldorg, dir;
1111
1112         VectorCopy (ent->fields.server->origin, oldorg);
1113         VectorClear (dir);
1114
1115         for (i=0 ; i<8 ; i++)
1116         {
1117                 // try pushing a little in an axial direction
1118                 switch (i)
1119                 {
1120                         case 0: dir[0] = 2; dir[1] = 0; break;
1121                         case 1: dir[0] = 0; dir[1] = 2; break;
1122                         case 2: dir[0] = -2; dir[1] = 0; break;
1123                         case 3: dir[0] = 0; dir[1] = -2; break;
1124                         case 4: dir[0] = 2; dir[1] = 2; break;
1125                         case 5: dir[0] = -2; dir[1] = 2; break;
1126                         case 6: dir[0] = 2; dir[1] = -2; break;
1127                         case 7: dir[0] = -2; dir[1] = -2; break;
1128                 }
1129
1130                 SV_PushEntity (ent, dir, false);
1131
1132                 // retry the original move
1133                 ent->fields.server->velocity[0] = oldvel[0];
1134                 ent->fields.server->velocity[1] = oldvel[1];
1135                 ent->fields.server->velocity[2] = 0;
1136                 clip = SV_FlyMove (ent, 0.1, NULL);
1137
1138                 if (fabs(oldorg[1] - ent->fields.server->origin[1]) > 4
1139                  || fabs(oldorg[0] - ent->fields.server->origin[0]) > 4)
1140                 {
1141                         Con_DPrint("TryUnstick - success.\n");
1142                         return clip;
1143                 }
1144
1145                 // go back to the original pos and try again
1146                 VectorCopy (oldorg, ent->fields.server->origin);
1147         }
1148
1149         // still not moving
1150         VectorClear (ent->fields.server->velocity);
1151         Con_DPrint("TryUnstick - failure.\n");
1152         return 7;
1153 }
1154
1155 /*
1156 =====================
1157 SV_WalkMove
1158
1159 Only used by players
1160 ======================
1161 */
1162 void SV_WalkMove (prvm_edict_t *ent)
1163 {
1164         int clip, oldonground, originalmove_clip, originalmove_flags, originalmove_groundentity;
1165         vec3_t upmove, downmove, start_origin, start_velocity, stepnormal, originalmove_origin, originalmove_velocity;
1166         trace_t downtrace;
1167
1168         SV_CheckVelocity(ent);
1169
1170         // do a regular slide move unless it looks like you ran into a step
1171         oldonground = (int)ent->fields.server->flags & FL_ONGROUND;
1172         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
1173
1174         VectorCopy (ent->fields.server->origin, start_origin);
1175         VectorCopy (ent->fields.server->velocity, start_velocity);
1176
1177         clip = SV_FlyMove (ent, sv.frametime, NULL);
1178
1179         SV_CheckVelocity(ent);
1180
1181         VectorCopy(ent->fields.server->origin, originalmove_origin);
1182         VectorCopy(ent->fields.server->velocity, originalmove_velocity);
1183         originalmove_clip = clip;
1184         originalmove_flags = (int)ent->fields.server->flags;
1185         originalmove_groundentity = ent->fields.server->groundentity;
1186
1187         if ((int)ent->fields.server->flags & FL_WATERJUMP)
1188                 return;
1189
1190         if (sv_nostep.integer)
1191                 return;
1192
1193         // if move didn't block on a step, return
1194         if (clip & 2)
1195         {
1196                 // if move was not trying to move into the step, return
1197                 if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
1198                         return;
1199
1200                 if (ent->fields.server->movetype != MOVETYPE_FLY)
1201                 {
1202                         // return if gibbed by a trigger
1203                         if (ent->fields.server->movetype != MOVETYPE_WALK)
1204                                 return;
1205
1206                         // only step up while jumping if that is enabled
1207                         if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))
1208                                 if (!oldonground && ent->fields.server->waterlevel == 0)
1209                                         return;
1210                 }
1211
1212                 // try moving up and forward to go up a step
1213                 // back to start pos
1214                 VectorCopy (start_origin, ent->fields.server->origin);
1215                 VectorCopy (start_velocity, ent->fields.server->velocity);
1216
1217                 // move up
1218                 VectorClear (upmove);
1219                 upmove[2] = sv_stepheight.value;
1220                 // FIXME: don't link?
1221                 SV_PushEntity(ent, upmove, false);
1222
1223                 // move forward
1224                 ent->fields.server->velocity[2] = 0;
1225                 clip = SV_FlyMove (ent, sv.frametime, stepnormal);
1226                 ent->fields.server->velocity[2] += start_velocity[2];
1227
1228                 SV_CheckVelocity(ent);
1229
1230                 // check for stuckness, possibly due to the limited precision of floats
1231                 // in the clipping hulls
1232                 if (clip
1233                  && fabs(originalmove_origin[1] - ent->fields.server->origin[1]) < 0.03125
1234                  && fabs(originalmove_origin[0] - ent->fields.server->origin[0]) < 0.03125)
1235                 {
1236                         //Con_Printf("wall\n");
1237                         // stepping up didn't make any progress, revert to original move
1238                         VectorCopy(originalmove_origin, ent->fields.server->origin);
1239                         VectorCopy(originalmove_velocity, ent->fields.server->velocity);
1240                         //clip = originalmove_clip;
1241                         ent->fields.server->flags = originalmove_flags;
1242                         ent->fields.server->groundentity = originalmove_groundentity;
1243                         // now try to unstick if needed
1244                         //clip = SV_TryUnstick (ent, oldvel);
1245                         return;
1246                 }
1247
1248                 //Con_Printf("step - ");
1249
1250                 // extra friction based on view angle
1251                 if (clip & 2 && sv_wallfriction.integer)
1252                         SV_WallFriction (ent, stepnormal);
1253         }
1254         // skip out if stepdown is enabled, moving downward, not in water, and the move started onground and ended offground
1255         else if (!(sv_gameplayfix_stepdown.integer && ent->fields.server->waterlevel < 2 && start_velocity[2] < (1.0 / 32.0) && oldonground && !((int)ent->fields.server->flags & FL_ONGROUND)))
1256                 return;
1257
1258         // move down
1259         VectorClear (downmove);
1260         downmove[2] = -sv_stepheight.value + start_velocity[2]*sv.frametime;
1261         // FIXME: don't link?
1262         downtrace = SV_PushEntity (ent, downmove, false);
1263
1264         if (downtrace.fraction < 1 && downtrace.plane.normal[2] > 0.7)
1265         {
1266                 // this has been disabled so that you can't jump when you are stepping
1267                 // up while already jumping (also known as the Quake2 stair jump bug)
1268 #if 0
1269                 // LordHavoc: disabled this check so you can walk on monsters/players
1270                 //if (ent->fields.server->solid == SOLID_BSP)
1271                 {
1272                         //Con_Printf("onground\n");
1273                         ent->fields.server->flags =     (int)ent->fields.server->flags | FL_ONGROUND;
1274                         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(downtrace.ent);
1275                 }
1276 #endif
1277         }
1278         else
1279         {
1280                 //Con_Printf("slope\n");
1281                 // if the push down didn't end up on good ground, use the move without
1282                 // the step up.  This happens near wall / slope combinations, and can
1283                 // cause the player to hop up higher on a slope too steep to climb
1284                 VectorCopy(originalmove_origin, ent->fields.server->origin);
1285                 VectorCopy(originalmove_velocity, ent->fields.server->velocity);
1286                 //clip = originalmove_clip;
1287                 ent->fields.server->flags = originalmove_flags;
1288                 ent->fields.server->groundentity = originalmove_groundentity;
1289         }
1290
1291         SV_CheckVelocity(ent);
1292 }
1293
1294 //============================================================================
1295
1296 /*
1297 =============
1298 SV_Physics_Follow
1299
1300 Entities that are "stuck" to another entity
1301 =============
1302 */
1303 void SV_Physics_Follow (prvm_edict_t *ent)
1304 {
1305         vec3_t vf, vr, vu, angles, v;
1306         prvm_edict_t *e;
1307
1308         // regular thinking
1309         if (!SV_RunThink (ent))
1310                 return;
1311
1312         // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
1313         e = PRVM_PROG_TO_EDICT(ent->fields.server->aiment);
1314         if (e->fields.server->angles[0] == ent->fields.server->punchangle[0] && e->fields.server->angles[1] == ent->fields.server->punchangle[1] && e->fields.server->angles[2] == ent->fields.server->punchangle[2])
1315         {
1316                 // quick case for no rotation
1317                 VectorAdd(e->fields.server->origin, ent->fields.server->view_ofs, ent->fields.server->origin);
1318         }
1319         else
1320         {
1321                 angles[0] = -ent->fields.server->punchangle[0];
1322                 angles[1] =  ent->fields.server->punchangle[1];
1323                 angles[2] =  ent->fields.server->punchangle[2];
1324                 AngleVectors (angles, vf, vr, vu);
1325                 v[0] = ent->fields.server->view_ofs[0] * vf[0] + ent->fields.server->view_ofs[1] * vr[0] + ent->fields.server->view_ofs[2] * vu[0];
1326                 v[1] = ent->fields.server->view_ofs[0] * vf[1] + ent->fields.server->view_ofs[1] * vr[1] + ent->fields.server->view_ofs[2] * vu[1];
1327                 v[2] = ent->fields.server->view_ofs[0] * vf[2] + ent->fields.server->view_ofs[1] * vr[2] + ent->fields.server->view_ofs[2] * vu[2];
1328                 angles[0] = -e->fields.server->angles[0];
1329                 angles[1] =  e->fields.server->angles[1];
1330                 angles[2] =  e->fields.server->angles[2];
1331                 AngleVectors (angles, vf, vr, vu);
1332                 ent->fields.server->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->fields.server->origin[0];
1333                 ent->fields.server->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->fields.server->origin[1];
1334                 ent->fields.server->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->fields.server->origin[2];
1335         }
1336         VectorAdd (e->fields.server->angles, ent->fields.server->v_angle, ent->fields.server->angles);
1337         SV_LinkEdict (ent, true);
1338 }
1339
1340 /*
1341 ==============================================================================
1342
1343 TOSS / BOUNCE
1344
1345 ==============================================================================
1346 */
1347
1348 /*
1349 =============
1350 SV_CheckWaterTransition
1351
1352 =============
1353 */
1354 void SV_CheckWaterTransition (prvm_edict_t *ent)
1355 {
1356         int cont;
1357         cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(ent->fields.server->origin));
1358         if (!ent->fields.server->watertype)
1359         {
1360                 // just spawned here
1361                 ent->fields.server->watertype = cont;
1362                 ent->fields.server->waterlevel = 1;
1363                 return;
1364         }
1365
1366         // DRESK - Support for Entity Contents Transition Event
1367         // NOTE: Call here BEFORE updating the watertype below,
1368         // and suppress watersplash sound if a valid function
1369         // call was made to allow for custom "splash" sounds.
1370         if( !SV_CheckContentsTransition(ent, cont) )
1371         { // Contents Transition Function Invalid; Potentially Play Water Sound
1372                 // check if the entity crossed into or out of water
1373                 if (sv_sound_watersplash.string && ((ent->fields.server->watertype == CONTENTS_WATER || ent->fields.server->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME)))
1374                         SV_StartSound (ent, 0, sv_sound_watersplash.string, 255, 1);
1375         }
1376
1377         if (cont <= CONTENTS_WATER)
1378         {
1379                 ent->fields.server->watertype = cont;
1380                 ent->fields.server->waterlevel = 1;
1381         }
1382         else
1383         {
1384                 ent->fields.server->watertype = CONTENTS_EMPTY;
1385                 ent->fields.server->waterlevel = 0;
1386         }
1387 }
1388
1389 /*
1390 =============
1391 SV_Physics_Toss
1392
1393 Toss, bounce, and fly movement.  When onground, do nothing.
1394 =============
1395 */
1396 void SV_Physics_Toss (prvm_edict_t *ent)
1397 {
1398         trace_t trace;
1399         vec3_t move;
1400
1401 // if onground, return without moving
1402         if ((int)ent->fields.server->flags & FL_ONGROUND)
1403         {
1404                 if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)
1405                 {
1406                         // don't stick to ground if onground and moving upward
1407                         ent->fields.server->flags -= FL_ONGROUND;
1408                 }
1409                 else if (!ent->fields.server->groundentity || !sv_gameplayfix_noairborncorpse.integer)
1410                 {
1411                         // we can trust FL_ONGROUND if groundentity is world because it never moves
1412                         return;
1413                 }
1414                 else if (ent->priv.server->suspendedinairflag && PRVM_PROG_TO_EDICT(ent->fields.server->groundentity)->priv.server->free)
1415                 {
1416                         // if ent was supported by a brush model on previous frame,
1417                         // and groundentity is now freed, set groundentity to 0 (world)
1418                         // which leaves it suspended in the air
1419                         ent->fields.server->groundentity = 0;
1420                         return;
1421                 }
1422         }
1423         ent->priv.server->suspendedinairflag = false;
1424
1425         SV_CheckVelocity (ent);
1426
1427 // add gravity
1428         if (ent->fields.server->movetype == MOVETYPE_TOSS || ent->fields.server->movetype == MOVETYPE_BOUNCE)
1429                 SV_AddGravity (ent);
1430
1431 // move angles
1432         VectorMA (ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
1433
1434 // move origin
1435         VectorScale (ent->fields.server->velocity, sv.frametime, move);
1436         trace = SV_PushEntity (ent, move, true);
1437         if (ent->priv.server->free)
1438                 return;
1439         if (trace.bmodelstartsolid)
1440         {
1441                 // try to unstick the entity
1442                 SV_UnstickEntity(ent);
1443                 trace = SV_PushEntity (ent, move, false);
1444                 if (ent->priv.server->free)
1445                         return;
1446         }
1447
1448         if (trace.fraction < 1)
1449         {
1450                 if (ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE)
1451                 {
1452                         ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 2.0);
1453                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
1454                 }
1455                 else if (ent->fields.server->movetype == MOVETYPE_BOUNCE)
1456                 {
1457                         float d;
1458                         ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1.5);
1459                         // LordHavoc: fixed grenades not bouncing when fired down a slope
1460                         if (sv_gameplayfix_grenadebouncedownslopes.integer)
1461                         {
1462                                 d = DotProduct(trace.plane.normal, ent->fields.server->velocity);
1463                                 if (trace.plane.normal[2] > 0.7 && fabs(d) < 60)
1464                                 {
1465                                         ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
1466                                         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
1467                                         VectorClear (ent->fields.server->velocity);
1468                                         VectorClear (ent->fields.server->avelocity);
1469                                 }
1470                                 else
1471                                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
1472                         }
1473                         else
1474                         {
1475                                 if (trace.plane.normal[2] > 0.7 && ent->fields.server->velocity[2] < 60)
1476                                 {
1477                                         ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
1478                                         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
1479                                         VectorClear (ent->fields.server->velocity);
1480                                         VectorClear (ent->fields.server->avelocity);
1481                                 }
1482                                 else
1483                                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
1484                         }
1485                 }
1486                 else
1487                 {
1488                         ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1.0);
1489                         if (trace.plane.normal[2] > 0.7)
1490                         {
1491                                 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
1492                                 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
1493                                 if (((prvm_edict_t *)trace.ent)->fields.server->solid == SOLID_BSP)
1494                                         ent->priv.server->suspendedinairflag = true;
1495                                 VectorClear (ent->fields.server->velocity);
1496                                 VectorClear (ent->fields.server->avelocity);
1497                         }
1498                         else
1499                                 ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
1500                 }
1501         }
1502
1503 // check for in water
1504         SV_CheckWaterTransition (ent);
1505 }
1506
1507 /*
1508 ===============================================================================
1509
1510 STEPPING MOVEMENT
1511
1512 ===============================================================================
1513 */
1514
1515 /*
1516 =============
1517 SV_Physics_Step
1518
1519 Monsters freefall when they don't have a ground entity, otherwise
1520 all movement is done with discrete steps.
1521
1522 This is also used for objects that have become still on the ground, but
1523 will fall if the floor is pulled out from under them.
1524 =============
1525 */
1526 void SV_Physics_Step (prvm_edict_t *ent)
1527 {
1528         int flags = (int)ent->fields.server->flags;
1529         // don't fall at all if fly/swim
1530         if (!(flags & (FL_FLY | FL_SWIM)))
1531         {
1532                 if (flags & FL_ONGROUND)
1533                 {
1534                         // freefall if onground and moving upward
1535                         // freefall if not standing on a world surface (it may be a lift or trap door)
1536                         if ((ent->fields.server->velocity[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer) || ent->fields.server->groundentity)
1537                         {
1538                                 ent->fields.server->flags -= FL_ONGROUND;
1539                                 SV_AddGravity(ent);
1540                                 SV_CheckVelocity(ent);
1541                                 SV_FlyMove(ent, sv.frametime, NULL);
1542                                 SV_LinkEdict(ent, true);
1543                         }
1544                 }
1545                 else
1546                 {
1547                         // freefall if not onground
1548                         int hitsound = ent->fields.server->velocity[2] < sv_gravity.value * -0.1;
1549
1550                         SV_AddGravity(ent);
1551                         SV_CheckVelocity(ent);
1552                         SV_FlyMove(ent, sv.frametime, NULL);
1553                         SV_LinkEdict(ent, true);
1554
1555                         // just hit ground
1556                         if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND && sv_sound_land.string)
1557                                 SV_StartSound(ent, 0, sv_sound_land.string, 255, 1);
1558                 }
1559         }
1560
1561 // regular thinking
1562         SV_RunThink(ent);
1563
1564         SV_CheckWaterTransition(ent);
1565 }
1566
1567 //============================================================================
1568
1569 static void SV_Physics_Entity (prvm_edict_t *ent)
1570 {
1571         // don't run a move on newly spawned projectiles as it messes up movement
1572         // interpolation and rocket trails
1573         qboolean runmove = ent->priv.server->move;
1574         ent->priv.server->move = true;
1575         switch ((int) ent->fields.server->movetype)
1576         {
1577         case MOVETYPE_PUSH:
1578         case MOVETYPE_FAKEPUSH:
1579                 SV_Physics_Pusher (ent);
1580                 break;
1581         case MOVETYPE_NONE:
1582                 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1583                 if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
1584                         SV_RunThink (ent);
1585                 break;
1586         case MOVETYPE_FOLLOW:
1587                 SV_Physics_Follow (ent);
1588                 break;
1589         case MOVETYPE_NOCLIP:
1590                 if (SV_RunThink(ent))
1591                 {
1592                         SV_CheckWater(ent);
1593                         VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
1594                         VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
1595                 }
1596                 SV_LinkEdict(ent, false);
1597                 break;
1598         case MOVETYPE_STEP:
1599                 SV_Physics_Step (ent);
1600                 break;
1601         case MOVETYPE_WALK:
1602                 if (SV_RunThink (ent))
1603                 {
1604                         if (!SV_CheckWater (ent) && ! ((int)ent->fields.server->flags & FL_WATERJUMP) )
1605                                 SV_AddGravity (ent);
1606                         SV_CheckStuck (ent);
1607                         SV_WalkMove (ent);
1608                         SV_LinkEdict (ent, true);
1609                 }
1610                 break;
1611         case MOVETYPE_TOSS:
1612         case MOVETYPE_BOUNCE:
1613         case MOVETYPE_BOUNCEMISSILE:
1614         case MOVETYPE_FLYMISSILE:
1615         case MOVETYPE_FLY:
1616                 // regular thinking
1617                 if (SV_RunThink (ent) && runmove)
1618                         SV_Physics_Toss (ent);
1619                 break;
1620         default:
1621                 Con_Printf ("SV_Physics: bad movetype %i\n", (int)ent->fields.server->movetype);
1622                 break;
1623         }
1624 }
1625
1626 void SV_Physics_ClientEntity (prvm_edict_t *ent)
1627 {
1628         SV_ApplyClientMove();
1629         // make sure the velocity is sane (not a NaN)
1630         SV_CheckVelocity(ent);
1631         // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
1632         if (SV_PlayerPhysicsQC && sv_playerphysicsqc.integer)
1633         {
1634                 prog->globals.server->time = sv.time;
1635                 prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
1636                 PRVM_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - prog->functions), "QC function SV_PlayerPhysics is missing");
1637         }
1638         else
1639                 SV_ClientThink ();
1640         // make sure the velocity is sane (not a NaN)
1641         SV_CheckVelocity(ent);
1642         // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
1643         // player_run/player_stand1 does not horribly malfunction if the
1644         // velocity becomes a number that is both == 0 and != 0
1645         // (sounds to me like NaN but to be absolutely safe...)
1646         if (DotProduct(ent->fields.server->velocity, ent->fields.server->velocity) < 0.0001)
1647                 VectorClear(ent->fields.server->velocity);
1648         // call standard client pre-think
1649         prog->globals.server->time = sv.time;
1650         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
1651         PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
1652         SV_CheckVelocity (ent);
1653
1654         switch ((int) ent->fields.server->movetype)
1655         {
1656         case MOVETYPE_PUSH:
1657         case MOVETYPE_FAKEPUSH:
1658                 SV_Physics_Pusher (ent);
1659                 break;
1660         case MOVETYPE_NONE:
1661                 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
1662                 if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
1663                         SV_RunThink (ent);
1664                 break;
1665         case MOVETYPE_FOLLOW:
1666                 SV_Physics_Follow (ent);
1667                 break;
1668         case MOVETYPE_NOCLIP:
1669                 if (SV_RunThink(ent))
1670                 {
1671                         SV_CheckWater(ent);
1672                         VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
1673                         VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
1674                 }
1675                 break;
1676         case MOVETYPE_STEP:
1677                 SV_Physics_Step (ent);
1678                 break;
1679         case MOVETYPE_WALK:
1680                 if (SV_RunThink (ent))
1681                 {
1682                         if (!SV_CheckWater (ent) && ! ((int)ent->fields.server->flags & FL_WATERJUMP) )
1683                                 SV_AddGravity (ent);
1684                         SV_CheckStuck (ent);
1685                         SV_WalkMove (ent);
1686                 }
1687                 break;
1688         case MOVETYPE_TOSS:
1689         case MOVETYPE_BOUNCE:
1690         case MOVETYPE_BOUNCEMISSILE:
1691         case MOVETYPE_FLYMISSILE:
1692                 // regular thinking
1693                 if (SV_RunThink (ent))
1694                         SV_Physics_Toss (ent);
1695                 break;
1696         case MOVETYPE_FLY:
1697                 if (SV_RunThink (ent))
1698                 {
1699                         SV_CheckWater (ent);
1700                         SV_WalkMove (ent);
1701                 }
1702                 break;
1703         default:
1704                 Con_Printf ("SV_Physics_ClientEntity: bad movetype %i\n", (int)ent->fields.server->movetype);
1705                 break;
1706         }
1707
1708         SV_CheckVelocity (ent);
1709
1710         // call standard player post-think
1711         SV_LinkEdict (ent, true);
1712
1713         SV_CheckVelocity (ent);
1714
1715         prog->globals.server->time = sv.time;
1716         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
1717         PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
1718 }
1719
1720 /*
1721 ================
1722 SV_Physics
1723
1724 ================
1725 */
1726 void SV_Physics (void)
1727 {
1728         int i;
1729         prvm_edict_t *ent;
1730
1731 // let the progs know that a new frame has started
1732         prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
1733         prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
1734         prog->globals.server->time = sv.time;
1735         prog->globals.server->frametime = sv.frametime;
1736         PRVM_ExecuteProgram (prog->globals.server->StartFrame, "QC function StartFrame is missing");
1737
1738 //
1739 // treat each object in turn
1740 //
1741
1742         // if force_retouch, relink all the entities
1743         if (prog->globals.server->force_retouch > 0)
1744                 for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1745                         if (!ent->priv.server->free)
1746                                 SV_LinkEdict (ent, true);       // force retouch even for stationary
1747
1748         // run physics on the client entities
1749         for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
1750         {
1751                 if (!ent->priv.server->free)
1752                 {
1753                         // don't do physics on disconnected clients, FrikBot relies on this
1754                         if (!host_client->spawned)
1755                                 memset(&host_client->cmd, 0, sizeof(host_client->cmd));
1756                         // don't run physics here if running asynchronously
1757                         else if (host_client->clmovement_skipphysicsframes > 0)
1758                                 host_client->clmovement_skipphysicsframes--;
1759                         else
1760                                 SV_Physics_ClientEntity(ent);
1761                 }
1762         }
1763
1764         // run physics on all the non-client entities
1765         if (!sv_freezenonclients.integer)
1766                 for (;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1767                         if (!ent->priv.server->free)
1768                                 SV_Physics_Entity(ent);
1769
1770         if (prog->globals.server->force_retouch > 0)
1771                 prog->globals.server->force_retouch = max(0, prog->globals.server->force_retouch - 1);
1772
1773         // LordHavoc: endframe support
1774         if (EndFrameQC)
1775         {
1776                 prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
1777                 prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
1778                 prog->globals.server->time = sv.time;
1779                 PRVM_ExecuteProgram ((func_t)(EndFrameQC - prog->functions), "QC function EndFrame is missing");
1780         }
1781
1782         // decrement prog->num_edicts if the highest number entities died
1783         for (;PRVM_EDICT_NUM(prog->num_edicts - 1)->priv.server->free;prog->num_edicts--);
1784
1785         if (!sv_freezenonclients.integer)
1786                 sv.time += sv.frametime;
1787 }
1788
1789
1790 trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
1791 {
1792         int i;
1793         float gravity;
1794         vec3_t move, end;
1795         vec3_t original_origin;
1796         vec3_t original_velocity;
1797         vec3_t original_angles;
1798         vec3_t original_avelocity;
1799         prvm_eval_t *val;
1800         trace_t trace;
1801
1802         VectorCopy(tossent->fields.server->origin   , original_origin   );
1803         VectorCopy(tossent->fields.server->velocity , original_velocity );
1804         VectorCopy(tossent->fields.server->angles   , original_angles   );
1805         VectorCopy(tossent->fields.server->avelocity, original_avelocity);
1806
1807         val = PRVM_GETEDICTFIELDVALUE(tossent, eval_gravity);
1808         if (val != NULL && val->_float != 0)
1809                 gravity = val->_float;
1810         else
1811                 gravity = 1.0;
1812         gravity *= sv_gravity.value * 0.05;
1813
1814         for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
1815         {
1816                 SV_CheckVelocity (tossent);
1817                 tossent->fields.server->velocity[2] -= gravity;
1818                 VectorMA (tossent->fields.server->angles, 0.05, tossent->fields.server->avelocity, tossent->fields.server->angles);
1819                 VectorScale (tossent->fields.server->velocity, 0.05, move);
1820                 VectorAdd (tossent->fields.server->origin, move, end);
1821                 trace = SV_Move (tossent->fields.server->origin, tossent->fields.server->mins, tossent->fields.server->maxs, end, MOVE_NORMAL, tossent);
1822                 VectorCopy (trace.endpos, tossent->fields.server->origin);
1823
1824                 if (trace.fraction < 1)
1825                         break;
1826         }
1827
1828         VectorCopy(original_origin   , tossent->fields.server->origin   );
1829         VectorCopy(original_velocity , tossent->fields.server->velocity );
1830         VectorCopy(original_angles   , tossent->fields.server->angles   );
1831         VectorCopy(original_avelocity, tossent->fields.server->avelocity);
1832
1833         return trace;
1834 }
1835