sv_phys.c

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