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