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