qcsrc/ecs/systems/physics.qc

   1 #include "physics.qh"
   2 #include "input.qh"
   3
   4 .int disableclientprediction;
   5
   6 void sys_phys_simulate(entity this, float dt);
   7 void sys_phys_simulate_simple(entity this, float dt);
   8
   9 void sys_phys_update(entity this, float dt)
  10 {
  11         if (!IS_CLIENT(this)) {
  12                 sys_phys_simulate_simple(this, dt);
  13                 return;
  14         }
  15         sys_in_update(this, dt);
  16
  17         sys_phys_fix(this, dt);
  18         if (sys_phys_override(this)) { return; } sys_phys_monitor(this);
  19
  20         this.buttons_old = PHYS_INPUT_BUTTON_MASK(this);
  21         this.movement_old = this.movement;
  22         this.v_angle_old = this.v_angle;
  23
  24         sys_phys_ai(this);
  25
  26         sys_phys_pregame_hold(this);
  27
  28         if (IS_SVQC) {
  29                 if (PHYS_MOVETYPE(this) == MOVETYPE_NONE) { return; }
  30                 // when we get here, disableclientprediction cannot be 2
  31                 this.disableclientprediction = 0;
  32         }
  33
  34         viewloc_PlayerPhysics(this);
  35
  36         PM_check_frozen(this);
  37
  38         PM_check_blocked(this);
  39
  40         float maxspeed_mod = (!this.in_swamp) ? 1 : this.swamp_slowdown;  // cvar("g_balance_swamp_moverate");
  41
  42 // conveyors: first fix velocity
  43         if (this.conveyor.state) { this.velocity -= this.conveyor.movedir; }
  44         MUTATOR_CALLHOOK(PlayerPhysics, this);
  45
  46         if (!IS_PLAYER(this)) {
  47                 sys_phys_spectator_control(this);
  48                 maxspeed_mod = this.spectatorspeed;
  49         }
  50         sys_phys_fixspeed(this, maxspeed_mod);
  51
  52         if (IS_DEAD(this)) {
  53                 // handle water here
  54                 vector midpoint = ((this.absmin + this.absmax) * 0.5);
  55                 if (pointcontents(midpoint) == CONTENT_WATER) {
  56                         this.velocity = this.velocity * 0.5;
  57
  58                         // do we want this?
  59                         // if(pointcontents(midpoint + '0 0 2') == CONTENT_WATER)
  60                         // { this.velocity_z = 70; }
  61                 }
  62                 goto end;
  63         }
  64
  65         if (IS_SVQC && !PHYS_FIXANGLE(this)) { this.angles = '0 1 0' * this.v_angle.y; }
  66         if (IS_PLAYER(this)) {
  67                 if (IS_ONGROUND(this)) {
  68                         PM_check_hitground(this);
  69                         PM_Footsteps(this);
  70                 } else if (IsFlying(this)) {
  71                         this.wasFlying = true;
  72                 }
  73                 CheckPlayerJump(this);
  74         }
  75
  76         if (this.flags & FL_WATERJUMP) {
  77                 this.velocity_x = this.movedir.x;
  78                 this.velocity_y = this.movedir.y;
  79                 if (time > PHYS_TELEPORT_TIME(this)
  80                     || this.waterlevel == WATERLEVEL_NONE
  81                     || PHYS_WATERJUMP_TIME(this) <= 0
  82                    ) {
  83                         this.flags &= ~FL_WATERJUMP;
  84                         PHYS_TELEPORT_TIME(this) = 0;
  85                         PHYS_WATERJUMP_TIME(this) = 0;
  86                 }
  87         } else if (MUTATOR_CALLHOOK(PM_Physics, this, maxspeed_mod)) {
  88                 // handled
  89         } else if (PHYS_MOVETYPE(this) == MOVETYPE_NOCLIP
  90             || PHYS_MOVETYPE(this) == MOVETYPE_FLY
  91             || PHYS_MOVETYPE(this) == MOVETYPE_FLY_WORLDONLY
  92             || MUTATOR_CALLHOOK(IsFlying, this)) {
  93                 this.com_phys_friction = PHYS_FRICTION(this);
  94                 this.com_phys_vel_max = PHYS_MAXSPEED(this) * maxspeed_mod;
  95                 this.com_phys_acc_rate = PHYS_ACCELERATE(this) * maxspeed_mod;
  96                 this.com_phys_friction_air = true;
  97                 sys_phys_simulate(this, dt);
  98                 this.com_phys_friction_air = false;
  99         } else if (this.waterlevel >= WATERLEVEL_SWIMMING) {
 100                 this.com_phys_vel_max = PHYS_MAXSPEED(this) * maxspeed_mod;
 101                 this.com_phys_acc_rate = PHYS_ACCELERATE(this) * maxspeed_mod;
 102                 this.com_phys_water = true;
 103                 sys_phys_simulate(this, dt);
 104                 this.com_phys_water = false;
 105         } else if (time < this.ladder_time) {
 106                 this.com_phys_friction = PHYS_FRICTION(this);
 107                 this.com_phys_vel_max = PHYS_MAXSPEED(this) * maxspeed_mod;
 108                 this.com_phys_acc_rate = PHYS_ACCELERATE(this) * maxspeed_mod;
 109                 this.com_phys_gravity = '0 0 -1' * PHYS_GRAVITY(this) * dt;
 110                 if (PHYS_ENTGRAVITY(this)) { this.com_phys_gravity *= PHYS_ENTGRAVITY(this); }
 111                 this.com_phys_ladder = true;
 112                 this.com_phys_friction_air = true;
 113                 sys_phys_simulate(this, dt);
 114                 this.com_phys_friction_air = false;
 115                 this.com_phys_ladder = false;
 116                 this.com_phys_gravity = '0 0 0';
 117         } else if (ITEMS_STAT(this) & IT_USING_JETPACK) {
 118                 PM_jetpack(this, maxspeed_mod);
 119         } else if (IS_ONGROUND(this)) {
 120                 if (!WAS_ONGROUND(this)) {
 121                         emit(phys_land, this);
 122                         if (this.lastground < time - 0.3) {
 123                                 this.velocity *= (1 - PHYS_FRICTION_ONLAND(this));
 124                         }
 125                 }
 126                 this.com_phys_vel_max = PHYS_MAXSPEED(this) * maxspeed_mod;
 127                 this.com_phys_gravity = '0 0 -1' * PHYS_GRAVITY(this) * dt;
 128                 if (PHYS_ENTGRAVITY(this)) { this.com_phys_gravity *= PHYS_ENTGRAVITY(this); }
 129                 this.com_phys_ground = true;
 130                 this.com_phys_vel_2d = true;
 131                 sys_phys_simulate(this, dt);
 132                 this.com_phys_vel_2d = false;
 133                 this.com_phys_ground = false;
 134                 this.com_phys_gravity = '0 0 0';
 135         } else {
 136                 this.com_phys_acc_rate_air = PHYS_AIRACCELERATE(this) * min(maxspeed_mod, 1);
 137                 this.com_phys_acc_rate_air_stop = PHYS_AIRSTOPACCELERATE(this) * maxspeed_mod;
 138                 this.com_phys_acc_rate_air_strafe = PHYS_AIRSTRAFEACCELERATE(this) * maxspeed_mod;
 139                 this.com_phys_vel_max_air_strafe = PHYS_MAXAIRSTRAFESPEED(this) * maxspeed_mod;
 140                 this.com_phys_vel_max_air = PHYS_MAXAIRSPEED(this) * maxspeed_mod;
 141                 this.com_phys_vel_max = PHYS_MAXAIRSPEED(this) * min(maxspeed_mod, 1);
 142                 this.com_phys_air = true;
 143                 this.com_phys_vel_2d = true;
 144                 sys_phys_simulate(this, dt);
 145                 this.com_phys_vel_2d = false;
 146                 this.com_phys_air = false;
 147         }
 148
 149         LABEL(end)
 150         if (IS_ONGROUND(this)) { this.lastground = time; }
 151 // conveyors: then break velocity again
 152         if (this.conveyor.state) { this.velocity += this.conveyor.movedir; }
 153         this.lastflags = this.flags;
 154
 155         this.lastclassname = this.classname;
 156 }
 157
 158 /** for players */
 159 void sys_phys_simulate(entity this, float dt)
 160 {
 161         const vector g = -this.com_phys_gravity;
 162         const bool jump = this.com_in_jump;
 163
 164         if (!this.com_phys_ground && !this.com_phys_air) {
 165                 // noclipping
 166                 // flying
 167                 // on a spawnfunc_func_ladder
 168                 // swimming in spawnfunc_func_water
 169                 // swimming
 170                 UNSET_ONGROUND(this);
 171
 172                 if (this.com_phys_friction_air) {
 173                         this.velocity_z += g.z / 2;
 174                         this.velocity = this.velocity * (1 - dt * this.com_phys_friction);
 175                         this.velocity_z += g.z / 2;
 176                 }
 177         }
 178
 179         if (this.com_phys_water) {
 180                 // water jump only in certain situations
 181                 // this mimics quakeworld code
 182                 if (jump && this.waterlevel == WATERLEVEL_SWIMMING && this.velocity_z >= -180 && !this.viewloc) {
 183                         vector yawangles = '0 1 0' * this.v_angle.y;
 184                         makevectors(yawangles);
 185                         vector forward = v_forward;
 186                         vector spot = this.origin + 24 * forward;
 187                         spot_z += 8;
 188                         traceline(spot, spot, MOVE_NOMONSTERS, this);
 189                         if (trace_startsolid) {
 190                                 spot_z += 24;
 191                                 traceline(spot, spot, MOVE_NOMONSTERS, this);
 192                                 if (!trace_startsolid) {
 193                                         this.velocity = forward * 50;
 194                                         this.velocity_z = 310;
 195                                         if (IS_CSQC) { PHYS_WATERJUMP_TIME(this) = 2; }
 196                                         UNSET_ONGROUND(this);
 197                                         SET_JUMP_HELD(this);
 198                                 }
 199                         }
 200                 }
 201         }
 202         makevectors(vmul(this.v_angle, (this.com_phys_vel_2d ? '0 1 0' : '1 1 1')));
 203         // wishvel = v_forward * this.movement.x + v_right * this.movement.y + v_up * this.movement.z;
 204         vector wishvel = v_forward * this.movement.x
 205             + v_right * this.movement.y
 206             + '0 0 1' * this.movement.z * (this.com_phys_vel_2d ? 0 : 1);
 207         if (this.com_phys_water) {
 208                 if (this.viewloc) {
 209                         wishvel.z = -160;    // drift anyway
 210                 } else if (wishvel == '0 0 0') {
 211                         wishvel = '0 0 -60'; // drift towards bottom
 212                 }
 213         }
 214         if (this.com_phys_ladder) {
 215                 if (this.viewloc) {
 216                         wishvel.z = this.oldmovement.x;
 217                 }
 218                 if (this.ladder_entity.classname == "func_water") {
 219                         float f = vlen(wishvel);
 220                         if (f > this.ladder_entity.speed) {
 221                                 wishvel *= (this.ladder_entity.speed / f);
 222                         }
 223
 224                         this.watertype = this.ladder_entity.skin;
 225                         f = this.ladder_entity.origin_z + this.ladder_entity.maxs_z;
 226                         if ((this.origin_z + this.view_ofs_z) < f) {
 227                                 this.waterlevel = WATERLEVEL_SUBMERGED;
 228                         } else if ((this.origin_z + (this.mins_z + this.maxs_z) * 0.5) < f) {
 229                                 this.waterlevel = WATERLEVEL_SWIMMING;
 230                         } else if ((this.origin_z + this.mins_z + 1) < f) {
 231                                 this.waterlevel = WATERLEVEL_WETFEET;
 232                         } else {
 233                                 this.waterlevel = WATERLEVEL_NONE;
 234                                 this.watertype = CONTENT_EMPTY;
 235                         }
 236                 }
 237         }
 238         // acceleration
 239         const vector wishdir = normalize(wishvel);
 240         float wishspeed = min(vlen(wishvel), this.com_phys_vel_max);
 241
 242         if (this.com_phys_air) {
 243                 if ((IS_SVQC && time >= PHYS_TELEPORT_TIME(this))
 244                     ||  (IS_CSQC && PHYS_WATERJUMP_TIME(this) <= 0)) {
 245                         // apply air speed limit
 246                         float airaccelqw = PHYS_AIRACCEL_QW(this);
 247                         float wishspeed0 = wishspeed;
 248                         const float maxairspd = this.com_phys_vel_max;
 249                         wishspeed = min(wishspeed, maxairspd);
 250                         if (IS_DUCKED(this)) {
 251                                 wishspeed *= 0.5;
 252                         }
 253                         float airaccel = this.com_phys_acc_rate_air;
 254
 255                         float accelerating = (this.velocity * wishdir > 0);
 256                         float wishspeed2 = wishspeed;
 257
 258                         // CPM: air control
 259                         if (PHYS_AIRSTOPACCELERATE(this)) {
 260                                 vector curdir = normalize(vec2(this.velocity));
 261                                 airaccel += (this.com_phys_acc_rate_air_stop - airaccel) * max(0, -(curdir * wishdir));
 262                         }
 263                         // note that for straight forward jumping:
 264                         // step = accel * PHYS_INPUT_TIMELENGTH * wishspeed0;
 265                         // accel  = bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
 266                         // -->
 267                         // dv/dt = accel * maxspeed (when slow)
 268                         // dv/dt = accel * maxspeed * (1 - accelqw) (when fast)
 269                         // log dv/dt = logaccel + logmaxspeed (when slow)
 270                         // log dv/dt = logaccel + logmaxspeed + log(1 - accelqw) (when fast)
 271                         float strafity = IsMoveInDirection(this.movement, -90) + IsMoveInDirection(this.movement, +90);  // if one is nonzero, other is always zero
 272                         if (PHYS_MAXAIRSTRAFESPEED(this)) {
 273                                 wishspeed =
 274                                     min(wishspeed,
 275                                         GeomLerp(this.com_phys_vel_max_air, strafity, this.com_phys_vel_max_air_strafe));
 276                         }
 277                         if (PHYS_AIRSTRAFEACCELERATE(this)) {
 278                                 airaccel = GeomLerp(airaccel, strafity, this.com_phys_acc_rate_air_strafe);
 279                         }
 280                         if (PHYS_AIRSTRAFEACCEL_QW(this)) {
 281                                 airaccelqw =
 282                                     (((strafity > 0.5 ? PHYS_AIRSTRAFEACCEL_QW(this) : PHYS_AIRACCEL_QW(this)) >= 0) ? +1 : -1)
 283                                     *
 284                                     (1 - GeomLerp(1 - fabs(PHYS_AIRACCEL_QW(this)), strafity, 1 - fabs(PHYS_AIRSTRAFEACCEL_QW(this))));
 285                         }
 286                         // !CPM
 287
 288                         if (PHYS_WARSOWBUNNY_TURNACCEL(this) && accelerating && this.movement.y == 0 && this.movement.x != 0) {
 289                                 PM_AirAccelerate(this, wishdir, wishspeed2);
 290                         } else {
 291                                 float sidefric = maxairspd ? (PHYS_AIRACCEL_SIDEWAYS_FRICTION(this) / maxairspd) : 0;
 292                                 PM_Accelerate(this, wishdir, wishspeed, wishspeed0, airaccel, airaccelqw,
 293                                         PHYS_AIRACCEL_QW_STRETCHFACTOR(this), sidefric, PHYS_AIRSPEEDLIMIT_NONQW(this));
 294                         }
 295
 296                         if (PHYS_AIRCONTROL(this)) {
 297                                 CPM_PM_Aircontrol(this, wishdir, wishspeed2);
 298                         }
 299                 }
 300         } else {
 301                 if (this.com_phys_ground || this.com_phys_water) {
 302                         if (IS_DUCKED(this)) { wishspeed *= 0.5; }
 303                 }
 304                 if (this.com_phys_water) {
 305                         wishspeed *= 0.7;
 306
 307                         //      if (PHYS_WATERJUMP_TIME(this) <= 0) // TODO: use
 308                         {
 309                                 // water friction
 310                                 float f = 1 - dt * PHYS_FRICTION(this);
 311                                 f = min(max(0, f), 1);
 312                                 this.velocity *= f;
 313
 314                                 f = wishspeed - this.velocity * wishdir;
 315                                 if (f > 0) {
 316                                         float accelspeed = min(PHYS_ACCELERATE(this) * dt * wishspeed, f);
 317                                         this.velocity += accelspeed * wishdir;
 318                                 }
 319
 320                                 // holding jump button swims upward slowly
 321                                 if (jump && !this.viewloc) {
 322                                         // was:
 323                                         // lava: 50
 324                                         // slime: 80
 325                                         // water: 100
 326                                         // idea: double those
 327                                         this.velocity_z = 200;
 328                                 }
 329                         }
 330                         if (this.viewloc) {
 331                                 const float addspeed = wishspeed - this.velocity * wishdir;
 332                                 if (addspeed > 0) {
 333                                         const float accelspeed = min(PHYS_ACCELERATE(this) * dt * wishspeed, addspeed);
 334                                         this.velocity += accelspeed * wishdir;
 335                                 }
 336                         } else {
 337                                 // water acceleration
 338                                 PM_Accelerate(this, wishdir, wishspeed, wishspeed, this.com_phys_acc_rate, 1, 0, 0, 0);
 339                                 PM_ClientMovement_Move(this);
 340                         }
 341                         return;
 342                 }
 343                 if (this.com_phys_ground) {
 344                         // apply edge friction
 345                         const float f2 = vlen2(vec2(this.velocity));
 346                         if (f2 > 0) {
 347                                 trace_dphitq3surfaceflags = 0;
 348                                 tracebox(this.origin, this.mins, this.maxs, this.origin - '0 0 1', MOVE_NOMONSTERS, this);
 349                                 // TODO: apply edge friction
 350                                 // apply ground friction
 351                                 const int realfriction = (trace_dphitq3surfaceflags & Q3SURFACEFLAG_SLICK)
 352                                     ? PHYS_FRICTION_SLICK(this)
 353                                         : PHYS_FRICTION(this);
 354
 355                                 float f = sqrt(f2);
 356                                 f = 1 - dt * realfriction
 357                                     * ((f < PHYS_STOPSPEED(this)) ? (PHYS_STOPSPEED(this) / f) : 1);
 358                                 f = max(0, f);
 359                                 this.velocity *= f;
 360                                 /*
 361                                    Mathematical analysis time!
 362
 363                                    Our goal is to invert this mess.
 364
 365                                    For the two cases we get:
 366                                     v = v0 * (1 - dt * (PHYS_STOPSPEED(this) / v0) * PHYS_FRICTION(this))
 367                                       = v0 - dt * PHYS_STOPSPEED(this) * PHYS_FRICTION(this)
 368                                     v0 = v + dt * PHYS_STOPSPEED(this) * PHYS_FRICTION(this)
 369                                    and
 370                                     v = v0 * (1 - dt * PHYS_FRICTION(this))
 371                                     v0 = v / (1 - dt * PHYS_FRICTION(this))
 372
 373                                    These cases would be chosen ONLY if:
 374                                     v0 < PHYS_STOPSPEED(this)
 375                                     v + dt * PHYS_STOPSPEED(this) * PHYS_FRICTION(this) < PHYS_STOPSPEED(this)
 376                                     v < PHYS_STOPSPEED(this) * (1 - dt * PHYS_FRICTION(this))
 377                                    and, respectively:
 378                                     v0 >= PHYS_STOPSPEED(this)
 379                                     v / (1 - dt * PHYS_FRICTION(this)) >= PHYS_STOPSPEED(this)
 380                                     v >= PHYS_STOPSPEED(this) * (1 - dt * PHYS_FRICTION(this))
 381                                  */
 382                         }
 383                         const float addspeed = wishspeed - this.velocity * wishdir;
 384                         if (addspeed > 0) {
 385                                 const float accelspeed = min(PHYS_ACCELERATE(this) * dt * wishspeed, addspeed);
 386                                 this.velocity += accelspeed * wishdir;
 387                         }
 388                         if (IS_CSQC && vdist(this.velocity, >, 0)) {
 389                                 PM_ClientMovement_Move(this);
 390                         }
 391                         return;
 392                 }
 393
 394                 if (IS_CSQC || time >= PHYS_TELEPORT_TIME(this)) {
 395                         PM_Accelerate(this, wishdir, wishspeed, wishspeed, this.com_phys_acc_rate, 1, 0, 0, 0);
 396                 }
 397         }
 398         PM_ClientMovement_Move(this);
 399 }
 400
 401 .entity groundentity;
 402 /** for other entities */
 403 void sys_phys_simulate_simple(entity this, float dt)
 404 {
 405         vector mn = this.mins;
 406         vector mx = this.maxs;
 407
 408         vector g = '0 0 0';
 409         if (this.com_phys_gravity_factor && !g) g = '0 0 -1' * PHYS_GRAVITY(NULL);
 410
 411         vector acc = this.com_phys_acc;
 412         vector vel = this.com_phys_vel;
 413         vector pos = this.com_phys_pos;
 414
 415         // SV_Physics_Toss
 416
 417         vel += g * dt;
 418
 419         this.angles += dt * this.avelocity;
 420         float movetime = dt;
 421         for (int i = 0; i < MAX_CLIP_PLANES && movetime > 0; i++) {
 422                 vector push = vel * movetime;
 423                 vector p0 = pos;
 424                 vector p1 = p0 + push;
 425                 // SV_PushEntity
 426                 tracebox(p0, mn, mx, p1, MOVE_NORMAL, this);
 427                 if (!trace_startsolid) {
 428                         bool hit = trace_fraction < 1;
 429                         pos = trace_endpos;
 430                         entity ent = trace_ent;
 431                         // SV_LinkEdict_TouchAreaGrid
 432                         if (this.solid != SOLID_NOT) {
 433                                 FOREACH_ENTITY_RADIUS_ORDERED(0.5 * (this.absmin + this.absmax), 0.5 * vlen(this.absmax - this.absmin), true, {
 434                                         if (it.solid != SOLID_TRIGGER || it == this) continue;
 435                                         if (gettouch(it) && boxesoverlap(it.absmin, it.absmax, this.absmin, this.absmax)) {
 436                                             // SV_LinkEdict_TouchAreaGrid_Call
 437                                             trace_allsolid = false;
 438                                             trace_startsolid = false;
 439                                             trace_fraction = 1;
 440                                             trace_inwater = false;
 441                                             trace_inopen = true;
 442                                             trace_endpos = it.origin;
 443                                             trace_plane_normal = '0 0 1';
 444                                             trace_plane_dist = 0;
 445                                             trace_ent = this;
 446                                             trace_dpstartcontents = 0;
 447                                             trace_dphitcontents = 0;
 448                                             trace_dphitq3surfaceflags = 0;
 449                                             trace_dphittexturename = string_null;
 450                                             gettouch(it)((other = this, it));
 451                                             vel = this.velocity;
 452                                         }
 453                                 });
 454                         }
 455                         if (hit && this.solid >= SOLID_TRIGGER && (!IS_ONGROUND(this) || this.groundentity != ent)) {
 456                                 // SV_Impact (ent, trace);
 457                                 tracebox(p0, mn, mx, p1, MOVE_NORMAL, this);
 458                                 void(entity) touched = gettouch(this);
 459                                 if (touched && this.solid != SOLID_NOT) {
 460                                         touched((other = ent, this));
 461                                 }
 462                                 void(entity) touched2 = gettouch(ent);
 463                                 if (this && ent && touched2 && ent.solid != SOLID_NOT) {
 464                                         trace_endpos = ent.origin;
 465                                         trace_plane_normal *= -1;
 466                                         trace_plane_dist *= -1;
 467                                         trace_ent = this;
 468                                         trace_dpstartcontents = 0;
 469                                         trace_dphitcontents = 0;
 470                                         trace_dphitq3surfaceflags = 0;
 471                                         trace_dphittexturename = string_null;
 472                                         touched2((other = this, ent));
 473                                 }
 474                         }
 475                 }
 476                 // end SV_PushEntity
 477                 if (wasfreed(this)) { return; }
 478                 tracebox(p0, mn, mx, p1, MOVE_NORMAL, this);
 479                 if (trace_fraction == 1) { break; }
 480                 movetime *= 1 - min(1, trace_fraction);
 481                 ClipVelocity(vel, trace_plane_normal, vel, 1);
 482         }
 483
 484         this.com_phys_acc = acc;
 485         this.com_phys_vel = vel;
 486         this.com_phys_pos = pos;
 487         setorigin(this, this.com_phys_pos);
 488 }
 489
 490 void sys_phys_update_single(entity this)
 491 {
 492         sys_phys_simulate_simple(this, frametime);
 493 }