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 int SV_GetPitchSign(prvm_edict_t *ent)
  47 {
  48         dp_model_t *model;
  49         if (
  50                         (model = SV_GetModelFromEdict(ent))
  51                         ?
  52                         model->type == mod_alias
  53                         :
  54                         (
  55                          (((unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pflags)->_float) & PFLAGS_FULLDYNAMIC)
  56                          ||
  57                          ((gamemode == GAME_TENEBRAE) && ((unsigned int)ent->fields.server->effects & (16 | 32)))
  58                         )
  59            )
  60                 return -1;
  61         return 1;
  62 }
  63
  64 /*
  65 ===============================================================================
  66
  67 LINE TESTING IN HULLS
  68
  69 ===============================================================================
  70 */
  71
  72 int SV_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
  73 {
  74         prvm_eval_t *val;
  75         if (passedict)
  76         {
  77                 val = PRVM_EDICTFIELDVALUE(passedict, prog->fieldoffsets.dphitcontentsmask);
  78                 if (val && val->_float)
  79                         return (int)val->_float;
  80                 else if (passedict->fields.server->solid == SOLID_SLIDEBOX)
  81                 {
  82                         if ((int)passedict->fields.server->flags & FL_MONSTER)
  83                                 return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_MONSTERCLIP;
  84                         else
  85                                 return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP;
  86                 }
  87                 else if (passedict->fields.server->solid == SOLID_CORPSE)
  88                         return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
  89                 else if (passedict->fields.server->solid == SOLID_TRIGGER)
  90                         return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
  91                 else
  92                         return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;
  93         }
  94         else
  95                 return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;
  96 }
  97
  98 /*
  99 ==================
 100 SV_TracePoint
 101 ==================
 102 */
 103 trace_t SV_TracePoint(const vec3_t start, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 104 {
 105         int i, bodysupercontents;
 106         int passedictprog;
 107         float pitchsign = 1;
 108         prvm_edict_t *traceowner, *touch;
 109         trace_t trace;
 110         // bounding box of entire move area
 111         vec3_t clipboxmins, clipboxmaxs;
 112         // size when clipping against monsters
 113         vec3_t clipmins2, clipmaxs2;
 114         // start and end origin of move
 115         vec3_t clipstart;
 116         // trace results
 117         trace_t cliptrace;
 118         // matrices to transform into/out of other entity's space
 119         matrix4x4_t matrix, imatrix;
 120         // model of other entity
 121         dp_model_t *model;
 122         // list of entities to test for collisions
 123         int numtouchedicts;
 124         static prvm_edict_t *touchedicts[MAX_EDICTS];
 125
 126         //return SV_TraceBox(start, vec3_origin, vec3_origin, end, type, passedict, hitsupercontentsmask);
 127
 128         VectorCopy(start, clipstart);
 129         VectorClear(clipmins2);
 130         VectorClear(clipmaxs2);
 131 #if COLLISIONPARANOID >= 3
 132         Con_Printf("move(%f %f %f)", clipstart[0], clipstart[1], clipstart[2]);
 133 #endif
 134
 135         // clip to world
 136         Collision_ClipPointToWorld(&cliptrace, sv.worldmodel, clipstart, hitsupercontentsmask);
 137         cliptrace.bmodelstartsolid = cliptrace.startsolid;
 138         if (cliptrace.startsolid || cliptrace.fraction < 1)
 139                 cliptrace.ent = prog->edicts;
 140         if (type == MOVE_WORLDONLY)
 141                 goto finished;
 142
 143         if (type == MOVE_MISSILE)
 144         {
 145                 // LordHavoc: modified this, was = -15, now -= 15
 146                 for (i = 0;i < 3;i++)
 147                 {
 148                         clipmins2[i] -= 15;
 149                         clipmaxs2[i] += 15;
 150                 }
 151         }
 152
 153         // create the bounding box of the entire move
 154         for (i = 0;i < 3;i++)
 155         {
 156                 clipboxmins[i] = min(clipstart[i], cliptrace.endpos[i]) + clipmins2[i] - 1;
 157                 clipboxmaxs[i] = max(clipstart[i], cliptrace.endpos[i]) + clipmaxs2[i] + 1;
 158         }
 159
 160         // debug override to test against everything
 161         if (sv_debugmove.integer)
 162         {
 163                 clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = -999999999;
 164                 clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] =  999999999;
 165         }
 166
 167         // if the passedict is world, make it NULL (to avoid two checks each time)
 168         if (passedict == prog->edicts)
 169                 passedict = NULL;
 170         // precalculate prog value for passedict for comparisons
 171         passedictprog = PRVM_EDICT_TO_PROG(passedict);
 172         // precalculate passedict's owner edict pointer for comparisons
 173         traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.server->owner) : 0;
 174
 175         // clip to entities
 176         // because this uses World_EntitiestoBox, we know all entity boxes overlap
 177         // the clip region, so we can skip culling checks in the loop below
 178         numtouchedicts = World_EntitiesInBox(&sv.world, clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
 179         if (numtouchedicts > MAX_EDICTS)
 180         {
 181                 // this never happens
 182                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 183                 numtouchedicts = MAX_EDICTS;
 184         }
 185         for (i = 0;i < numtouchedicts;i++)
 186         {
 187                 touch = touchedicts[i];
 188
 189                 if (touch->fields.server->solid < SOLID_BBOX)
 190                         continue;
 191                 if (type == MOVE_NOMONSTERS && touch->fields.server->solid != SOLID_BSP)
 192                         continue;
 193
 194                 if (passedict)
 195                 {
 196                         // don't clip against self
 197                         if (passedict == touch)
 198                                 continue;
 199                         // don't clip owned entities against owner
 200                         if (traceowner == touch)
 201                                 continue;
 202                         // don't clip owner against owned entities
 203                         if (passedictprog == touch->fields.server->owner)
 204                                 continue;
 205                         // don't clip points against points (they can't collide)
 206                         if (VectorCompare(touch->fields.server->mins, touch->fields.server->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.server->flags & FL_MONSTER)))
 207                                 continue;
 208                 }
 209
 210                 bodysupercontents = touch->fields.server->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
 211
 212                 // might interact, so do an exact clip
 213                 model = NULL;
 214                 if ((int) touch->fields.server->solid == SOLID_BSP || type == MOVE_HITMODEL)
 215                 {
 216                         model = SV_GetModelFromEdict(touch);
 217                         pitchsign = SV_GetPitchSign(touch);
 218                 }
 219                 if (model)
 220                         Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
 221                 else
 222                         Matrix4x4_CreateTranslate(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2]);
 223                 Matrix4x4_Invert_Simple(&imatrix, &matrix);
 224                 VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
 225                 VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
 226                 VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);
 227                 if (type == MOVE_MISSILE && (int)touch->fields.server->flags & FL_MONSTER)
 228                         Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipstart, hitsupercontentsmask);
 229                 else
 230                         Collision_ClipPointToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, hitsupercontentsmask);
 231
 232                 Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.server->solid == SOLID_BSP);
 233         }
 234
 235 finished:
 236         return cliptrace;
 237 }
 238
 239 /*
 240 ==================
 241 SV_TraceLine
 242 ==================
 243 */
 244 #ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
 245 trace_t SV_TraceLine(const vec3_t start, const vec3_t pEnd, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 246 #else
 247 trace_t SV_TraceLine(const vec3_t start, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 248 #endif
 249 {
 250         int i, bodysupercontents;
 251         int passedictprog;
 252         float pitchsign = 1;
 253         prvm_edict_t *traceowner, *touch;
 254         trace_t trace;
 255         // bounding box of entire move area
 256         vec3_t clipboxmins, clipboxmaxs;
 257         // size when clipping against monsters
 258         vec3_t clipmins2, clipmaxs2;
 259         // start and end origin of move
 260         vec3_t clipstart, clipend;
 261         // trace results
 262         trace_t cliptrace;
 263         // matrices to transform into/out of other entity's space
 264         matrix4x4_t matrix, imatrix;
 265         // model of other entity
 266         dp_model_t *model;
 267         // list of entities to test for collisions
 268         int numtouchedicts;
 269         static prvm_edict_t *touchedicts[MAX_EDICTS];
 270 #ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
 271         vec3_t end;
 272         vec_t len = 0;
 273
 274         if (VectorCompare(start, pEnd))
 275                 return SV_TracePoint(start, type, passedict, hitsupercontentsmask);
 276
 277         if(collision_endposnudge.value > 0)
 278         {
 279                 // TRICK: make the trace 1 qu longer!
 280                 VectorSubtract(pEnd, start, end);
 281                 len = VectorNormalizeLength(end);
 282                 VectorMA(pEnd, collision_endposnudge.value, end, end);
 283         }
 284         else
 285                 VectorCopy(pEnd, end);
 286 #else
 287         if (VectorCompare(start, end))
 288                 return SV_TracePoint(start, type, passedict, hitsupercontentsmask);
 289 #endif
 290
 291         //return SV_TraceBox(start, vec3_origin, vec3_origin, end, type, passedict, hitsupercontentsmask);
 292
 293         VectorCopy(start, clipstart);
 294         VectorCopy(end, clipend);
 295         VectorClear(clipmins2);
 296         VectorClear(clipmaxs2);
 297 #if COLLISIONPARANOID >= 3
 298         Con_Printf("move(%f %f %f,%f %f %f)", clipstart[0], clipstart[1], clipstart[2], clipend[0], clipend[1], clipend[2]);
 299 #endif
 300
 301         // clip to world
 302         Collision_ClipLineToWorld(&cliptrace, sv.worldmodel, clipstart, clipend, hitsupercontentsmask);
 303         cliptrace.bmodelstartsolid = cliptrace.startsolid;
 304         if (cliptrace.startsolid || cliptrace.fraction < 1)
 305                 cliptrace.ent = prog->edicts;
 306         if (type == MOVE_WORLDONLY)
 307                 goto finished;
 308
 309         if (type == MOVE_MISSILE)
 310         {
 311                 // LordHavoc: modified this, was = -15, now -= 15
 312                 for (i = 0;i < 3;i++)
 313                 {
 314                         clipmins2[i] -= 15;
 315                         clipmaxs2[i] += 15;
 316                 }
 317         }
 318
 319         // create the bounding box of the entire move
 320         for (i = 0;i < 3;i++)
 321         {
 322                 clipboxmins[i] = min(clipstart[i], cliptrace.endpos[i]) + clipmins2[i] - 1;
 323                 clipboxmaxs[i] = max(clipstart[i], cliptrace.endpos[i]) + clipmaxs2[i] + 1;
 324         }
 325
 326         // debug override to test against everything
 327         if (sv_debugmove.integer)
 328         {
 329                 clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = -999999999;
 330                 clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] =  999999999;
 331         }
 332
 333         // if the passedict is world, make it NULL (to avoid two checks each time)
 334         if (passedict == prog->edicts)
 335                 passedict = NULL;
 336         // precalculate prog value for passedict for comparisons
 337         passedictprog = PRVM_EDICT_TO_PROG(passedict);
 338         // precalculate passedict's owner edict pointer for comparisons
 339         traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.server->owner) : 0;
 340
 341         // clip to entities
 342         // because this uses World_EntitiestoBox, we know all entity boxes overlap
 343         // the clip region, so we can skip culling checks in the loop below
 344         numtouchedicts = World_EntitiesInBox(&sv.world, clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
 345         if (numtouchedicts > MAX_EDICTS)
 346         {
 347                 // this never happens
 348                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 349                 numtouchedicts = MAX_EDICTS;
 350         }
 351         for (i = 0;i < numtouchedicts;i++)
 352         {
 353                 touch = touchedicts[i];
 354
 355                 if (touch->fields.server->solid < SOLID_BBOX)
 356                         continue;
 357                 if (type == MOVE_NOMONSTERS && touch->fields.server->solid != SOLID_BSP)
 358                         continue;
 359
 360                 if (passedict)
 361                 {
 362                         // don't clip against self
 363                         if (passedict == touch)
 364                                 continue;
 365                         // don't clip owned entities against owner
 366                         if (traceowner == touch)
 367                                 continue;
 368                         // don't clip owner against owned entities
 369                         if (passedictprog == touch->fields.server->owner)
 370                                 continue;
 371                         // don't clip points against points (they can't collide)
 372                         if (VectorCompare(touch->fields.server->mins, touch->fields.server->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.server->flags & FL_MONSTER)))
 373                                 continue;
 374                 }
 375
 376                 bodysupercontents = touch->fields.server->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
 377
 378                 // might interact, so do an exact clip
 379                 model = NULL;
 380                 if ((int) touch->fields.server->solid == SOLID_BSP || type == MOVE_HITMODEL)
 381                 {
 382                         model = SV_GetModelFromEdict(touch);
 383                         pitchsign = SV_GetPitchSign(touch);
 384                 }
 385                 if (model)
 386                         Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
 387                 else
 388                         Matrix4x4_CreateTranslate(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2]);
 389                 Matrix4x4_Invert_Simple(&imatrix, &matrix);
 390                 VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
 391                 VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
 392                 VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);
 393                 if (type == MOVE_MISSILE && (int)touch->fields.server->flags & FL_MONSTER)
 394                         Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);
 395                 else
 396                         Collision_ClipLineToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipend, hitsupercontentsmask);
 397
 398                 Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.server->solid == SOLID_BSP);
 399         }
 400
 401 finished:
 402 #ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
 403         if(!VectorCompare(start, pEnd) && collision_endposnudge.value > 0)
 404                 Collision_ShortenTrace(&cliptrace, len / (len + collision_endposnudge.value), pEnd);
 405 #endif
 406         return cliptrace;
 407 }
 408
 409 /*
 410 ==================
 411 SV_Move
 412 ==================
 413 */
 414 #ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
 415 #if COLLISIONPARANOID >= 1
 416 trace_t SV_TraceBox_(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t pEnd, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 417 #else
 418 trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t pEnd, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 419 #endif
 420 #else
 421 #if COLLISIONPARANOID >= 1
 422 trace_t SV_TraceBox_(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 423 #else
 424 trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 425 #endif
 426 #endif
 427 {
 428         vec3_t hullmins, hullmaxs;
 429         int i, bodysupercontents;
 430         int passedictprog;
 431         float pitchsign = 1;
 432         qboolean pointtrace;
 433         prvm_edict_t *traceowner, *touch;
 434         trace_t trace;
 435         // bounding box of entire move area
 436         vec3_t clipboxmins, clipboxmaxs;
 437         // size of the moving object
 438         vec3_t clipmins, clipmaxs;
 439         // size when clipping against monsters
 440         vec3_t clipmins2, clipmaxs2;
 441         // start and end origin of move
 442         vec3_t clipstart, clipend;
 443         // trace results
 444         trace_t cliptrace;
 445         // matrices to transform into/out of other entity's space
 446         matrix4x4_t matrix, imatrix;
 447         // model of other entity
 448         dp_model_t *model;
 449         // list of entities to test for collisions
 450         int numtouchedicts;
 451         static prvm_edict_t *touchedicts[MAX_EDICTS];
 452 #ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
 453         vec3_t end;
 454         vec_t len = 0;
 455
 456         if (VectorCompare(mins, maxs))
 457         {
 458                 vec3_t shiftstart, shiftend;
 459                 VectorAdd(start, mins, shiftstart);
 460                 VectorAdd(pEnd, mins, shiftend);
 461                 if (VectorCompare(start, pEnd))
 462                         trace = SV_TracePoint(shiftstart, type, passedict, hitsupercontentsmask);
 463                 else
 464                         trace = SV_TraceLine(shiftstart, shiftend, type, passedict, hitsupercontentsmask);
 465                 VectorSubtract(trace.endpos, mins, trace.endpos);
 466                 return trace;
 467         }
 468
 469         if(!VectorCompare(start, pEnd) && collision_endposnudge.value > 0)
 470         {
 471                 // TRICK: make the trace 1 qu longer!
 472                 VectorSubtract(pEnd, start, end);
 473                 len = VectorNormalizeLength(end);
 474                 VectorMA(pEnd, collision_endposnudge.value, end, end);
 475         }
 476         else
 477                 VectorCopy(pEnd, end);
 478 #else
 479         if (VectorCompare(mins, maxs))
 480         {
 481                 vec3_t shiftstart, shiftend;
 482                 VectorAdd(start, mins, shiftstart);
 483                 VectorAdd(end, mins, shiftend);
 484                 if (VectorCompare(start, end))
 485                         trace = SV_TracePoint(shiftstart, type, passedict, hitsupercontentsmask);
 486                 else
 487                         trace = SV_TraceLine(shiftstart, shiftend, type, passedict, hitsupercontentsmask);
 488                 VectorSubtract(trace.endpos, mins, trace.endpos);
 489                 return trace;
 490         }
 491 #endif
 492
 493         VectorCopy(start, clipstart);
 494         VectorCopy(end, clipend);
 495         VectorCopy(mins, clipmins);
 496         VectorCopy(maxs, clipmaxs);
 497         VectorCopy(mins, clipmins2);
 498         VectorCopy(maxs, clipmaxs2);
 499 #if COLLISIONPARANOID >= 3
 500         Con_Printf("move(%f %f %f,%f %f %f)", clipstart[0], clipstart[1], clipstart[2], clipend[0], clipend[1], clipend[2]);
 501 #endif
 502
 503         // clip to world
 504         Collision_ClipToWorld(&cliptrace, sv.worldmodel, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask);
 505         cliptrace.bmodelstartsolid = cliptrace.startsolid;
 506         if (cliptrace.startsolid || cliptrace.fraction < 1)
 507                 cliptrace.ent = prog->edicts;
 508         if (type == MOVE_WORLDONLY)
 509                 goto finished;
 510
 511         if (type == MOVE_MISSILE)
 512         {
 513                 // LordHavoc: modified this, was = -15, now -= 15
 514                 for (i = 0;i < 3;i++)
 515                 {
 516                         clipmins2[i] -= 15;
 517                         clipmaxs2[i] += 15;
 518                 }
 519         }
 520
 521         // get adjusted box for bmodel collisions if the world is q1bsp or hlbsp
 522         if (sv.worldmodel && sv.worldmodel->brush.RoundUpToHullSize)
 523                 sv.worldmodel->brush.RoundUpToHullSize(sv.worldmodel, clipmins, clipmaxs, hullmins, hullmaxs);
 524         else
 525         {
 526                 VectorCopy(clipmins, hullmins);
 527                 VectorCopy(clipmaxs, hullmaxs);
 528         }
 529
 530         // create the bounding box of the entire move
 531         for (i = 0;i < 3;i++)
 532         {
 533                 clipboxmins[i] = min(clipstart[i], cliptrace.endpos[i]) + min(hullmins[i], clipmins2[i]) - 1;
 534                 clipboxmaxs[i] = max(clipstart[i], cliptrace.endpos[i]) + max(hullmaxs[i], clipmaxs2[i]) + 1;
 535         }
 536
 537         // debug override to test against everything
 538         if (sv_debugmove.integer)
 539         {
 540                 clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = -999999999;
 541                 clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] =  999999999;
 542         }
 543
 544         // if the passedict is world, make it NULL (to avoid two checks each time)
 545         if (passedict == prog->edicts)
 546                 passedict = NULL;
 547         // precalculate prog value for passedict for comparisons
 548         passedictprog = PRVM_EDICT_TO_PROG(passedict);
 549         // figure out whether this is a point trace for comparisons
 550         pointtrace = VectorCompare(clipmins, clipmaxs);
 551         // precalculate passedict's owner edict pointer for comparisons
 552         traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.server->owner) : 0;
 553
 554         // clip to entities
 555         // because this uses World_EntitiestoBox, we know all entity boxes overlap
 556         // the clip region, so we can skip culling checks in the loop below
 557         numtouchedicts = World_EntitiesInBox(&sv.world, clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
 558         if (numtouchedicts > MAX_EDICTS)
 559         {
 560                 // this never happens
 561                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 562                 numtouchedicts = MAX_EDICTS;
 563         }
 564         for (i = 0;i < numtouchedicts;i++)
 565         {
 566                 touch = touchedicts[i];
 567
 568                 if (touch->fields.server->solid < SOLID_BBOX)
 569                         continue;
 570                 if (type == MOVE_NOMONSTERS && touch->fields.server->solid != SOLID_BSP)
 571                         continue;
 572
 573                 if (passedict)
 574                 {
 575                         // don't clip against self
 576                         if (passedict == touch)
 577                                 continue;
 578                         // don't clip owned entities against owner
 579                         if (traceowner == touch)
 580                                 continue;
 581                         // don't clip owner against owned entities
 582                         if (passedictprog == touch->fields.server->owner)
 583                                 continue;
 584                         // don't clip points against points (they can't collide)
 585                         if (pointtrace && VectorCompare(touch->fields.server->mins, touch->fields.server->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.server->flags & FL_MONSTER)))
 586                                 continue;
 587                 }
 588
 589                 bodysupercontents = touch->fields.server->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
 590
 591                 // might interact, so do an exact clip
 592                 model = NULL;
 593                 if ((int) touch->fields.server->solid == SOLID_BSP || type == MOVE_HITMODEL)
 594                 {
 595                         model = SV_GetModelFromEdict(touch);
 596                         pitchsign = SV_GetPitchSign(touch);
 597                 }
 598                 if (model)
 599                         Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
 600                 else
 601                         Matrix4x4_CreateTranslate(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2]);
 602                 Matrix4x4_Invert_Simple(&imatrix, &matrix);
 603                 VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
 604                 VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
 605                 VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);
 606                 if (type == MOVE_MISSILE && (int)touch->fields.server->flags & FL_MONSTER)
 607                         Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);
 608                 else
 609                         Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask);
 610
 611                 Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.server->solid == SOLID_BSP);
 612         }
 613
 614 finished:
 615 #ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
 616         if(!VectorCompare(start, pEnd) && collision_endposnudge.value > 0)
 617                 Collision_ShortenTrace(&cliptrace, len / (len + collision_endposnudge.value), pEnd);
 618 #endif
 619         return cliptrace;
 620 }
 621
 622 #if COLLISIONPARANOID >= 1
 623 trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask)
 624 {
 625         int endstuck;
 626         trace_t trace;
 627         vec3_t temp;
 628         trace = SV_TraceBox_(start, mins, maxs, end, type, passedict, hitsupercontentsmask);
 629         if (passedict)
 630         {
 631                 VectorCopy(trace.endpos, temp);
 632                 endstuck = SV_TraceBox_(temp, mins, maxs, temp, type, passedict, hitsupercontentsmask).startsolid;
 633 #if COLLISIONPARANOID < 3
 634                 if (trace.startsolid || endstuck)
 635 #endif
 636                         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" : "");
 637         }
 638         return trace;
 639 }
 640 #endif
 641
 642 int SV_PointSuperContents(const vec3_t point)
 643 {
 644         int supercontents = 0;
 645         int i;
 646         prvm_edict_t *touch;
 647         vec3_t transformed;
 648         // matrices to transform into/out of other entity's space
 649         matrix4x4_t matrix, imatrix;
 650         // model of other entity
 651         dp_model_t *model;
 652         int frame;
 653         // list of entities to test for collisions
 654         int numtouchedicts;
 655         static prvm_edict_t *touchedicts[MAX_EDICTS];
 656
 657         // get world supercontents at this point
 658         if (sv.worldmodel && sv.worldmodel->PointSuperContents)
 659                 supercontents = sv.worldmodel->PointSuperContents(sv.worldmodel, 0, point);
 660
 661         // if sv_gameplayfix_swiminbmodels is off we're done
 662         if (!sv_gameplayfix_swiminbmodels.integer)
 663                 return supercontents;
 664
 665         // get list of entities at this point
 666         numtouchedicts = World_EntitiesInBox(&sv.world, point, point, MAX_EDICTS, touchedicts);
 667         if (numtouchedicts > MAX_EDICTS)
 668         {
 669                 // this never happens
 670                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 671                 numtouchedicts = MAX_EDICTS;
 672         }
 673         for (i = 0;i < numtouchedicts;i++)
 674         {
 675                 touch = touchedicts[i];
 676
 677                 // we only care about SOLID_BSP for pointcontents
 678                 if (touch->fields.server->solid != SOLID_BSP)
 679                         continue;
 680
 681                 // might interact, so do an exact clip
 682                 model = SV_GetModelFromEdict(touch);
 683                 if (!model || !model->PointSuperContents)
 684                         continue;
 685                 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);
 686                 Matrix4x4_Invert_Simple(&imatrix, &matrix);
 687                 Matrix4x4_Transform(&imatrix, point, transformed);
 688                 frame = (int)touch->fields.server->frame;
 689                 supercontents |= model->PointSuperContents(model, bound(0, frame, (model->numframes - 1)), transformed);
 690         }
 691
 692         return supercontents;
 693 }
 694
 695 /*
 696 ===============================================================================
 697
 698 Linking entities into the world culling system
 699
 700 ===============================================================================
 701 */
 702
 703 void SV_LinkEdict_TouchAreaGrid_Call(prvm_edict_t *touch, prvm_edict_t *ent)
 704 {
 705         prvm_eval_t *val;
 706         prog->globals.server->self = PRVM_EDICT_TO_PROG(touch);
 707         prog->globals.server->other = PRVM_EDICT_TO_PROG(ent);
 708         prog->globals.server->time = sv.time;
 709         prog->globals.server->trace_allsolid = false;
 710         prog->globals.server->trace_startsolid = false;
 711         prog->globals.server->trace_fraction = 1;
 712         prog->globals.server->trace_inwater = false;
 713         prog->globals.server->trace_inopen = true;
 714         VectorCopy (touch->fields.server->origin, prog->globals.server->trace_endpos);
 715         VectorSet (prog->globals.server->trace_plane_normal, 0, 0, 1);
 716         prog->globals.server->trace_plane_dist = 0;
 717         prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(ent);
 718         if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dpstartcontents)))
 719                 val->_float = 0;
 720         if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitcontents)))
 721                 val->_float = 0;
 722         if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitq3surfaceflags)))
 723                 val->_float = 0;
 724         if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphittexturename)))
 725                 val->string = 0;
 726         PRVM_ExecuteProgram (touch->fields.server->touch, "QC function self.touch is missing");
 727 }
 728
 729 void SV_LinkEdict_TouchAreaGrid(prvm_edict_t *ent)
 730 {
 731         int i, numtouchedicts, old_self, old_other;
 732         prvm_edict_t *touch;
 733         static prvm_edict_t *touchedicts[MAX_EDICTS];
 734
 735         if (ent == prog->edicts)
 736                 return;         // don't add the world
 737
 738         if (ent->priv.server->free)
 739                 return;
 740
 741         if (ent->fields.server->solid == SOLID_NOT)
 742                 return;
 743
 744         // build a list of edicts to touch, because the link loop can be corrupted
 745         // by IncreaseEdicts called during touch functions
 746         numtouchedicts = World_EntitiesInBox(&sv.world, ent->priv.server->areamins, ent->priv.server->areamaxs, MAX_EDICTS, touchedicts);
 747         if (numtouchedicts > MAX_EDICTS)
 748         {
 749                 // this never happens
 750                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 751                 numtouchedicts = MAX_EDICTS;
 752         }
 753
 754         old_self = prog->globals.server->self;
 755         old_other = prog->globals.server->other;
 756         for (i = 0;i < numtouchedicts;i++)
 757         {
 758                 touch = touchedicts[i];
 759                 if (touch != ent && (int)touch->fields.server->solid == SOLID_TRIGGER && touch->fields.server->touch)
 760                 {
 761                         SV_LinkEdict_TouchAreaGrid_Call(touch, ent);
 762                 }
 763         }
 764         prog->globals.server->self = old_self;
 765         prog->globals.server->other = old_other;
 766 }
 767
 768 static void RotateBBox(const vec3_t mins, const vec3_t maxs, const vec3_t angles, vec3_t rotatedmins, vec3_t rotatedmaxs)
 769 {
 770         vec3_t v, u;
 771         matrix4x4_t m;
 772         Matrix4x4_CreateFromQuakeEntity(&m, 0, 0, 0, angles[PITCH], angles[YAW], angles[ROLL], 1.0);
 773
 774         v[0] = mins[0]; v[1] = mins[1]; v[2] = mins[2]; Matrix4x4_Transform(&m, v, u);
 775                 VectorCopy(u, rotatedmins); VectorCopy(u, rotatedmaxs);
 776         v[0] = maxs[0]; v[1] = mins[1]; v[2] = mins[2]; Matrix4x4_Transform(&m, v, u);
 777                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 778                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 779         v[0] = mins[0]; v[1] = maxs[1]; v[2] = mins[2]; Matrix4x4_Transform(&m, v, u);
 780                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 781                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 782         v[0] = maxs[0]; v[1] = maxs[1]; v[2] = mins[2]; Matrix4x4_Transform(&m, v, u);
 783                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 784                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 785         v[0] = mins[0]; v[1] = mins[1]; v[2] = maxs[2]; Matrix4x4_Transform(&m, v, u);
 786                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 787                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 788         v[0] = maxs[0]; v[1] = mins[1]; v[2] = maxs[2]; Matrix4x4_Transform(&m, v, u);
 789                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 790                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 791         v[0] = mins[0]; v[1] = maxs[1]; v[2] = maxs[2]; Matrix4x4_Transform(&m, v, u);
 792                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 793                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 794         v[0] = maxs[0]; v[1] = maxs[1]; v[2] = maxs[2]; Matrix4x4_Transform(&m, v, u);
 795                 if(rotatedmins[0] > u[0]) rotatedmins[0] = u[0]; if(rotatedmins[1] > u[1]) rotatedmins[1] = u[1]; if(rotatedmins[2] > u[2]) rotatedmins[2] = u[2];
 796                 if(rotatedmaxs[0] < u[0]) rotatedmaxs[0] = u[0]; if(rotatedmaxs[1] < u[1]) rotatedmaxs[1] = u[1]; if(rotatedmaxs[2] < u[2]) rotatedmaxs[2] = u[2];
 797 }
 798
 799 /*
 800 ===============
 801 SV_LinkEdict
 802
 803 ===============
 804 */
 805 void SV_LinkEdict (prvm_edict_t *ent)
 806 {
 807         dp_model_t *model;
 808         vec3_t mins, maxs;
 809         int modelindex;
 810
 811         if (ent == prog->edicts)
 812                 return;         // don't add the world
 813
 814         if (ent->priv.server->free)
 815                 return;
 816
 817         modelindex = (int)ent->fields.server->modelindex;
 818         if (modelindex < 0 || modelindex >= MAX_MODELS)
 819         {
 820                 Con_Printf("edict %i: SOLID_BSP with invalid modelindex!\n", PRVM_NUM_FOR_EDICT(ent));
 821                 modelindex = 0;
 822         }
 823         model = SV_GetModelByIndex(modelindex);
 824
 825         VM_GenerateFrameGroupBlend(ent->priv.server->framegroupblend, ent);
 826         VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model);
 827         VM_UpdateEdictSkeleton(ent, model, ent->priv.server->frameblend);
 828
 829 // set the abs box
 830
 831         if (ent->fields.server->movetype == MOVETYPE_PHYSICS)
 832         {
 833                 // TODO maybe should do this for rotating SOLID_BSP too? Would behave better with rotating doors
 834                 // TODO special handling for spheres?
 835                 RotateBBox(ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->angles, mins, maxs);
 836                 VectorAdd(ent->fields.server->origin, mins, mins);
 837                 VectorAdd(ent->fields.server->origin, maxs, maxs);
 838         }
 839         else if (ent->fields.server->solid == SOLID_BSP)
 840         {
 841                 if (model != NULL)
 842                 {
 843                         if (!model->TraceBox)
 844                                 Con_DPrintf("edict %i: SOLID_BSP with non-collidable model\n", PRVM_NUM_FOR_EDICT(ent));
 845
 846                         if (ent->fields.server->angles[0] || ent->fields.server->angles[2] || ent->fields.server->avelocity[0] || ent->fields.server->avelocity[2])
 847                         {
 848                                 VectorAdd(ent->fields.server->origin, model->rotatedmins, mins);
 849                                 VectorAdd(ent->fields.server->origin, model->rotatedmaxs, maxs);
 850                         }
 851                         else if (ent->fields.server->angles[1] || ent->fields.server->avelocity[1])
 852                         {
 853                                 VectorAdd(ent->fields.server->origin, model->yawmins, mins);
 854                                 VectorAdd(ent->fields.server->origin, model->yawmaxs, maxs);
 855                         }
 856                         else
 857                         {
 858                                 VectorAdd(ent->fields.server->origin, model->normalmins, mins);
 859                                 VectorAdd(ent->fields.server->origin, model->normalmaxs, maxs);
 860                         }
 861                 }
 862                 else
 863                 {
 864                         // SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily
 865                         VectorAdd(ent->fields.server->origin, ent->fields.server->mins, mins);
 866                         VectorAdd(ent->fields.server->origin, ent->fields.server->maxs, maxs);
 867                 }
 868         }
 869         else
 870         {
 871                 VectorAdd(ent->fields.server->origin, ent->fields.server->mins, mins);
 872                 VectorAdd(ent->fields.server->origin, ent->fields.server->maxs, maxs);
 873         }
 874
 875 //
 876 // to make items easier to pick up and allow them to be grabbed off
 877 // of shelves, the abs sizes are expanded
 878 //
 879         if ((int)ent->fields.server->flags & FL_ITEM)
 880         {
 881                 mins[0] -= 15;
 882                 mins[1] -= 15;
 883                 mins[2] -= 1;
 884                 maxs[0] += 15;
 885                 maxs[1] += 15;
 886                 maxs[2] += 1;
 887         }
 888         else
 889         {
 890                 // because movement is clipped an epsilon away from an actual edge,
 891                 // we must fully check even when bounding boxes don't quite touch
 892                 mins[0] -= 1;
 893                 mins[1] -= 1;
 894                 mins[2] -= 1;
 895                 maxs[0] += 1;
 896                 maxs[1] += 1;
 897                 maxs[2] += 1;
 898         }
 899
 900         VectorCopy(mins, ent->fields.server->absmin);
 901         VectorCopy(maxs, ent->fields.server->absmax);
 902
 903         World_LinkEdict(&sv.world, ent, mins, maxs);
 904 }
 905
 906 /*
 907 ===============================================================================
 908
 909 Utility functions
 910
 911 ===============================================================================
 912 */
 913
 914 /*
 915 ============
 916 SV_TestEntityPosition
 917
 918 returns true if the entity is in solid currently
 919 ============
 920 */
 921 static int SV_TestEntityPosition (prvm_edict_t *ent, vec3_t offset)
 922 {
 923         int contents;
 924         vec3_t org;
 925         trace_t trace;
 926         contents = SV_GenericHitSuperContentsMask(ent);
 927         VectorAdd(ent->fields.server->origin, offset, org);
 928         trace = SV_TraceBox(org, ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->origin, MOVE_NOMONSTERS, ent, contents);
 929         if (trace.startsupercontents & contents)
 930                 return true;
 931         else
 932         {
 933                 if (sv.worldmodel->brushq1.numclipnodes && !VectorCompare(ent->fields.server->mins, ent->fields.server->maxs))
 934                 {
 935                         // q1bsp/hlbsp use hulls and if the entity does not exactly match
 936                         // a hull size it is incorrectly tested, so this code tries to
 937                         // 'fix' it slightly...
 938                         // FIXME: this breaks entities larger than the hull size
 939                         int i;
 940                         vec3_t v, m1, m2, s;
 941                         VectorAdd(org, ent->fields.server->mins, m1);
 942                         VectorAdd(org, ent->fields.server->maxs, m2);
 943                         VectorSubtract(m2, m1, s);
 944 #define EPSILON (1.0f / 32.0f)
 945                         if (s[0] >= EPSILON*2) {m1[0] += EPSILON;m2[0] -= EPSILON;}
 946                         if (s[1] >= EPSILON*2) {m1[1] += EPSILON;m2[1] -= EPSILON;}
 947                         if (s[2] >= EPSILON*2) {m1[2] += EPSILON;m2[2] -= EPSILON;}
 948                         for (i = 0;i < 8;i++)
 949                         {
 950                                 v[0] = (i & 1) ? m2[0] : m1[0];
 951                                 v[1] = (i & 2) ? m2[1] : m1[1];
 952                                 v[2] = (i & 4) ? m2[2] : m1[2];
 953                                 if (SV_PointSuperContents(v) & contents)
 954                                         return true;
 955                         }
 956                 }
 957         }
 958         // if the trace found a better position for the entity, move it there
 959         if (VectorDistance2(trace.endpos, ent->fields.server->origin) >= 0.0001)
 960         {
 961 #if 0
 962                 // please switch back to this code when trace.endpos sometimes being in solid bug is fixed
 963                 VectorCopy(trace.endpos, ent->fields.server->origin);
 964 #else
 965                 // verify if the endpos is REALLY outside solid
 966                 VectorCopy(trace.endpos, org);
 967                 trace = SV_TraceBox(org, ent->fields.server->mins, ent->fields.server->maxs, org, MOVE_NOMONSTERS, ent, contents);
 968                 if(trace.startsolid)
 969                         Con_Printf("SV_TestEntityPosition: trace.endpos detected to be in solid. NOT using it.\n");
 970                 else
 971                         VectorCopy(org, ent->fields.server->origin);
 972 #endif
 973         }
 974         return false;
 975 }
 976
 977 /*
 978 ================
 979 SV_CheckAllEnts
 980 ================
 981 */
 982 void SV_CheckAllEnts (void)
 983 {
 984         int e;
 985         prvm_edict_t *check;
 986
 987         // see if any solid entities are inside the final position
 988         check = PRVM_NEXT_EDICT(prog->edicts);
 989         for (e = 1;e < prog->num_edicts;e++, check = PRVM_NEXT_EDICT(check))
 990         {
 991                 if (check->priv.server->free)
 992                         continue;
 993                 if (check->fields.server->movetype == MOVETYPE_PUSH
 994                  || check->fields.server->movetype == MOVETYPE_NONE
 995                  || check->fields.server->movetype == MOVETYPE_FOLLOW
 996                  || check->fields.server->movetype == MOVETYPE_NOCLIP)
 997                         continue;
 998
 999                 if (SV_TestEntityPosition (check, vec3_origin))
1000                         Con_Print("entity in invalid position\n");
1001         }
1002 }
1003
1004 // DRESK - Support for Entity Contents Transition Event
1005 /*
1006 ================
1007 SV_CheckContentsTransition
1008
1009 returns true if entity had a valid contentstransition function call
1010 ================
1011 */
1012 int SV_CheckContentsTransition(prvm_edict_t *ent, const int nContents)
1013 {
1014         int bValidFunctionCall;
1015         prvm_eval_t *contentstransition;
1016
1017         // Default Valid Function Call to False
1018         bValidFunctionCall = false;
1019
1020         if(ent->fields.server->watertype != nContents)
1021         { // Changed Contents
1022                 // Acquire Contents Transition Function from QC
1023                 contentstransition = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.contentstransition);
1024
1025                 if(contentstransition->function)
1026                 { // Valid Function; Execute
1027                         // Assign Valid Function
1028                         bValidFunctionCall = true;
1029                         // Prepare Parameters (Original Contents, New Contents)
1030                                 // Original Contents
1031                                 PRVM_G_FLOAT(OFS_PARM0) = ent->fields.server->watertype;
1032                                 // New Contents
1033                                 PRVM_G_FLOAT(OFS_PARM1) = nContents;
1034                                 // Assign Self
1035                                 prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
1036                         // Execute VM Function
1037                         PRVM_ExecuteProgram(contentstransition->function, "contentstransition: NULL function");
1038                 }
1039         }
1040
1041         // Return if Function Call was Valid
1042         return bValidFunctionCall;
1043 }
1044
1045
1046 /*
1047 ================
1048 SV_CheckVelocity
1049 ================
1050 */
1051 void SV_CheckVelocity (prvm_edict_t *ent)
1052 {
1053         int i;
1054         float wishspeed;
1055
1056 //
1057 // bound velocity
1058 //
1059         for (i=0 ; i<3 ; i++)
1060         {
1061                 if (IS_NAN(ent->fields.server->velocity[i]))
1062                 {
1063                         Con_Printf("Got a NaN velocity on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(ent->fields.server->classname));
1064                         ent->fields.server->velocity[i] = 0;
1065                 }
1066                 if (IS_NAN(ent->fields.server->origin[i]))
1067                 {
1068                         Con_Printf("Got a NaN origin on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(ent->fields.server->classname));
1069                         ent->fields.server->origin[i] = 0;
1070                 }
1071         }
1072
1073         // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
1074         // player_run/player_stand1 does not horribly malfunction if the
1075         // velocity becomes a denormalized float
1076         if (VectorLength2(ent->fields.server->velocity) < 0.0001)
1077                 VectorClear(ent->fields.server->velocity);
1078
1079         // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
1080         wishspeed = DotProduct(ent->fields.server->velocity, ent->fields.server->velocity);
1081         if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
1082         {
1083                 wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
1084                 ent->fields.server->velocity[0] *= wishspeed;
1085                 ent->fields.server->velocity[1] *= wishspeed;
1086                 ent->fields.server->velocity[2] *= wishspeed;
1087         }
1088 }
1089
1090 /*
1091 =============
1092 SV_RunThink
1093
1094 Runs thinking code if time.  There is some play in the exact time the think
1095 function will be called, because it is called before any movement is done
1096 in a frame.  Not used for pushmove objects, because they must be exact.
1097 Returns false if the entity removed itself.
1098 =============
1099 */
1100 qboolean SV_RunThink (prvm_edict_t *ent)
1101 {
1102         int iterations;
1103
1104         // don't let things stay in the past.
1105         // it is possible to start that way by a trigger with a local time.
1106         if (ent->fields.server->nextthink <= 0 || ent->fields.server->nextthink > sv.time + sv.frametime)
1107                 return true;
1108
1109         for (iterations = 0;iterations < 128  && !ent->priv.server->free;iterations++)
1110         {
1111                 prog->globals.server->time = max(sv.time, ent->fields.server->nextthink);
1112                 ent->fields.server->nextthink = 0;
1113                 prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
1114                 prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
1115                 PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
1116                 // mods often set nextthink to time to cause a think every frame,
1117                 // we don't want to loop in that case, so exit if the new nextthink is
1118                 // <= the time the qc was told, also exit if it is past the end of the
1119                 // frame
1120                 if (ent->fields.server->nextthink <= prog->globals.server->time || ent->fields.server->nextthink > sv.time + sv.frametime || !sv_gameplayfix_multiplethinksperframe.integer)
1121                         break;
1122         }
1123         return !ent->priv.server->free;
1124 }
1125
1126 /*
1127 ==================
1128 SV_Impact
1129
1130 Two entities have touched, so run their touch functions
1131 returns true if the impact kept the origin of the touching entity intact
1132 ==================
1133 */
1134 extern void VM_SetTraceGlobals(const trace_t *trace);
1135 extern sizebuf_t vm_tempstringsbuf;
1136 qboolean SV_Impact (prvm_edict_t *e1, trace_t *trace)
1137 {
1138         int restorevm_tempstringsbuf_cursize;
1139         int old_self, old_other;
1140         vec3_t org;
1141         prvm_edict_t *e2 = (prvm_edict_t *)trace->ent;
1142         prvm_eval_t *val;
1143
1144         old_self = prog->globals.server->self;
1145         old_other = prog->globals.server->other;
1146         restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
1147
1148         VectorCopy(e1->fields.server->origin, org);
1149
1150         VM_SetTraceGlobals(trace);
1151
1152         prog->globals.server->time = sv.time;
1153         if (!e1->priv.server->free && !e2->priv.server->free && e1->fields.server->touch && e1->fields.server->solid != SOLID_NOT)
1154         {
1155                 prog->globals.server->self = PRVM_EDICT_TO_PROG(e1);
1156                 prog->globals.server->other = PRVM_EDICT_TO_PROG(e2);
1157                 PRVM_ExecuteProgram (e1->fields.server->touch, "QC function self.touch is missing");
1158         }
1159
1160         if (!e1->priv.server->free && !e2->priv.server->free && e2->fields.server->touch && e2->fields.server->solid != SOLID_NOT)
1161         {
1162                 prog->globals.server->self = PRVM_EDICT_TO_PROG(e2);
1163                 prog->globals.server->other = PRVM_EDICT_TO_PROG(e1);
1164                 VectorCopy(e2->fields.server->origin, prog->globals.server->trace_endpos);
1165                 VectorNegate(trace->plane.normal, prog->globals.server->trace_plane_normal);
1166                 prog->globals.server->trace_plane_dist = -trace->plane.dist;
1167                 prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(e1);
1168                 if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dpstartcontents)))
1169                         val->_float = 0;
1170                 if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitcontents)))
1171                         val->_float = 0;
1172                 if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitq3surfaceflags)))
1173                         val->_float = 0;
1174                 if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphittexturename)))
1175                         val->string = 0;
1176                 PRVM_ExecuteProgram (e2->fields.server->touch, "QC function self.touch is missing");
1177         }
1178
1179         prog->globals.server->self = old_self;
1180         prog->globals.server->other = old_other;
1181         vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
1182
1183         return VectorCompare(e1->fields.server->origin, org);
1184 }
1185
1186
1187 /*
1188 ==================
1189 ClipVelocity
1190
1191 Slide off of the impacting object
1192 returns the blocked flags (1 = floor, 2 = step / wall)
1193 ==================
1194 */
1195 #define STOP_EPSILON 0.1
1196 void ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
1197 {
1198         int i;
1199         float backoff;
1200
1201         backoff = -DotProduct (in, normal) * overbounce;
1202         VectorMA(in, backoff, normal, out);
1203
1204         for (i = 0;i < 3;i++)
1205                 if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
1206                         out[i] = 0;
1207 }
1208
1209
1210 /*
1211 ============
1212 SV_FlyMove
1213
1214 The basic solid body movement clip that slides along multiple planes
1215 Returns the clipflags if the velocity was modified (hit something solid)
1216 1 = floor
1217 2 = wall / step
1218 4 = dead stop
1219 8 = teleported by touch method
1220 If stepnormal is not NULL, the plane normal of any vertical wall hit will be stored
1221 ============
1222 */
1223 static float SV_Gravity (prvm_edict_t *ent);
1224 static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, qboolean failonbmodelstartsolid, qboolean dolink);
1225 #define MAX_CLIP_PLANES 5
1226 static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, float *stepnormal, int hitsupercontentsmask)
1227 {
1228         int blocked, bumpcount;
1229         int i, j, numplanes;
1230         float d, time_left, gravity;
1231         vec3_t dir, push, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, new_velocity;
1232 #if 0
1233         vec3_t end;
1234 #endif
1235         trace_t trace;
1236         if (time <= 0)
1237                 return 0;
1238         gravity = 0;
1239         if (applygravity)
1240         {
1241                 if (sv_gameplayfix_gravityunaffectedbyticrate.integer)
1242                 {
1243                         gravity = SV_Gravity(ent) * 0.5f;
1244                         ent->fields.server->velocity[2] -= gravity;
1245                 }
1246                 else
1247                 {
1248                         applygravity = false;
1249                         ent->fields.server->velocity[2] -= SV_Gravity(ent);
1250                 }
1251         }
1252         blocked = 0;
1253         VectorCopy(ent->fields.server->velocity, original_velocity);
1254         VectorCopy(ent->fields.server->velocity, primal_velocity);
1255         numplanes = 0;
1256         time_left = time;
1257         for (bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
1258         {
1259                 if (!ent->fields.server->velocity[0] && !ent->fields.server->velocity[1] && !ent->fields.server->velocity[2])
1260                         break;
1261
1262                 VectorScale(ent->fields.server->velocity, time_left, push);
1263 #if 0
1264                 VectorAdd(ent->fields.server->origin, push, end);
1265 #endif
1266                 if(!SV_PushEntity(&trace, ent, push, false, false))
1267                 {
1268                         // we got teleported by a touch function
1269                         // let's abort the move
1270                         blocked |= 8;
1271                         break;
1272                 }
1273
1274 #if 0
1275                 //if (trace.fraction < 0.002)
1276                 {
1277 #if 1
1278                         vec3_t start;
1279                         trace_t testtrace;
1280                         VectorCopy(ent->fields.server->origin, start);
1281                         start[2] += 3;//0.03125;
1282                         VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
1283                         end[2] += 3;//0.03125;
1284                         testtrace = SV_TraceBox(start, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, hitsupercontentsmask);
1285                         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)))
1286                         {
1287                                 Con_Printf("got further (new %f > old %f)\n", testtrace.fraction, trace.fraction);
1288                                 trace = testtrace;
1289                         }
1290 #endif
1291 #if 0
1292                         //j = -1;
1293                         for (i = 0;i < numplanes;i++)
1294                         {
1295                                 VectorCopy(ent->fields.server->origin, start);
1296                                 VectorMA(ent->fields.server->origin, time_left, ent->fields.server->velocity, end);
1297                                 VectorMA(start, 3, planes[i], start);
1298                                 VectorMA(end, 3, planes[i], end);
1299                                 testtrace = SV_TraceBox(start, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, hitsupercontentsmask);
1300                                 if (trace.fraction < testtrace.fraction)
1301                                 {
1302                                         trace = testtrace;
1303                                         VectorCopy(start, ent->fields.server->origin);
1304                                         //j = i;
1305                                 }
1306                         }
1307                         //if (j >= 0)
1308                         //      VectorAdd(ent->fields.server->origin, planes[j], start);
1309 #endif
1310                 }
1311 #endif
1312
1313 #if 0
1314                 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);
1315                 if (trace.fraction < 1)
1316                         Con_Printf(" : %f %f %f", trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2]);
1317                 Con_Print("\n");
1318 #endif
1319
1320 #if 0
1321                 if (trace.bmodelstartsolid)
1322                 {
1323                         // LordHavoc: note: this code is what makes entities stick in place
1324                         // if embedded in world only (you can walk through other objects if
1325                         // stuck)
1326                         // entity is trapped in another solid
1327                         VectorClear(ent->fields.server->velocity);
1328                         return 3;
1329                 }
1330 #endif
1331
1332                 if (trace.fraction == 1)
1333                         break;
1334                 if (trace.plane.normal[2])
1335                 {
1336                         if (trace.plane.normal[2] > 0.7)
1337                         {
1338                                 // floor
1339                                 blocked |= 1;
1340
1341                                 if (!trace.ent)
1342                                 {
1343                                         Con_Printf ("SV_FlyMove: !trace.ent");
1344                                         trace.ent = prog->edicts;
1345                                 }
1346
1347                                 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
1348                                 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
1349                         }
1350                 }
1351                 else
1352                 {
1353                         // step
1354                         blocked |= 2;
1355                         // save the trace for player extrafriction
1356                         if (stepnormal)
1357                                 VectorCopy(trace.plane.normal, stepnormal);
1358                 }
1359                 if (trace.fraction >= 0.001)
1360                 {
1361                         // actually covered some distance
1362                         VectorCopy(ent->fields.server->velocity, original_velocity);
1363                         numplanes = 0;
1364                 }
1365
1366                 time_left *= 1 - trace.fraction;
1367
1368                 // clipped to another plane
1369                 if (numplanes >= MAX_CLIP_PLANES)
1370                 {
1371                         // this shouldn't really happen
1372                         VectorClear(ent->fields.server->velocity);
1373                         blocked = 3;
1374                         break;
1375                 }
1376
1377                 /*
1378                 for (i = 0;i < numplanes;i++)
1379                         if (DotProduct(trace.plane.normal, planes[i]) > 0.99)
1380                                 break;
1381                 if (i < numplanes)
1382                 {
1383                         VectorAdd(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity);
1384                         continue;
1385                 }
1386                 */
1387
1388                 VectorCopy(trace.plane.normal, planes[numplanes]);
1389                 numplanes++;
1390
1391                 if (sv_newflymove.integer)
1392                         ClipVelocity(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1);
1393                 else
1394                 {
1395                         // modify original_velocity so it parallels all of the clip planes
1396                         for (i = 0;i < numplanes;i++)
1397                         {
1398                                 ClipVelocity(original_velocity, planes[i], new_velocity, 1);
1399                                 for (j = 0;j < numplanes;j++)
1400                                 {
1401                                         if (j != i)
1402                                         {
1403                                                 // not ok
1404                                                 if (DotProduct(new_velocity, planes[j]) < 0)
1405                                                         break;
1406                                         }
1407                                 }
1408                                 if (j == numplanes)
1409                                         break;
1410                         }
1411
1412                         if (i != numplanes)
1413                         {
1414                                 // go along this plane
1415                                 VectorCopy(new_velocity, ent->fields.server->velocity);
1416                         }
1417                         else
1418                         {
1419                                 // go along the crease
1420                                 if (numplanes != 2)
1421                                 {
1422                                         VectorClear(ent->fields.server->velocity);
1423                                         blocked = 7;
1424                                         break;
1425                                 }
1426                                 CrossProduct(planes[0], planes[1], dir);
1427                                 // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
1428                                 VectorNormalize(dir);
1429                                 d = DotProduct(dir, ent->fields.server->velocity);
1430                                 VectorScale(dir, d, ent->fields.server->velocity);
1431                         }
1432                 }
1433
1434                 // if current velocity is against the original velocity,
1435                 // stop dead to avoid tiny occilations in sloping corners
1436                 if (DotProduct(ent->fields.server->velocity, primal_velocity) <= 0)
1437                 {
1438                         VectorClear(ent->fields.server->velocity);
1439                         break;
1440                 }
1441         }
1442
1443         //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]);
1444
1445         /*
1446         if ((blocked & 1) == 0 && bumpcount > 1)
1447         {
1448                 // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
1449                 // flag ONGROUND if there's ground under it
1450                 trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, hitsupercontentsmask);
1451         }
1452         */
1453
1454         // LordHavoc: this came from QW and allows you to get out of water more easily
1455         if (sv_gameplayfix_easierwaterjump.integer && ((int)ent->fields.server->flags & FL_WATERJUMP) && !(blocked & 8))
1456                 VectorCopy(primal_velocity, ent->fields.server->velocity);
1457         if (applygravity && !((int)ent->fields.server->flags & FL_ONGROUND))
1458                 ent->fields.server->velocity[2] -= gravity;
1459         return blocked;
1460 }
1461
1462 /*
1463 ============
1464 SV_Gravity
1465
1466 ============
1467 */
1468 static float SV_Gravity (prvm_edict_t *ent)
1469 {
1470         float ent_gravity;
1471         prvm_eval_t *val;
1472
1473         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.gravity);
1474         if (val!=0 && val->_float)
1475                 ent_gravity = val->_float;
1476         else
1477                 ent_gravity = 1.0;
1478         return ent_gravity * sv_gravity.value * sv.frametime;
1479 }
1480
1481
1482 /*
1483 ===============================================================================
1484
1485 PUSHMOVE
1486
1487 ===============================================================================
1488 */
1489
1490 /*
1491 ============
1492 SV_PushEntity
1493
1494 Does not change the entities velocity at all
1495 The trace struct is filled with the trace that has been done.
1496 Returns true if the push did not result in the entity being teleported by QC code.
1497 ============
1498 */
1499 static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, qboolean failonbmodelstartsolid, qboolean dolink)
1500 {
1501         int type;
1502         int bump;
1503         vec3_t original;
1504         vec3_t end;
1505
1506         VectorCopy(ent->fields.server->origin, original);
1507         VectorAdd (ent->fields.server->origin, push, end);
1508
1509         if (ent->fields.server->movetype == MOVETYPE_FLYMISSILE)
1510                 type = MOVE_MISSILE;
1511         else if (ent->fields.server->solid == SOLID_TRIGGER || ent->fields.server->solid == SOLID_NOT)
1512                 type = MOVE_NOMONSTERS; // only clip against bmodels
1513         else
1514                 type = MOVE_NORMAL;
1515
1516         *trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, type, ent, SV_GenericHitSuperContentsMask(ent));
1517         bump = 0;
1518         while (trace->startsolid && sv_gameplayfix_nudgeoutofsolid.integer)
1519         {
1520                 vec_t nudge = -trace->startdepth + sv_gameplayfix_nudgeoutofsolid_bias.value;
1521                 VectorMA(ent->fields.server->origin, nudge, trace->startdepthnormal, ent->fields.server->origin);
1522                 *trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, type, ent, SV_GenericHitSuperContentsMask(ent));
1523                 bump++;
1524                 if (bump > 10)
1525                 {
1526                         VectorCopy(original, ent->fields.server->origin);
1527                         break;
1528                 }
1529         }
1530         if (trace->bmodelstartsolid && failonbmodelstartsolid)
1531                 return true;
1532
1533
1534         VectorCopy (trace->endpos, ent->fields.server->origin);
1535         SV_LinkEdict(ent);
1536
1537 #if 0
1538         if(!trace->startsolid)
1539         if(SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->origin, type, ent, SV_GenericHitSuperContentsMask(ent)).startsolid)
1540         {
1541                 Con_Printf("something eeeeevil happened\n");
1542         }
1543 #endif
1544
1545         if (dolink)
1546                 SV_LinkEdict_TouchAreaGrid(ent);
1547
1548         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))))
1549                 return SV_Impact (ent, trace);
1550
1551         return true;
1552 }
1553
1554
1555 /*
1556 ============
1557 SV_PushMove
1558
1559 ============
1560 */
1561 void SV_PushMove (prvm_edict_t *pusher, float movetime)
1562 {
1563         int i, e, index;
1564         int pusherowner, pusherprog;
1565         int checkcontents;
1566         qboolean rotated;
1567         float savesolid, movetime2, pushltime;
1568         vec3_t mins, maxs, move, move1, moveangle, pushorig, pushang, a, forward, left, up, org;
1569         int num_moved;
1570         int numcheckentities;
1571         static prvm_edict_t *checkentities[MAX_EDICTS];
1572         dp_model_t *pushermodel;
1573         trace_t trace, trace2;
1574         matrix4x4_t pusherfinalmatrix, pusherfinalimatrix;
1575         static unsigned short moved_edicts[MAX_EDICTS];
1576
1577         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])
1578         {
1579                 pusher->fields.server->ltime += movetime;
1580                 return;
1581         }
1582
1583         switch ((int) pusher->fields.server->solid)
1584         {
1585         // LordHavoc: valid pusher types
1586         case SOLID_BSP:
1587         case SOLID_BBOX:
1588         case SOLID_SLIDEBOX:
1589         case SOLID_CORPSE: // LordHavoc: this would be weird...
1590                 break;
1591         // LordHavoc: no collisions
1592         case SOLID_NOT:
1593         case SOLID_TRIGGER:
1594                 VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
1595                 VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
1596                 pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
1597                 pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
1598                 pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
1599                 pusher->fields.server->ltime += movetime;
1600                 SV_LinkEdict(pusher);
1601                 return;
1602         default:
1603                 Con_Printf("SV_PushMove: entity #%i, unrecognized solid type %f\n", PRVM_NUM_FOR_EDICT(pusher), pusher->fields.server->solid);
1604                 return;
1605         }
1606         index = (int) pusher->fields.server->modelindex;
1607         if (index < 1 || index >= MAX_MODELS)
1608         {
1609                 Con_Printf("SV_PushMove: entity #%i has an invalid modelindex %f\n", PRVM_NUM_FOR_EDICT(pusher), pusher->fields.server->modelindex);
1610                 return;
1611         }
1612         pushermodel = SV_GetModelByIndex(index);
1613         pusherowner = pusher->fields.server->owner;
1614         pusherprog = PRVM_EDICT_TO_PROG(pusher);
1615
1616         rotated = VectorLength2(pusher->fields.server->angles) + VectorLength2(pusher->fields.server->avelocity) > 0;
1617
1618         movetime2 = movetime;
1619         VectorScale(pusher->fields.server->velocity, movetime2, move1);
1620         VectorScale(pusher->fields.server->avelocity, movetime2, moveangle);
1621         if (moveangle[0] || moveangle[2])
1622         {
1623                 for (i = 0;i < 3;i++)
1624                 {
1625                         if (move1[i] > 0)
1626                         {
1627                                 mins[i] = pushermodel->rotatedmins[i] + pusher->fields.server->origin[i] - 1;
1628                                 maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
1629                         }
1630                         else
1631                         {
1632                                 mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
1633                                 maxs[i] = pushermodel->rotatedmaxs[i] + pusher->fields.server->origin[i] + 1;
1634                         }
1635                 }
1636         }
1637         else if (moveangle[1])
1638         {
1639                 for (i = 0;i < 3;i++)
1640                 {
1641                         if (move1[i] > 0)
1642                         {
1643                                 mins[i] = pushermodel->yawmins[i] + pusher->fields.server->origin[i] - 1;
1644                                 maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
1645                         }
1646                         else
1647                         {
1648                                 mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
1649                                 maxs[i] = pushermodel->yawmaxs[i] + pusher->fields.server->origin[i] + 1;
1650                         }
1651                 }
1652         }
1653         else
1654         {
1655                 for (i = 0;i < 3;i++)
1656                 {
1657                         if (move1[i] > 0)
1658                         {
1659                                 mins[i] = pushermodel->normalmins[i] + pusher->fields.server->origin[i] - 1;
1660                                 maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
1661                         }
1662                         else
1663                         {
1664                                 mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
1665                                 maxs[i] = pushermodel->normalmaxs[i] + pusher->fields.server->origin[i] + 1;
1666                         }
1667                 }
1668         }
1669
1670         VectorNegate (moveangle, a);
1671         AngleVectorsFLU (a, forward, left, up);
1672
1673         VectorCopy (pusher->fields.server->origin, pushorig);
1674         VectorCopy (pusher->fields.server->angles, pushang);
1675         pushltime = pusher->fields.server->ltime;
1676
1677 // move the pusher to its final position
1678
1679         VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
1680         VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
1681         pusher->fields.server->ltime += movetime;
1682         SV_LinkEdict(pusher);
1683
1684         pushermodel = SV_GetModelFromEdict(pusher);
1685         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);
1686         Matrix4x4_Invert_Simple(&pusherfinalimatrix, &pusherfinalmatrix);
1687
1688         savesolid = pusher->fields.server->solid;
1689
1690 // see if any solid entities are inside the final position
1691         num_moved = 0;
1692
1693         numcheckentities = World_EntitiesInBox(&sv.world, mins, maxs, MAX_EDICTS, checkentities);
1694         for (e = 0;e < numcheckentities;e++)
1695         {
1696                 prvm_edict_t *check = checkentities[e];
1697                 int movetype = (int)check->fields.server->movetype;
1698                 switch(movetype)
1699                 {
1700                 case MOVETYPE_NONE:
1701                 case MOVETYPE_PUSH:
1702                 case MOVETYPE_FOLLOW:
1703                 case MOVETYPE_NOCLIP:
1704                 case MOVETYPE_FAKEPUSH:
1705                         continue;
1706                 default:
1707                         break;
1708                 }
1709
1710                 if (check->fields.server->owner == pusherprog)
1711                         continue;
1712
1713                 if (pusherowner == PRVM_EDICT_TO_PROG(check))
1714                         continue;
1715
1716                 //Con_Printf("%i %s ", PRVM_NUM_FOR_EDICT(check), PRVM_GetString(check->fields.server->classname));
1717
1718                 // tell any MOVETYPE_STEP entity that it may need to check for water transitions
1719                 check->priv.server->waterposition_forceupdate = true;
1720
1721                 checkcontents = SV_GenericHitSuperContentsMask(check);
1722
1723                 // if the entity is standing on the pusher, it will definitely be moved
1724                 // if the entity is not standing on the pusher, but is in the pusher's
1725                 // final position, move it
1726                 if (!((int)check->fields.server->flags & FL_ONGROUND) || PRVM_PROG_TO_EDICT(check->fields.server->groundentity) != pusher)
1727                 {
1728                         Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, 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);
1729                         //trace = SV_TraceBox(check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, MOVE_NOMONSTERS, check, checkcontents);
1730                         if (!trace.startsolid)
1731                         {
1732                                 //Con_Printf("- not in solid\n");
1733                                 continue;
1734                         }
1735                 }
1736
1737                 if (rotated)
1738                 {
1739                         vec3_t org2;
1740                         VectorSubtract (check->fields.server->origin, pusher->fields.server->origin, org);
1741                         org2[0] = DotProduct (org, forward);
1742                         org2[1] = DotProduct (org, left);
1743                         org2[2] = DotProduct (org, up);
1744                         VectorSubtract (org2, org, move);
1745                         VectorAdd (move, move1, move);
1746                 }
1747                 else
1748                         VectorCopy (move1, move);
1749
1750                 //Con_Printf("- pushing %f %f %f\n", move[0], move[1], move[2]);
1751
1752                 VectorCopy (check->fields.server->origin, check->priv.server->moved_from);
1753                 VectorCopy (check->fields.server->angles, check->priv.server->moved_fromangles);
1754                 moved_edicts[num_moved++] = PRVM_NUM_FOR_EDICT(check);
1755
1756                 // physics objects need better collisions than this code can do
1757                 if (movetype == MOVETYPE_PHYSICS)
1758                 {
1759                         VectorAdd(check->fields.server->origin, move, check->fields.server->origin);
1760                         SV_LinkEdict(check);
1761                         SV_LinkEdict_TouchAreaGrid(check);
1762                         continue;
1763                 }
1764
1765                 // try moving the contacted entity
1766                 pusher->fields.server->solid = SOLID_NOT;
1767                 if(!SV_PushEntity (&trace, check, move, true, true))
1768                 {
1769                         // entity "check" got teleported
1770                         check->fields.server->angles[1] += trace.fraction * moveangle[1];
1771                         pusher->fields.server->solid = savesolid; // was SOLID_BSP
1772                         continue; // pushed enough
1773                 }
1774                 // FIXME: turn players specially
1775                 check->fields.server->angles[1] += trace.fraction * moveangle[1];
1776                 pusher->fields.server->solid = savesolid; // was SOLID_BSP
1777                 //Con_Printf("%s:%d frac %f startsolid %d bmodelstartsolid %d allsolid %d\n", __FILE__, __LINE__, trace.fraction, trace.startsolid, trace.bmodelstartsolid, trace.allsolid);
1778
1779                 // this trace.fraction < 1 check causes items to fall off of pushers
1780                 // if they pass under or through a wall
1781                 // the groundentity check causes items to fall off of ledges
1782                 if (check->fields.server->movetype != MOVETYPE_WALK && (trace.fraction < 1 || PRVM_PROG_TO_EDICT(check->fields.server->groundentity) != pusher))
1783                         check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
1784
1785                 // if it is still inside the pusher, block
1786                 Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, 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);
1787                 if (trace.startsolid)
1788                 {
1789                         // try moving the contacted entity a tiny bit further to account for precision errors
1790                         vec3_t move2;
1791                         pusher->fields.server->solid = SOLID_NOT;
1792                         VectorScale(move, 1.1, move2);
1793                         VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
1794                         VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
1795                         if(!SV_PushEntity (&trace2, check, move2, true, true))
1796                         {
1797                                 // entity "check" got teleported
1798                                 continue;
1799                         }
1800                         pusher->fields.server->solid = savesolid;
1801                         Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, 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);
1802                         if (trace.startsolid)
1803                         {
1804                                 // try moving the contacted entity a tiny bit less to account for precision errors
1805                                 pusher->fields.server->solid = SOLID_NOT;
1806                                 VectorScale(move, 0.9, move2);
1807                                 VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
1808                                 VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
1809                                 if(!SV_PushEntity (&trace2, check, move2, true, true))
1810                                 {
1811                                         // entity "check" got teleported
1812                                         continue;
1813                                 }
1814                                 pusher->fields.server->solid = savesolid;
1815                                 Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, 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);
1816                                 if (trace.startsolid)
1817                                 {
1818                                         // still inside pusher, so it's really blocked
1819
1820                                         // fail the move
1821                                         if (check->fields.server->mins[0] == check->fields.server->maxs[0])
1822                                                 continue;
1823                                         if (check->fields.server->solid == SOLID_NOT || check->fields.server->solid == SOLID_TRIGGER)
1824                                         {
1825                                                 // corpse
1826                                                 check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
1827                                                 VectorCopy (check->fields.server->mins, check->fields.server->maxs);
1828                                                 continue;
1829                                         }
1830
1831                                         VectorCopy (pushorig, pusher->fields.server->origin);
1832                                         VectorCopy (pushang, pusher->fields.server->angles);
1833                                         pusher->fields.server->ltime = pushltime;
1834                                         SV_LinkEdict(pusher);
1835
1836                                         // move back any entities we already moved
1837                                         for (i = 0;i < num_moved;i++)
1838                                         {
1839                                                 prvm_edict_t *ed = PRVM_EDICT_NUM(moved_edicts[i]);
1840                                                 VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
1841                                                 VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
1842                                                 SV_LinkEdict(ed);
1843                                         }
1844
1845                                         // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
1846                                         if (pusher->fields.server->blocked)
1847                                         {
1848                                                 prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
1849                                                 prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
1850                                                 PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
1851                                         }
1852                                         break;
1853                                 }
1854                         }
1855                 }
1856         }
1857         pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
1858         pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
1859         pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
1860 }
1861
1862 /*
1863 ================
1864 SV_Physics_Pusher
1865
1866 ================
1867 */
1868 void SV_Physics_Pusher (prvm_edict_t *ent)
1869 {
1870         float thinktime, oldltime, movetime;
1871
1872         oldltime = ent->fields.server->ltime;
1873
1874         thinktime = ent->fields.server->nextthink;
1875         if (thinktime < ent->fields.server->ltime + sv.frametime)
1876         {
1877                 movetime = thinktime - ent->fields.server->ltime;
1878                 if (movetime < 0)
1879                         movetime = 0;
1880         }
1881         else
1882                 movetime = sv.frametime;
1883
1884         if (movetime)
1885                 // advances ent->fields.server->ltime if not blocked
1886                 SV_PushMove (ent, movetime);
1887
1888         if (thinktime > oldltime && thinktime <= ent->fields.server->ltime)
1889         {
1890                 ent->fields.server->nextthink = 0;
1891                 prog->globals.server->time = sv.time;
1892                 prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
1893                 prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
1894                 PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
1895         }
1896 }
1897
1898
1899 /*
1900 ===============================================================================
1901
1902 CLIENT MOVEMENT
1903
1904 ===============================================================================
1905 */
1906
1907 static float unstickoffsets[] =
1908 {
1909         // poutting -/+z changes first as they are least weird
1910          0,  0,  -1,
1911          0,  0,  1,
1912          // x or y changes
1913         -1,  0,  0,
1914          1,  0,  0,
1915          0, -1,  0,
1916          0,  1,  0,
1917          // x and y changes
1918         -1, -1,  0,
1919          1, -1,  0,
1920         -1,  1,  0,
1921          1,  1,  0,
1922 };
1923
1924 typedef enum unstickresult_e
1925 {
1926         UNSTICK_STUCK = 0,
1927         UNSTICK_GOOD = 1,
1928         UNSTICK_UNSTUCK = 2
1929 }
1930 unstickresult_t;
1931
1932 unstickresult_t SV_UnstickEntityReturnOffset (prvm_edict_t *ent, vec3_t offset)
1933 {
1934         int i, maxunstick;
1935
1936         // if not stuck in a bmodel, just return
1937         if (!SV_TestEntityPosition(ent, vec3_origin))
1938                 return UNSTICK_GOOD;
1939
1940         for (i = 0;i < (int)(sizeof(unstickoffsets) / sizeof(unstickoffsets[0]));i += 3)
1941         {
1942                 if (!SV_TestEntityPosition(ent, unstickoffsets + i))
1943                 {
1944                         VectorCopy(unstickoffsets + i, offset);
1945                         SV_LinkEdict(ent);
1946                         //SV_LinkEdict_TouchAreaGrid(ent);
1947                         return UNSTICK_UNSTUCK;
1948                 }
1949         }
1950
1951         maxunstick = (int) ((ent->fields.server->maxs[2] - ent->fields.server->mins[2]) * 0.36);
1952         // magic number 0.36 allows unsticking by up to 17 units with the largest supported bbox
1953
1954         for(i = 2; i <= maxunstick; ++i)
1955         {
1956                 VectorClear(offset);
1957                 offset[2] = -i;
1958                 if (!SV_TestEntityPosition(ent, offset))
1959                 {
1960                         SV_LinkEdict(ent);
1961                         //SV_LinkEdict_TouchAreaGrid(ent);
1962                         return UNSTICK_UNSTUCK;
1963                 }
1964                 offset[2] = i;
1965                 if (!SV_TestEntityPosition(ent, offset))
1966                 {
1967                         SV_LinkEdict(ent);
1968                         //SV_LinkEdict_TouchAreaGrid(ent);
1969                         return UNSTICK_UNSTUCK;
1970                 }
1971         }
1972
1973         return UNSTICK_STUCK;
1974 }
1975
1976 qboolean SV_UnstickEntity (prvm_edict_t *ent)
1977 {
1978         vec3_t offset;
1979         switch(SV_UnstickEntityReturnOffset(ent, offset))
1980         {
1981                 case UNSTICK_GOOD:
1982                         return true;
1983                 case UNSTICK_UNSTUCK:
1984                         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), offset[0], offset[1], offset[2]);
1985                         return true;
1986                 case UNSTICK_STUCK:
1987                         if (developer_extra.integer)
1988                                 Con_DPrintf("Stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
1989                         return false;
1990                 default:
1991                         Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");
1992                         return false;
1993         }
1994 }
1995
1996 /*
1997 =============
1998 SV_CheckStuck
1999
2000 This is a big hack to try and fix the rare case of getting stuck in the world
2001 clipping hull.
2002 =============
2003 */
2004 void SV_CheckStuck (prvm_edict_t *ent)
2005 {
2006         vec3_t offset;
2007
2008         switch(SV_UnstickEntityReturnOffset(ent, offset))
2009         {
2010                 case UNSTICK_GOOD:
2011                         VectorCopy (ent->fields.server->origin, ent->fields.server->oldorigin);
2012                         break;
2013                 case UNSTICK_UNSTUCK:
2014                         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), offset[0], offset[1], offset[2]);
2015                         break;
2016                 case UNSTICK_STUCK:
2017                         VectorSubtract(ent->fields.server->oldorigin, ent->fields.server->origin, offset);
2018                         if (!SV_TestEntityPosition(ent, offset))
2019                         {
2020                                 Con_DPrintf("Unstuck player entity %i (classname \"%s\") by restoring oldorigin.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
2021                                 SV_LinkEdict(ent);
2022                                 //SV_LinkEdict_TouchAreaGrid(ent);
2023                         }
2024                         else
2025                                 Con_DPrintf("Stuck player entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
2026                         break;
2027                 default:
2028                         Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");
2029         }
2030 }
2031
2032
2033 /*
2034 =============
2035 SV_CheckWater
2036 =============
2037 */
2038 qboolean SV_CheckWater (prvm_edict_t *ent)
2039 {
2040         int cont;
2041         int nNativeContents;
2042         vec3_t point;
2043
2044         point[0] = ent->fields.server->origin[0];
2045         point[1] = ent->fields.server->origin[1];
2046         point[2] = ent->fields.server->origin[2] + ent->fields.server->mins[2] + 1;
2047
2048         // DRESK - Support for Entity Contents Transition Event
2049         // NOTE: Some logic needed to be slightly re-ordered
2050         // to not affect performance and allow for the feature.
2051
2052         // Acquire Super Contents Prior to Resets
2053         cont = SV_PointSuperContents(point);
2054         // Acquire Native Contents Here
2055         nNativeContents = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, cont);
2056
2057         // DRESK - Support for Entity Contents Transition Event
2058         if(ent->fields.server->watertype)
2059                 // Entity did NOT Spawn; Check
2060                 SV_CheckContentsTransition(ent, nNativeContents);
2061
2062
2063         ent->fields.server->waterlevel = 0;
2064         ent->fields.server->watertype = CONTENTS_EMPTY;
2065         cont = SV_PointSuperContents(point);
2066         if (cont & (SUPERCONTENTS_LIQUIDSMASK))
2067         {
2068                 ent->fields.server->watertype = nNativeContents;
2069                 ent->fields.server->waterlevel = 1;
2070                 point[2] = ent->fields.server->origin[2] + (ent->fields.server->mins[2] + ent->fields.server->maxs[2])*0.5;
2071                 if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
2072                 {
2073                         ent->fields.server->waterlevel = 2;
2074                         point[2] = ent->fields.server->origin[2] + ent->fields.server->view_ofs[2];
2075                         if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
2076                                 ent->fields.server->waterlevel = 3;
2077                 }
2078         }
2079
2080         return ent->fields.server->waterlevel > 1;
2081 }
2082
2083 /*
2084 ============
2085 SV_WallFriction
2086
2087 ============
2088 */
2089 void SV_WallFriction (prvm_edict_t *ent, float *stepnormal)
2090 {
2091         float d, i;
2092         vec3_t forward, into, side;
2093
2094         AngleVectors (ent->fields.server->v_angle, forward, NULL, NULL);
2095         if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
2096         {
2097                 // cut the tangential velocity
2098                 i = DotProduct (stepnormal, ent->fields.server->velocity);
2099                 VectorScale (stepnormal, i, into);
2100                 VectorSubtract (ent->fields.server->velocity, into, side);
2101                 ent->fields.server->velocity[0] = side[0] * (1 + d);
2102                 ent->fields.server->velocity[1] = side[1] * (1 + d);
2103         }
2104 }
2105
2106 #if 0
2107 /*
2108 =====================
2109 SV_TryUnstick
2110
2111 Player has come to a dead stop, possibly due to the problem with limited
2112 float precision at some angle joins in the BSP hull.
2113
2114 Try fixing by pushing one pixel in each direction.
2115
2116 This is a hack, but in the interest of good gameplay...
2117 ======================
2118 */
2119 int SV_TryUnstick (prvm_edict_t *ent, vec3_t oldvel)
2120 {
2121         int i, clip;
2122         vec3_t oldorg, dir;
2123
2124         VectorCopy (ent->fields.server->origin, oldorg);
2125         VectorClear (dir);
2126
2127         for (i=0 ; i<8 ; i++)
2128         {
2129                 // try pushing a little in an axial direction
2130                 switch (i)
2131                 {
2132                         case 0: dir[0] = 2; dir[1] = 0; break;
2133                         case 1: dir[0] = 0; dir[1] = 2; break;
2134                         case 2: dir[0] = -2; dir[1] = 0; break;
2135                         case 3: dir[0] = 0; dir[1] = -2; break;
2136                         case 4: dir[0] = 2; dir[1] = 2; break;
2137                         case 5: dir[0] = -2; dir[1] = 2; break;
2138                         case 6: dir[0] = 2; dir[1] = -2; break;
2139                         case 7: dir[0] = -2; dir[1] = -2; break;
2140                 }
2141
2142                 SV_PushEntity (&trace, ent, dir, false, true);
2143
2144                 // retry the original move
2145                 ent->fields.server->velocity[0] = oldvel[0];
2146                 ent->fields.server->velocity[1] = oldvel[1];
2147                 ent->fields.server->velocity[2] = 0;
2148                 clip = SV_FlyMove (ent, 0.1, NULL, SV_GenericHitSuperContentsMask(ent));
2149
2150                 if (fabs(oldorg[1] - ent->fields.server->origin[1]) > 4
2151                  || fabs(oldorg[0] - ent->fields.server->origin[0]) > 4)
2152                 {
2153                         Con_DPrint("TryUnstick - success.\n");
2154                         return clip;
2155                 }
2156
2157                 // go back to the original pos and try again
2158                 VectorCopy (oldorg, ent->fields.server->origin);
2159         }
2160
2161         // still not moving
2162         VectorClear (ent->fields.server->velocity);
2163         Con_DPrint("TryUnstick - failure.\n");
2164         return 7;
2165 }
2166 #endif
2167
2168 /*
2169 =====================
2170 SV_WalkMove
2171
2172 Only used by players
2173 ======================
2174 */
2175 void SV_WalkMove (prvm_edict_t *ent)
2176 {
2177         int clip, oldonground, originalmove_clip, originalmove_flags, originalmove_groundentity, hitsupercontentsmask, type;
2178         vec3_t upmove, downmove, start_origin, start_velocity, stepnormal, originalmove_origin, originalmove_velocity;
2179         trace_t downtrace, trace;
2180         qboolean applygravity;
2181
2182         // if frametime is 0 (due to client sending the same timestamp twice),
2183         // don't move
2184         if (sv.frametime <= 0)
2185                 return;
2186
2187         SV_CheckStuck (ent);
2188
2189         applygravity = !SV_CheckWater (ent) && ent->fields.server->movetype == MOVETYPE_WALK && ! ((int)ent->fields.server->flags & FL_WATERJUMP);
2190
2191         hitsupercontentsmask = SV_GenericHitSuperContentsMask(ent);
2192
2193         SV_CheckVelocity(ent);
2194
2195         // do a regular slide move unless it looks like you ran into a step
2196         oldonground = (int)ent->fields.server->flags & FL_ONGROUND;
2197
2198         VectorCopy (ent->fields.server->origin, start_origin);
2199         VectorCopy (ent->fields.server->velocity, start_velocity);
2200
2201         clip = SV_FlyMove (ent, sv.frametime, applygravity, NULL, hitsupercontentsmask);
2202
2203         if(sv_gameplayfix_downtracesupportsongroundflag.integer)
2204         if(!(clip & 1))
2205         {
2206                 // only try this if there was no floor in the way in the trace (no,
2207                 // this check seems to be not REALLY necessary, because if clip & 1,
2208                 // our trace will hit that thing too)
2209                 VectorSet(upmove, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] + 1);
2210                 VectorSet(downmove, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] - 1);
2211                 if (ent->fields.server->movetype == MOVETYPE_FLYMISSILE)
2212                         type = MOVE_MISSILE;
2213                 else if (ent->fields.server->solid == SOLID_TRIGGER || ent->fields.server->solid == SOLID_NOT)
2214                         type = MOVE_NOMONSTERS; // only clip against bmodels
2215                 else
2216                         type = MOVE_NORMAL;
2217                 trace = SV_TraceBox(upmove, ent->fields.server->mins, ent->fields.server->maxs, downmove, type, ent, SV_GenericHitSuperContentsMask(ent));
2218                 if(trace.fraction < 1 && trace.plane.normal[2] > 0.7)
2219                         clip |= 1; // but we HAVE found a floor
2220         }
2221
2222         // if the move did not hit the ground at any point, we're not on ground
2223         if(!(clip & 1))
2224                 ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
2225
2226         SV_CheckVelocity(ent);
2227         SV_LinkEdict(ent);
2228         SV_LinkEdict_TouchAreaGrid(ent);
2229
2230         if(clip & 8) // teleport
2231                 return;
2232
2233         if ((int)ent->fields.server->flags & FL_WATERJUMP)
2234                 return;
2235
2236         if (sv_nostep.integer)
2237                 return;
2238
2239         VectorCopy(ent->fields.server->origin, originalmove_origin);
2240         VectorCopy(ent->fields.server->velocity, originalmove_velocity);
2241         originalmove_clip = clip;
2242         originalmove_flags = (int)ent->fields.server->flags;
2243         originalmove_groundentity = ent->fields.server->groundentity;
2244
2245         // if move didn't block on a step, return
2246         if (clip & 2)
2247         {
2248                 // if move was not trying to move into the step, return
2249                 if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
2250                         return;
2251
2252                 if (ent->fields.server->movetype != MOVETYPE_FLY)
2253                 {
2254                         // return if gibbed by a trigger
2255                         if (ent->fields.server->movetype != MOVETYPE_WALK)
2256                                 return;
2257
2258                         // only step up while jumping if that is enabled
2259                         if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))
2260                                 if (!oldonground && ent->fields.server->waterlevel == 0)
2261                                         return;
2262                 }
2263
2264                 // try moving up and forward to go up a step
2265                 // back to start pos
2266                 VectorCopy (start_origin, ent->fields.server->origin);
2267                 VectorCopy (start_velocity, ent->fields.server->velocity);
2268
2269                 // move up
2270                 VectorClear (upmove);
2271                 upmove[2] = sv_stepheight.value;
2272                 if(!SV_PushEntity(&trace, ent, upmove, false, true))
2273                 {
2274                         // we got teleported when upstepping... must abort the move
2275                         return;
2276                 }
2277
2278                 // move forward
2279                 ent->fields.server->velocity[2] = 0;
2280                 clip = SV_FlyMove (ent, sv.frametime, applygravity, stepnormal, hitsupercontentsmask);
2281                 ent->fields.server->velocity[2] += start_velocity[2];
2282                 if(clip & 8)
2283                 {
2284                         // we got teleported when upstepping... must abort the move
2285                         // note that z velocity handling may not be what QC expects here, but we cannot help it
2286                         return;
2287                 }
2288
2289                 SV_CheckVelocity(ent);
2290                 SV_LinkEdict(ent);
2291                 SV_LinkEdict_TouchAreaGrid(ent);
2292
2293                 // check for stuckness, possibly due to the limited precision of floats
2294                 // in the clipping hulls
2295                 if (clip
2296                  && fabs(originalmove_origin[1] - ent->fields.server->origin[1]) < 0.03125
2297                  && fabs(originalmove_origin[0] - ent->fields.server->origin[0]) < 0.03125)
2298                 {
2299                         //Con_Printf("wall\n");
2300                         // stepping up didn't make any progress, revert to original move
2301                         VectorCopy(originalmove_origin, ent->fields.server->origin);
2302                         VectorCopy(originalmove_velocity, ent->fields.server->velocity);
2303                         //clip = originalmove_clip;
2304                         ent->fields.server->flags = originalmove_flags;
2305                         ent->fields.server->groundentity = originalmove_groundentity;
2306                         // now try to unstick if needed
2307                         //clip = SV_TryUnstick (ent, oldvel);
2308                         return;
2309                 }
2310
2311                 //Con_Printf("step - ");
2312
2313                 // extra friction based on view angle
2314                 if (clip & 2 && sv_wallfriction.integer)
2315                         SV_WallFriction (ent, stepnormal);
2316         }
2317         // don't do the down move if stepdown is disabled, moving upward, not in water, or the move started offground or ended onground
2318         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))
2319                 return;
2320
2321         // move down
2322         VectorClear (downmove);
2323         downmove[2] = -sv_stepheight.value + start_velocity[2]*sv.frametime;
2324         if(!SV_PushEntity (&downtrace, ent, downmove, false, true))
2325         {
2326                 // we got teleported when downstepping... must abort the move
2327                 return;
2328         }
2329
2330         if (downtrace.fraction < 1 && downtrace.plane.normal[2] > 0.7)
2331         {
2332                 // this has been disabled so that you can't jump when you are stepping
2333                 // up while already jumping (also known as the Quake2 double jump bug)
2334 #if 0
2335                 // LordHavoc: disabled this check so you can walk on monsters/players
2336                 //if (ent->fields.server->solid == SOLID_BSP)
2337                 {
2338                         //Con_Printf("onground\n");
2339                         ent->fields.server->flags =     (int)ent->fields.server->flags | FL_ONGROUND;
2340                         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(downtrace.ent);
2341                 }
2342 #endif
2343         }
2344         else
2345         {
2346                 //Con_Printf("slope\n");
2347                 // if the push down didn't end up on good ground, use the move without
2348                 // the step up.  This happens near wall / slope combinations, and can
2349                 // cause the player to hop up higher on a slope too steep to climb
2350                 VectorCopy(originalmove_origin, ent->fields.server->origin);
2351                 VectorCopy(originalmove_velocity, ent->fields.server->velocity);
2352                 //clip = originalmove_clip;
2353                 ent->fields.server->flags = originalmove_flags;
2354                 ent->fields.server->groundentity = originalmove_groundentity;
2355         }
2356
2357         SV_CheckVelocity(ent);
2358         SV_LinkEdict(ent);
2359         SV_LinkEdict_TouchAreaGrid(ent);
2360 }
2361
2362 //============================================================================
2363
2364 /*
2365 =============
2366 SV_Physics_Follow
2367
2368 Entities that are "stuck" to another entity
2369 =============
2370 */
2371 void SV_Physics_Follow (prvm_edict_t *ent)
2372 {
2373         vec3_t vf, vr, vu, angles, v;
2374         prvm_edict_t *e;
2375
2376         // regular thinking
2377         if (!SV_RunThink (ent))
2378                 return;
2379
2380         // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
2381         e = PRVM_PROG_TO_EDICT(ent->fields.server->aiment);
2382         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])
2383         {
2384                 // quick case for no rotation
2385                 VectorAdd(e->fields.server->origin, ent->fields.server->view_ofs, ent->fields.server->origin);
2386         }
2387         else
2388         {
2389                 angles[0] = -ent->fields.server->punchangle[0];
2390                 angles[1] =  ent->fields.server->punchangle[1];
2391                 angles[2] =  ent->fields.server->punchangle[2];
2392                 AngleVectors (angles, vf, vr, vu);
2393                 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];
2394                 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];
2395                 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];
2396                 angles[0] = -e->fields.server->angles[0];
2397                 angles[1] =  e->fields.server->angles[1];
2398                 angles[2] =  e->fields.server->angles[2];
2399                 AngleVectors (angles, vf, vr, vu);
2400                 ent->fields.server->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->fields.server->origin[0];
2401                 ent->fields.server->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->fields.server->origin[1];
2402                 ent->fields.server->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->fields.server->origin[2];
2403         }
2404         VectorAdd (e->fields.server->angles, ent->fields.server->v_angle, ent->fields.server->angles);
2405         SV_LinkEdict(ent);
2406         //SV_LinkEdict_TouchAreaGrid(ent);
2407 }
2408
2409 /*
2410 ==============================================================================
2411
2412 TOSS / BOUNCE
2413
2414 ==============================================================================
2415 */
2416
2417 /*
2418 =============
2419 SV_CheckWaterTransition
2420
2421 =============
2422 */
2423 void SV_CheckWaterTransition (prvm_edict_t *ent)
2424 {
2425         int cont;
2426         cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(ent->fields.server->origin));
2427         if (!ent->fields.server->watertype)
2428         {
2429                 // just spawned here
2430                 ent->fields.server->watertype = cont;
2431                 ent->fields.server->waterlevel = 1;
2432                 return;
2433         }
2434
2435         // DRESK - Support for Entity Contents Transition Event
2436         // NOTE: Call here BEFORE updating the watertype below,
2437         // and suppress watersplash sound if a valid function
2438         // call was made to allow for custom "splash" sounds.
2439         if( !SV_CheckContentsTransition(ent, cont) )
2440         { // Contents Transition Function Invalid; Potentially Play Water Sound
2441                 // check if the entity crossed into or out of water
2442                 if (sv_sound_watersplash.string && ((ent->fields.server->watertype == CONTENTS_WATER || ent->fields.server->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME)))
2443                         SV_StartSound (ent, 0, sv_sound_watersplash.string, 255, 1);
2444         }
2445
2446         if (cont <= CONTENTS_WATER)
2447         {
2448                 ent->fields.server->watertype = cont;
2449                 ent->fields.server->waterlevel = 1;
2450         }
2451         else
2452         {
2453                 ent->fields.server->watertype = CONTENTS_EMPTY;
2454                 ent->fields.server->waterlevel = 0;
2455         }
2456 }
2457
2458 /*
2459 =============
2460 SV_Physics_Toss
2461
2462 Toss, bounce, and fly movement.  When onground, do nothing.
2463 =============
2464 */
2465 void SV_Physics_Toss (prvm_edict_t *ent)
2466 {
2467         trace_t trace;
2468         vec3_t move;
2469         vec_t movetime;
2470         int bump;
2471         prvm_edict_t *groundentity;
2472
2473 // if onground, return without moving
2474         if ((int)ent->fields.server->flags & FL_ONGROUND)
2475         {
2476                 groundentity = PRVM_PROG_TO_EDICT(ent->fields.server->groundentity);
2477                 if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)
2478                 {
2479                         // don't stick to ground if onground and moving upward
2480                         ent->fields.server->flags -= FL_ONGROUND;
2481                 }
2482                 else if (!ent->fields.server->groundentity || !sv_gameplayfix_noairborncorpse.integer)
2483                 {
2484                         // we can trust FL_ONGROUND if groundentity is world because it never moves
2485                         return;
2486                 }
2487                 else if (ent->priv.server->suspendedinairflag && groundentity->priv.server->free)
2488                 {
2489                         // if ent was supported by a brush model on previous frame,
2490                         // and groundentity is now freed, set groundentity to 0 (world)
2491                         // which leaves it suspended in the air
2492                         ent->fields.server->groundentity = 0;
2493                         if (sv_gameplayfix_noairborncorpse_allowsuspendeditems.integer)
2494                                 return;
2495                 }
2496                 else if (BoxesOverlap(ent->priv.server->cullmins, ent->priv.server->cullmaxs, groundentity->priv.server->cullmins, groundentity->priv.server->cullmaxs))
2497                 {
2498                         // don't slide if still touching the groundentity
2499                         return;
2500                 }
2501         }
2502         ent->priv.server->suspendedinairflag = false;
2503
2504         SV_CheckVelocity (ent);
2505
2506 // add gravity
2507         if (ent->fields.server->movetype == MOVETYPE_TOSS || ent->fields.server->movetype == MOVETYPE_BOUNCE)
2508                 ent->fields.server->velocity[2] -= SV_Gravity(ent);
2509
2510 // move angles
2511         VectorMA (ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
2512
2513         movetime = sv.frametime;
2514         for (bump = 0;bump < MAX_CLIP_PLANES && movetime > 0;bump++)
2515         {
2516         // move origin
2517                 VectorScale (ent->fields.server->velocity, movetime, move);
2518                 if(!SV_PushEntity (&trace, ent, move, true, true))
2519                         return; // teleported
2520                 if (ent->priv.server->free)
2521                         return;
2522                 if (trace.bmodelstartsolid)
2523                 {
2524                         // try to unstick the entity
2525                         SV_UnstickEntity(ent);
2526                         if(!SV_PushEntity (&trace, ent, move, false, true))
2527                                 return; // teleported
2528                         if (ent->priv.server->free)
2529                                 return;
2530                 }
2531                 if (trace.fraction == 1)
2532                         break;
2533                 movetime *= 1 - min(1, trace.fraction);
2534                 if (ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE)
2535                 {
2536                         prvm_eval_t *val;
2537                         float bouncefactor = 1.0f;
2538                         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.bouncefactor);
2539                         if (val!=0 && val->_float)
2540                                 bouncefactor = val->_float;
2541
2542                         ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1 + bouncefactor);
2543                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
2544                 }
2545                 else if (ent->fields.server->movetype == MOVETYPE_BOUNCE)
2546                 {
2547                         float d, ent_gravity;
2548                         prvm_eval_t *val;
2549                         float bouncefactor = 0.5f;
2550                         float bouncestop = 60.0f / 800.0f;
2551
2552                         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.bouncefactor);
2553                         if (val!=0 && val->_float)
2554                                 bouncefactor = val->_float;
2555
2556                         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.bouncestop);
2557                         if (val!=0 && val->_float)
2558                                 bouncestop = val->_float;
2559
2560                         ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1 + bouncefactor);
2561                         // LordHavoc: fixed grenades not bouncing when fired down a slope
2562                         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.gravity);
2563                         if (val!=0 && val->_float)
2564                                 ent_gravity = val->_float;
2565                         else
2566                                 ent_gravity = 1.0;
2567                         if (sv_gameplayfix_grenadebouncedownslopes.integer)
2568                         {
2569                                 d = DotProduct(trace.plane.normal, ent->fields.server->velocity);
2570                                 if (trace.plane.normal[2] > 0.7 && fabs(d) < sv_gravity.value * bouncestop * ent_gravity)
2571                                 {
2572                                         ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
2573                                         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
2574                                         VectorClear (ent->fields.server->velocity);
2575                                         VectorClear (ent->fields.server->avelocity);
2576                                 }
2577                                 else
2578                                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
2579                         }
2580                         else
2581                         {
2582                                 if (trace.plane.normal[2] > 0.7 && ent->fields.server->velocity[2] < sv_gravity.value * bouncestop * ent_gravity)
2583                                 {
2584                                         ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
2585                                         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
2586                                         VectorClear (ent->fields.server->velocity);
2587                                         VectorClear (ent->fields.server->avelocity);
2588                                 }
2589                                 else
2590                                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
2591                         }
2592                 }
2593                 else
2594                 {
2595                         ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1.0);
2596                         if (trace.plane.normal[2] > 0.7)
2597                         {
2598                                 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
2599                                 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
2600                                 if (((prvm_edict_t *)trace.ent)->fields.server->solid == SOLID_BSP)
2601                                         ent->priv.server->suspendedinairflag = true;
2602                                 VectorClear (ent->fields.server->velocity);
2603                                 VectorClear (ent->fields.server->avelocity);
2604                         }
2605                         else
2606                                 ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
2607                 }
2608                 if (!sv_gameplayfix_slidemoveprojectiles.integer || (ent->fields.server->movetype != MOVETYPE_BOUNCE && ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE) || ((int)ent->fields.server->flags & FL_ONGROUND))
2609                         break;
2610         }
2611
2612 // check for in water
2613         SV_CheckWaterTransition (ent);
2614 }
2615
2616 /*
2617 ===============================================================================
2618
2619 STEPPING MOVEMENT
2620
2621 ===============================================================================
2622 */
2623
2624 /*
2625 =============
2626 SV_Physics_Step
2627
2628 Monsters freefall when they don't have a ground entity, otherwise
2629 all movement is done with discrete steps.
2630
2631 This is also used for objects that have become still on the ground, but
2632 will fall if the floor is pulled out from under them.
2633 =============
2634 */
2635 void SV_Physics_Step (prvm_edict_t *ent)
2636 {
2637         int flags = (int)ent->fields.server->flags;
2638
2639         // DRESK
2640         // Backup Velocity in the event that movetypesteplandevent is called,
2641         // to provide a parameter with the entity's velocity at impact.
2642         prvm_eval_t *movetypesteplandevent;
2643         vec3_t backupVelocity;
2644         VectorCopy(ent->fields.server->velocity, backupVelocity);
2645         // don't fall at all if fly/swim
2646         if (!(flags & (FL_FLY | FL_SWIM)))
2647         {
2648                 if (flags & FL_ONGROUND)
2649                 {
2650                         // freefall if onground and moving upward
2651                         // freefall if not standing on a world surface (it may be a lift or trap door)
2652                         if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)
2653                         {
2654                                 ent->fields.server->flags -= FL_ONGROUND;
2655                                 SV_CheckVelocity(ent);
2656                                 SV_FlyMove(ent, sv.frametime, true, NULL, SV_GenericHitSuperContentsMask(ent));
2657                                 SV_LinkEdict(ent);
2658                                 SV_LinkEdict_TouchAreaGrid(ent);
2659                                 ent->priv.server->waterposition_forceupdate = true;
2660                         }
2661                 }
2662                 else
2663                 {
2664                         // freefall if not onground
2665                         int hitsound = ent->fields.server->velocity[2] < sv_gravity.value * -0.1;
2666
2667                         SV_CheckVelocity(ent);
2668                         SV_FlyMove(ent, sv.frametime, true, NULL, SV_GenericHitSuperContentsMask(ent));
2669                         SV_LinkEdict(ent);
2670                         SV_LinkEdict_TouchAreaGrid(ent);
2671
2672                         // just hit ground
2673                         if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND)
2674                         {
2675                                 // DRESK - Check for Entity Land Event Function
2676                                 movetypesteplandevent = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.movetypesteplandevent);
2677
2678                                 if(movetypesteplandevent->function)
2679                                 { // Valid Function; Execute
2680                                         // Prepare Parameters
2681                                                 // Assign Velocity at Impact
2682                                                 PRVM_G_VECTOR(OFS_PARM0)[0] = backupVelocity[0];
2683                                                 PRVM_G_VECTOR(OFS_PARM0)[1] = backupVelocity[1];
2684                                                 PRVM_G_VECTOR(OFS_PARM0)[2] = backupVelocity[2];
2685                                                 // Assign Self
2686                                                 prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
2687                                         // Execute VM Function
2688                                         PRVM_ExecuteProgram(movetypesteplandevent->function, "movetypesteplandevent: NULL function");
2689                                 }
2690                                 else
2691                                 // Check for Engine Landing Sound
2692                                 if(sv_sound_land.string)
2693                                         SV_StartSound(ent, 0, sv_sound_land.string, 255, 1);
2694                         }
2695                         ent->priv.server->waterposition_forceupdate = true;
2696                 }
2697         }
2698
2699 // regular thinking
2700         if (!SV_RunThink(ent))
2701                 return;
2702
2703         if (ent->priv.server->waterposition_forceupdate || !VectorCompare(ent->fields.server->origin, ent->priv.server->waterposition_origin))
2704         {
2705                 ent->priv.server->waterposition_forceupdate = false;
2706                 VectorCopy(ent->fields.server->origin, ent->priv.server->waterposition_origin);
2707                 SV_CheckWaterTransition(ent);
2708         }
2709 }
2710
2711 //============================================================================
2712
2713 static void SV_Physics_Entity (prvm_edict_t *ent)
2714 {
2715         // don't run think/move on newly spawned projectiles as it messes up
2716         // movement interpolation and rocket trails, and is inconsistent with
2717         // respect to entities spawned in the same frame
2718         // (if an ent spawns a higher numbered ent, it moves in the same frame,
2719         //  but if it spawns a lower numbered ent, it doesn't - this never moves
2720         //  ents in the first frame regardless)
2721         qboolean runmove = ent->priv.server->move;
2722         ent->priv.server->move = true;
2723         if (!runmove && sv_gameplayfix_delayprojectiles.integer > 0)
2724                 return;
2725         switch ((int) ent->fields.server->movetype)
2726         {
2727         case MOVETYPE_PUSH:
2728         case MOVETYPE_FAKEPUSH:
2729                 SV_Physics_Pusher (ent);
2730                 break;
2731         case MOVETYPE_NONE:
2732                 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
2733                 if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
2734                         SV_RunThink (ent);
2735                 break;
2736         case MOVETYPE_FOLLOW:
2737                 SV_Physics_Follow (ent);
2738                 break;
2739         case MOVETYPE_NOCLIP:
2740                 if (SV_RunThink(ent))
2741                 {
2742                         SV_CheckWater(ent);
2743                         VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
2744                         VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
2745                 }
2746                 SV_LinkEdict(ent);
2747                 break;
2748         case MOVETYPE_STEP:
2749                 SV_Physics_Step (ent);
2750                 break;
2751         case MOVETYPE_WALK:
2752                 if (SV_RunThink (ent))
2753                         SV_WalkMove (ent);
2754                 break;
2755         case MOVETYPE_TOSS:
2756         case MOVETYPE_BOUNCE:
2757         case MOVETYPE_BOUNCEMISSILE:
2758         case MOVETYPE_FLYMISSILE:
2759         case MOVETYPE_FLY:
2760                 // regular thinking
2761                 if (SV_RunThink (ent))
2762                         SV_Physics_Toss (ent);
2763                 break;
2764         case MOVETYPE_PHYSICS:
2765                 if (SV_RunThink(ent))
2766                 {
2767                         SV_LinkEdict(ent);
2768                         SV_LinkEdict_TouchAreaGrid(ent);
2769                 }
2770                 break;
2771         default:
2772                 Con_Printf ("SV_Physics: bad movetype %i\n", (int)ent->fields.server->movetype);
2773                 break;
2774         }
2775 }
2776
2777 void SV_Physics_ClientMove(void)
2778 {
2779         prvm_edict_t *ent;
2780         ent = host_client->edict;
2781
2782         // call player physics, this needs the proper frametime
2783         prog->globals.server->frametime = sv.frametime;
2784         SV_ClientThink();
2785
2786         // call standard client pre-think, with frametime = 0
2787         prog->globals.server->time = sv.time;
2788         prog->globals.server->frametime = 0;
2789         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
2790         PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
2791         prog->globals.server->frametime = sv.frametime;
2792
2793         // make sure the velocity is sane (not a NaN)
2794         SV_CheckVelocity(ent);
2795
2796         // perform MOVETYPE_WALK behavior
2797         SV_WalkMove (ent);
2798
2799         // call standard player post-think, with frametime = 0
2800         prog->globals.server->time = sv.time;
2801         prog->globals.server->frametime = 0;
2802         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
2803         PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
2804         prog->globals.server->frametime = sv.frametime;
2805
2806         if(ent->fields.server->fixangle)
2807         {
2808                 // angle fixing was requested by physics code...
2809                 // so store the current angles for later use
2810                 memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
2811                 host_client->fixangle_angles_set = TRUE;
2812
2813                 // and clear fixangle for the next frame
2814                 ent->fields.server->fixangle = 0;
2815         }
2816 }
2817
2818 static void SV_Physics_ClientEntity_PreThink(prvm_edict_t *ent)
2819 {
2820         // don't do physics on disconnected clients, FrikBot relies on this
2821         if (!host_client->spawned)
2822                 return;
2823
2824         // make sure the velocity is sane (not a NaN)
2825         SV_CheckVelocity(ent);
2826
2827         // don't run physics here if running asynchronously
2828         if (host_client->clmovement_inputtimeout <= 0)
2829         {
2830                 SV_ClientThink();
2831                 //host_client->cmd.time = max(host_client->cmd.time, sv.time);
2832         }
2833
2834         // make sure the velocity is still sane (not a NaN)
2835         SV_CheckVelocity(ent);
2836
2837         // call standard client pre-think
2838         prog->globals.server->time = sv.time;
2839         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
2840         PRVM_ExecuteProgram(prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
2841
2842         // make sure the velocity is still sane (not a NaN)
2843         SV_CheckVelocity(ent);
2844 }
2845
2846 static void SV_Physics_ClientEntity_PostThink(prvm_edict_t *ent)
2847 {
2848         // don't do physics on disconnected clients, FrikBot relies on this
2849         if (!host_client->spawned)
2850                 return;
2851
2852         // make sure the velocity is sane (not a NaN)
2853         SV_CheckVelocity(ent);
2854
2855         // call standard player post-think
2856         prog->globals.server->time = sv.time;
2857         prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
2858         PRVM_ExecuteProgram(prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
2859
2860         // make sure the velocity is still sane (not a NaN)
2861         SV_CheckVelocity(ent);
2862
2863         if(ent->fields.server->fixangle)
2864         {
2865                 // angle fixing was requested by physics code...
2866                 // so store the current angles for later use
2867                 memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
2868                 host_client->fixangle_angles_set = TRUE;
2869
2870                 // and clear fixangle for the next frame
2871                 ent->fields.server->fixangle = 0;
2872         }
2873
2874         // decrement the countdown variable used to decide when to go back to
2875         // synchronous physics
2876         if (host_client->clmovement_inputtimeout > sv.frametime)
2877                 host_client->clmovement_inputtimeout -= sv.frametime;
2878         else
2879                 host_client->clmovement_inputtimeout = 0;
2880 }
2881
2882 static void SV_Physics_ClientEntity(prvm_edict_t *ent)
2883 {
2884         // don't do physics on disconnected clients, FrikBot relies on this
2885         if (!host_client->spawned)
2886         {
2887                 memset(&host_client->cmd, 0, sizeof(host_client->cmd));
2888                 return;
2889         }
2890
2891         // make sure the velocity is sane (not a NaN)
2892         SV_CheckVelocity(ent);
2893
2894         switch ((int) ent->fields.server->movetype)
2895         {
2896         case MOVETYPE_PUSH:
2897         case MOVETYPE_FAKEPUSH:
2898                 SV_Physics_Pusher (ent);
2899                 break;
2900         case MOVETYPE_NONE:
2901                 // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
2902                 if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
2903                         SV_RunThink (ent);
2904                 break;
2905         case MOVETYPE_FOLLOW:
2906                 SV_Physics_Follow (ent);
2907                 break;
2908         case MOVETYPE_NOCLIP:
2909                 SV_RunThink(ent);
2910                 SV_CheckWater(ent);
2911                 VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
2912                 VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
2913                 break;
2914         case MOVETYPE_STEP:
2915                 SV_Physics_Step (ent);
2916                 break;
2917         case MOVETYPE_WALK:
2918                 SV_RunThink (ent);
2919                 // don't run physics here if running asynchronously
2920                 if (host_client->clmovement_inputtimeout <= 0)
2921                         SV_WalkMove (ent);
2922                 break;
2923         case MOVETYPE_TOSS:
2924         case MOVETYPE_BOUNCE:
2925         case MOVETYPE_BOUNCEMISSILE:
2926         case MOVETYPE_FLYMISSILE:
2927                 // regular thinking
2928                 SV_RunThink (ent);
2929                 SV_Physics_Toss (ent);
2930                 break;
2931         case MOVETYPE_FLY:
2932                 SV_RunThink (ent);
2933                 SV_WalkMove (ent);
2934                 break;
2935         case MOVETYPE_PHYSICS:
2936                 SV_RunThink (ent);
2937                 break;
2938         default:
2939                 Con_Printf ("SV_Physics_ClientEntity: bad movetype %i\n", (int)ent->fields.server->movetype);
2940                 break;
2941         }
2942
2943         SV_CheckVelocity (ent);
2944
2945         SV_LinkEdict(ent);
2946         SV_LinkEdict_TouchAreaGrid(ent);
2947
2948         SV_CheckVelocity (ent);
2949 }
2950
2951 /*
2952 ================
2953 SV_Physics
2954
2955 ================
2956 */
2957 void SV_Physics (void)
2958 {
2959         int i;
2960         prvm_edict_t *ent;
2961
2962 // let the progs know that a new frame has started
2963         prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
2964         prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
2965         prog->globals.server->time = sv.time;
2966         prog->globals.server->frametime = sv.frametime;
2967         PRVM_ExecuteProgram (prog->globals.server->StartFrame, "QC function StartFrame is missing");
2968
2969         // run physics engine
2970         World_Physics_Frame(&sv.world, sv.frametime, sv_gravity.value);
2971
2972 //
2973 // treat each object in turn
2974 //
2975
2976         // if force_retouch, relink all the entities
2977         if (prog->globals.server->force_retouch > 0)
2978                 for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
2979                         if (!ent->priv.server->free)
2980                                 SV_LinkEdict_TouchAreaGrid(ent); // force retouch even for stationary
2981
2982         if (sv_gameplayfix_consistentplayerprethink.integer)
2983         {
2984                 // run physics on the client entities in 3 stages
2985                 for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
2986                         if (!ent->priv.server->free)
2987                                 SV_Physics_ClientEntity_PreThink(ent);
2988
2989                 for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
2990                         if (!ent->priv.server->free)
2991                                 SV_Physics_ClientEntity(ent);
2992
2993                 for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
2994                         if (!ent->priv.server->free)
2995                                 SV_Physics_ClientEntity_PostThink(ent);
2996         }
2997         else
2998         {
2999                 // run physics on the client entities
3000                 for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
3001                 {
3002                         if (!ent->priv.server->free)
3003                         {
3004                                 SV_Physics_ClientEntity_PreThink(ent);
3005                                 SV_Physics_ClientEntity(ent);
3006                                 SV_Physics_ClientEntity_PostThink(ent);
3007                         }
3008                 }
3009         }
3010
3011         // run physics on all the non-client entities
3012         if (!sv_freezenonclients.integer)
3013         {
3014                 for (;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
3015                         if (!ent->priv.server->free)
3016                                 SV_Physics_Entity(ent);
3017                 // make a second pass to see if any ents spawned this frame and make
3018                 // sure they run their move/think
3019                 if (sv_gameplayfix_delayprojectiles.integer < 0)
3020                         for (i = svs.maxclients + 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
3021                                 if (!ent->priv.server->move && !ent->priv.server->free)
3022                                         SV_Physics_Entity(ent);
3023         }
3024
3025         if (prog->globals.server->force_retouch > 0)
3026                 prog->globals.server->force_retouch = max(0, prog->globals.server->force_retouch - 1);
3027
3028         // LordHavoc: endframe support
3029         if (prog->funcoffsets.EndFrame)
3030         {
3031                 prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
3032                 prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
3033                 prog->globals.server->time = sv.time;
3034                 PRVM_ExecuteProgram (prog->funcoffsets.EndFrame, "QC function EndFrame is missing");
3035         }
3036
3037         // decrement prog->num_edicts if the highest number entities died
3038         for (;PRVM_ED_CanAlloc(PRVM_EDICT_NUM(prog->num_edicts - 1));prog->num_edicts--);
3039
3040         if (!sv_freezenonclients.integer)
3041                 sv.time += sv.frametime;
3042 }