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