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