qcsrc/server/cl_physics.qc

   1 #if defined(CSQC)
   2 #elif defined(MENUQC)
   3 #elif defined(SVQC)
   4         #include "../dpdefs/progsdefs.qh"
   5     #include "../dpdefs/dpextensions.qh"
   6     #include "../warpzonelib/mathlib.qh"
   7     #include "../warpzonelib/server.qh"
   8     #include "../common/constants.qh"
   9     #include "../common/util.qh"
  10     #include "../common/animdecide.qh"
  11     #include "../common/monsters/sv_monsters.qh"
  12     #include "../common/weapons/weapons.qh"
  13     #include "t_items.qh"
  14     #include "autocvars.qh"
  15     #include "defs.qh"
  16     #include "../common/notifications.qh"
  17     #include "mutators/mutators_include.qh"
  18     #include "../common/mapinfo.qh"
  19     #include "../csqcmodellib/sv_model.qh"
  20     #include "anticheat.qh"
  21     #include "cheats.qh"
  22     #include "g_hook.qh"
  23     #include "race.qh"
  24     #include "playerdemo.qh"
  25 #endif
  26
  27 .float race_penalty;
  28 .float restart_jump;
  29
  30 .float ladder_time;
  31 .entity ladder_entity;
  32 .float gravity;
  33 .float swamp_slowdown;
  34 .int lastflags;
  35 .float lastground;
  36 .float wasFlying;
  37 .float spectatorspeed;
  38
  39 /*
  40 =============
  41 PlayerJump
  42
  43 When you press the jump key
  44 returns true if handled
  45 =============
  46 */
  47 float PlayerJump (void)
  48 {
  49         if(self.frozen)
  50                 return true; // no jumping in freezetag when frozen
  51
  52         if(self.player_blocked)
  53                 return true; // no jumping while blocked
  54
  55         float doublejump = false;
  56         float mjumpheight = autocvar_sv_jumpvelocity;
  57
  58         player_multijump = doublejump;
  59         player_jumpheight = mjumpheight;
  60         if(MUTATOR_CALLHOOK(PlayerJump))
  61                 return true;
  62
  63         doublejump = player_multijump;
  64         mjumpheight = player_jumpheight;
  65
  66         if (autocvar_sv_doublejump)
  67         {
  68                 tracebox(self.origin + '0 0 0.01', self.mins, self.maxs, self.origin - '0 0 0.01', MOVE_NORMAL, self);
  69                 if (trace_fraction < 1 && trace_plane_normal.z > 0.7)
  70                 {
  71                         doublejump = true;
  72
  73                         // we MUST clip velocity here!
  74                         float f;
  75                         f = self.velocity * trace_plane_normal;
  76                         if(f < 0)
  77                                 self.velocity -= f * trace_plane_normal;
  78                 }
  79         }
  80
  81         if (self.waterlevel >= WATERLEVEL_SWIMMING)
  82         {
  83                 self.velocity_z = self.stat_sv_maxspeed * 0.7;
  84                 return true;
  85         }
  86
  87         if (!doublejump)
  88                 if (!(self.flags & FL_ONGROUND))
  89                         return !(self.flags & FL_JUMPRELEASED);
  90
  91         if(self.cvar_cl_movement_track_canjump)
  92                 if (!(self.flags & FL_JUMPRELEASED))
  93                         return true;
  94
  95         // sv_jumpspeedcap_min/sv_jumpspeedcap_max act as baseline
  96         // velocity bounds.  Final velocity is bound between (jumpheight *
  97         // min + jumpheight) and (jumpheight * max + jumpheight);
  98
  99         if(autocvar_sv_jumpspeedcap_min != "")
 100         {
 101                 float minjumpspeed;
 102
 103                 minjumpspeed = mjumpheight * stof(autocvar_sv_jumpspeedcap_min);
 104
 105                 if (self.velocity.z < minjumpspeed)
 106                         mjumpheight += minjumpspeed - self.velocity.z;
 107         }
 108
 109         if(autocvar_sv_jumpspeedcap_max != "")
 110         {
 111                 // don't do jump speedcaps on ramps to preserve old xonotic ramjump style
 112                 tracebox(self.origin + '0 0 0.01', self.mins, self.maxs, self.origin - '0 0 0.01', MOVE_NORMAL, self);
 113
 114                 if(!(trace_fraction < 1 && trace_plane_normal.z < 0.98 && autocvar_sv_jumpspeedcap_max_disable_on_ramps))
 115                 {
 116                         float maxjumpspeed;
 117
 118                         maxjumpspeed = mjumpheight * stof(autocvar_sv_jumpspeedcap_max);
 119
 120                         if (self.velocity.z > maxjumpspeed)
 121                                 mjumpheight -= self.velocity.z - maxjumpspeed;
 122                 }
 123         }
 124
 125         if(!(self.lastflags & FL_ONGROUND))
 126         {
 127                 if(autocvar_speedmeter)
 128                         dprint(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n"));
 129                 if(self.lastground < time - 0.3)
 130                 {
 131                         self.velocity_x *= (1 - autocvar_sv_friction_on_land);
 132                         self.velocity_y *= (1 - autocvar_sv_friction_on_land);
 133                 }
 134                 if(self.jumppadcount > 1)
 135                         dprint(strcat(ftos(self.jumppadcount), "x jumppad combo\n"));
 136                 self.jumppadcount = 0;
 137         }
 138
 139         self.velocity_z = self.velocity.z + mjumpheight;
 140         self.oldvelocity_z = self.velocity.z;
 141
 142         self.flags &= ~FL_ONGROUND;
 143         self.flags &= ~FL_JUMPRELEASED;
 144
 145         animdecide_setaction(self, ANIMACTION_JUMP, true);
 146
 147         if(autocvar_g_jump_grunt)
 148                 PlayerSound(playersound_jump, CH_PLAYER, VOICETYPE_PLAYERSOUND);
 149
 150         self.restart_jump = -1; // restart jump anim next time
 151         // value -1 is used to not use the teleport bit (workaround for tiny hitch when re-jumping)
 152         return true;
 153 }
 154 void CheckWaterJump()
 155 {
 156         vector start, end;
 157
 158 // check for a jump-out-of-water
 159         makevectors (self.angles);
 160         start = self.origin;
 161         start.z = start.z + 8;
 162         v_forward.z = 0;
 163         normalize(v_forward);
 164         end = start + v_forward*24;
 165         traceline (start, end, true, self);
 166         if (trace_fraction < 1)
 167         {       // solid at waist
 168                 start.z = start.z + self.maxs.z - 8;
 169                 end = start + v_forward*24;
 170                 self.movedir = trace_plane_normal * -50;
 171                 traceline (start, end, true, self);
 172                 if (trace_fraction == 1)
 173                 {       // open at eye level
 174                         self.flags |= FL_WATERJUMP;
 175                         self.velocity_z = 225;
 176                         self.flags &= ~FL_JUMPRELEASED;
 177                         self.teleport_time = time + 2;  // safety net
 178                         return;
 179                 }
 180         }
 181 }
 182
 183 .float jetpack_stopped;
 184 // Hack: shouldn't need to know about this
 185 .float multijump_count;
 186 void CheckPlayerJump()
 187 {
 188         float was_flying = self.items & IT_USING_JETPACK;
 189
 190         if (self.cvar_cl_jetpack_jump < 2)
 191                 self.items &= ~IT_USING_JETPACK;
 192
 193         if (self.BUTTON_JUMP || self.BUTTON_JETPACK)
 194         {
 195                 float air_jump = !PlayerJump() || self.multijump_count > 0; // PlayerJump() has important side effects
 196                 float activate = self.cvar_cl_jetpack_jump && air_jump && self.BUTTON_JUMP || self.BUTTON_JETPACK;
 197                 float has_fuel = !autocvar_g_jetpack_fuel || self.ammo_fuel || self.items & IT_UNLIMITED_WEAPON_AMMO;
 198                 if (!(self.items & IT_JETPACK)) { }
 199                 else if (self.jetpack_stopped) { }
 200                 else if (!has_fuel)
 201                 {
 202                         if (was_flying) // TODO: ran out of fuel message
 203                                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL);
 204                         else if (activate)
 205                                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL);
 206                         self.jetpack_stopped = true;
 207                         self.items &= ~IT_USING_JETPACK;
 208                 }
 209                 else if (activate && !self.frozen)
 210                         self.items |= IT_USING_JETPACK;
 211         }
 212         else
 213         {
 214                 self.jetpack_stopped = false;
 215                 self.items &= ~IT_USING_JETPACK;
 216         }
 217         if (!self.BUTTON_JUMP)
 218                 self.flags |= FL_JUMPRELEASED;
 219
 220         if (self.waterlevel == WATERLEVEL_SWIMMING)
 221                 CheckWaterJump ();
 222 }
 223
 224 float racecar_angle(float forward, float down)
 225 {
 226         float ret, angle_mult;
 227
 228         if(forward < 0)
 229         {
 230                 forward = -forward;
 231                 down = -down;
 232         }
 233
 234         ret = vectoyaw('0 1 0' * down + '1 0 0' * forward);
 235
 236         angle_mult = forward / (800 + forward);
 237
 238         if(ret > 180)
 239                 return ret * angle_mult + 360 * (1 - angle_mult);
 240         else
 241                 return ret * angle_mult;
 242 }
 243
 244 void RaceCarPhysics()
 245 {
 246         // using this move type for "big rigs"
 247         // the engine does not push the entity!
 248
 249         float accel, steer, f, myspeed, steerfactor;
 250         vector angles_save, rigvel;
 251
 252         angles_save = self.angles;
 253         accel = bound(-1, self.movement.x / self.stat_sv_maxspeed, 1);
 254         steer = bound(-1, self.movement.y / self.stat_sv_maxspeed, 1);
 255
 256         if(g_bugrigs_reverse_speeding)
 257         {
 258                 if(accel < 0)
 259                 {
 260                         // back accel is DIGITAL
 261                         // to prevent speedhack
 262                         if(accel < -0.5)
 263                                 accel = -1;
 264                         else
 265                                 accel = 0;
 266                 }
 267         }
 268
 269         self.angles_x = 0;
 270         self.angles_z = 0;
 271         makevectors(self.angles); // new forward direction!
 272
 273         if(self.flags & FL_ONGROUND || g_bugrigs_air_steering)
 274         {
 275                 float upspeed, accelfactor;
 276
 277                 myspeed = self.velocity * v_forward;
 278                 upspeed = self.velocity * v_up;
 279
 280                 // responsiveness factor for steering and acceleration
 281                 f = 1 / (1 + pow(max(-myspeed, myspeed) / g_bugrigs_speed_ref, g_bugrigs_speed_pow));
 282                 //MAXIMA: f(v) := 1 / (1 + (v / g_bugrigs_speed_ref) ^ g_bugrigs_speed_pow);
 283
 284                 if(myspeed < 0 && g_bugrigs_reverse_spinning)
 285                         steerfactor = -myspeed * g_bugrigs_steer;
 286                 else
 287                         steerfactor = -myspeed * f * g_bugrigs_steer;
 288
 289                 if(myspeed < 0 && g_bugrigs_reverse_speeding)
 290                         accelfactor = g_bugrigs_accel;
 291                 else
 292                         accelfactor = f * g_bugrigs_accel;
 293                 //MAXIMA: accel(v) := f(v) * g_bugrigs_accel;
 294
 295                 if(accel < 0)
 296                 {
 297                         if(myspeed > 0)
 298                         {
 299                                 myspeed = max(0, myspeed - frametime * (g_bugrigs_friction_floor - g_bugrigs_friction_brake * accel));
 300                         }
 301                         else
 302                         {
 303                                 if(!g_bugrigs_reverse_speeding)
 304                                         myspeed = min(0, myspeed + frametime * g_bugrigs_friction_floor);
 305                         }
 306                 }
 307                 else
 308                 {
 309                         if(myspeed >= 0)
 310                         {
 311                                 myspeed = max(0, myspeed - frametime * g_bugrigs_friction_floor);
 312                         }
 313                         else
 314                         {
 315                                 if(g_bugrigs_reverse_stopping)
 316                                         myspeed = 0;
 317                                 else
 318                                         myspeed = min(0, myspeed + frametime * (g_bugrigs_friction_floor + g_bugrigs_friction_brake * accel));
 319                         }
 320                 }
 321                 // terminal velocity = velocity at which 50 == accelfactor, that is, 1549 units/sec
 322                 //MAXIMA: friction(v) := g_bugrigs_friction_floor;
 323
 324                 self.angles_y += steer * frametime * steerfactor; // apply steering
 325                 makevectors(self.angles); // new forward direction!
 326
 327                 myspeed += accel * accelfactor * frametime;
 328
 329                 rigvel = myspeed * v_forward + '0 0 1' * upspeed;
 330         }
 331         else
 332         {
 333                 myspeed = vlen(self.velocity);
 334
 335                 // responsiveness factor for steering and acceleration
 336                 f = 1 / (1 + pow(max(0, myspeed / g_bugrigs_speed_ref), g_bugrigs_speed_pow));
 337                 steerfactor = -myspeed * f;
 338                 self.angles_y += steer * frametime * steerfactor; // apply steering
 339
 340                 rigvel = self.velocity;
 341                 makevectors(self.angles); // new forward direction!
 342         }
 343
 344         rigvel = rigvel * max(0, 1 - vlen(rigvel) * g_bugrigs_friction_air * frametime);
 345         //MAXIMA: airfriction(v) := v * v * g_bugrigs_friction_air;
 346         //MAXIMA: total_acceleration(v) := accel(v) - friction(v) - airfriction(v);
 347         //MAXIMA: solve(total_acceleration(v) = 0, v);
 348
 349         if(g_bugrigs_planar_movement)
 350         {
 351                 vector rigvel_xy, neworigin, up;
 352                 float mt;
 353
 354                 rigvel.z -= frametime * autocvar_sv_gravity; // 4x gravity plays better
 355                 rigvel_xy = vec2(rigvel);
 356
 357                 if(g_bugrigs_planar_movement_car_jumping)
 358                         mt = MOVE_NORMAL;
 359                 else
 360                         mt = MOVE_NOMONSTERS;
 361
 362                 tracebox(self.origin, self.mins, self.maxs, self.origin + '0 0 1024', mt, self);
 363                 up = trace_endpos - self.origin;
 364
 365                 // BUG RIGS: align the move to the surface instead of doing collision testing
 366                 // can we move?
 367                 tracebox(trace_endpos, self.mins, self.maxs, trace_endpos + rigvel_xy * frametime, mt, self);
 368
 369                 // align to surface
 370                 tracebox(trace_endpos, self.mins, self.maxs, trace_endpos - up + '0 0 1' * rigvel.z * frametime, mt, self);
 371
 372                 if(trace_fraction < 0.5)
 373                 {
 374                         trace_fraction = 1;
 375                         neworigin = self.origin;
 376                 }
 377                 else
 378                         neworigin = trace_endpos;
 379
 380                 if(trace_fraction < 1)
 381                 {
 382                         // now set angles_x so that the car points parallel to the surface
 383                         self.angles = vectoangles(
 384                                         '1 0 0' * v_forward.x * trace_plane_normal.z
 385                                         +
 386                                         '0 1 0' * v_forward.y * trace_plane_normal.z
 387                                         +
 388                                         '0 0 1' * -(v_forward.x * trace_plane_normal.x + v_forward.y * trace_plane_normal.y)
 389                                         );
 390                         self.flags |= FL_ONGROUND;
 391                 }
 392                 else
 393                 {
 394                         // now set angles_x so that the car points forward, but is tilted in velocity direction
 395                         self.flags &= ~FL_ONGROUND;
 396                 }
 397
 398                 self.velocity = (neworigin - self.origin) * (1.0 / frametime);
 399                 self.movetype = MOVETYPE_NOCLIP;
 400         }
 401         else
 402         {
 403                 rigvel.z -= frametime * autocvar_sv_gravity; // 4x gravity plays better
 404                 self.velocity = rigvel;
 405                 self.movetype = MOVETYPE_FLY;
 406         }
 407
 408         trace_fraction = 1;
 409         tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 4', MOVE_NORMAL, self);
 410         if(trace_fraction != 1)
 411         {
 412                 self.angles = vectoangles2(
 413                                 '1 0 0' * v_forward.x * trace_plane_normal.z
 414                                 +
 415                                 '0 1 0' * v_forward.y * trace_plane_normal.z
 416                                 +
 417                                 '0 0 1' * -(v_forward.x * trace_plane_normal.x + v_forward.y * trace_plane_normal.y),
 418                                 trace_plane_normal
 419                                 );
 420         }
 421         else
 422         {
 423                 vector vel_local;
 424
 425                 vel_local.x = v_forward * self.velocity;
 426                 vel_local.y = v_right * self.velocity;
 427                 vel_local.z = v_up * self.velocity;
 428
 429                 self.angles_x = racecar_angle(vel_local.x, vel_local.z);
 430                 self.angles_z = racecar_angle(-vel_local.y, vel_local.z);
 431         }
 432
 433         // smooth the angles
 434         vector vf1, vu1, smoothangles;
 435         makevectors(self.angles);
 436         f = bound(0, frametime * g_bugrigs_angle_smoothing, 1);
 437         if(f == 0)
 438                 f = 1;
 439         vf1 = v_forward * f;
 440         vu1 = v_up * f;
 441         makevectors(angles_save);
 442         vf1 = vf1 + v_forward * (1 - f);
 443         vu1 = vu1 + v_up * (1 - f);
 444         smoothangles = vectoangles2(vf1, vu1);
 445         self.angles_x = -smoothangles.x;
 446         self.angles_z =  smoothangles.z;
 447 }
 448
 449 float IsMoveInDirection(vector mv, float angle) // key mix factor
 450 {
 451         if(mv.x == 0 && mv.y == 0)
 452                 return 0; // avoid division by zero
 453         angle -= RAD2DEG * atan2(mv.y, mv.x);
 454         angle = remainder(angle, 360) / 45;
 455         if(angle >  1)
 456                 return 0;
 457         if(angle < -1)
 458                 return 0;
 459         return 1 - fabs(angle);
 460 }
 461
 462 float GeomLerp(float a, float lerp, float b)
 463 {
 464         if(a == 0)
 465         {
 466                 if(lerp < 1)
 467                         return 0;
 468                 else
 469                         return b;
 470         }
 471         if(b == 0)
 472         {
 473                 if(lerp > 0)
 474                         return 0;
 475                 else
 476                         return a;
 477         }
 478         return a * pow(fabs(b / a), lerp);
 479 }
 480
 481 void CPM_PM_Aircontrol(vector wishdir, float wishspeed)
 482 {
 483         float zspeed, xyspeed, dot, k;
 484
 485 #if 0
 486         // this doesn't play well with analog input
 487         if(self.movement_x == 0 || self.movement.y != 0)
 488                 return; // can't control movement if not moving forward or backward
 489         k = 32;
 490 #else
 491         k = 32 * (2 * IsMoveInDirection(self.movement, 0) - 1);
 492         if(k <= 0)
 493                 return;
 494 #endif
 495
 496         k *= bound(0, wishspeed / autocvar_sv_maxairspeed, 1);
 497
 498         zspeed = self.velocity.z;
 499         self.velocity_z = 0;
 500         xyspeed = vlen(self.velocity); self.velocity = normalize(self.velocity);
 501
 502         dot = self.velocity * wishdir;
 503
 504         if(dot > 0) // we can't change direction while slowing down
 505         {
 506                 k *= pow(dot, autocvar_sv_aircontrol_power)*frametime;
 507                 xyspeed = max(0, xyspeed - autocvar_sv_aircontrol_penalty * sqrt(max(0, 1 - dot*dot)) * k/32);
 508                 k *= autocvar_sv_aircontrol;
 509                 self.velocity = normalize(self.velocity * xyspeed + wishdir * k);
 510         }
 511
 512         self.velocity = self.velocity * xyspeed;
 513         self.velocity_z = zspeed;
 514 }
 515
 516 float AdjustAirAccelQW(float accelqw, float factor)
 517 {
 518         return copysign(bound(0.000001, 1 - (1 - fabs(accelqw)) * factor, 1), accelqw);
 519 }
 520
 521 // example config for alternate speed clamping:
 522 //   sv_airaccel_qw 0.8
 523 //   sv_airaccel_sideways_friction 0
 524 //   prvm_globalset server speedclamp_mode 1
 525 //     (or 2)
 526 void PM_Accelerate(vector wishdir, float wishspeed, float wishspeed0, float accel, float accelqw, float stretchfactor, float sidefric, float speedlimit)
 527 {
 528         float vel_straight;
 529         float velZ;
 530         vector vel_perpend;
 531         float step;
 532
 533         vector vel_xy;
 534         float vel_xy_current;
 535         float vel_xy_backward, vel_xy_forward;
 536         float speedclamp;
 537
 538         if(stretchfactor > 0)
 539                 speedclamp = stretchfactor;
 540         else if(accelqw < 0)
 541                 speedclamp = 1; // full clamping, no stretch
 542         else
 543                 speedclamp = -1; // no clamping
 544
 545         if(accelqw < 0)
 546                 accelqw = -accelqw;
 547
 548         if(autocvar_sv_gameplayfix_q2airaccelerate)
 549                 wishspeed0 = wishspeed;
 550
 551         vel_straight = self.velocity * wishdir;
 552         velZ = self.velocity.z;
 553         vel_xy = vec2(self.velocity);
 554         vel_perpend = vel_xy - vel_straight * wishdir;
 555
 556         step = accel * frametime * wishspeed0;
 557
 558         vel_xy_current  = vlen(vel_xy);
 559         if(speedlimit)
 560                 accelqw = AdjustAirAccelQW(accelqw, (speedlimit - bound(wishspeed, vel_xy_current, speedlimit)) / max(1, speedlimit - wishspeed));
 561         vel_xy_forward  = vel_xy_current + bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
 562         vel_xy_backward = vel_xy_current - bound(0, wishspeed + vel_xy_current, step) * accelqw - step * (1 - accelqw);
 563         if(vel_xy_backward < 0)
 564                 vel_xy_backward = 0; // not that it REALLY occurs that this would cause wrong behaviour afterwards
 565
 566         vel_straight = vel_straight + bound(0, wishspeed - vel_straight, step) * accelqw + step * (1 - accelqw);
 567
 568         if(sidefric < 0 && (vel_perpend*vel_perpend))
 569                 // negative: only apply so much sideways friction to stay below the speed you could get by "braking"
 570         {
 571                 float f, fminimum;
 572                 f = max(0, 1 + frametime * wishspeed * sidefric);
 573                 fminimum = (vel_xy_backward*vel_xy_backward - vel_straight*vel_straight) / (vel_perpend*vel_perpend);
 574                 // this cannot be > 1
 575                 if(fminimum <= 0)
 576                         vel_perpend = vel_perpend * max(0, f);
 577                 else
 578                 {
 579                         fminimum = sqrt(fminimum);
 580                         vel_perpend = vel_perpend * max(fminimum, f);
 581                 }
 582         }
 583         else
 584                 vel_perpend = vel_perpend * max(0, 1 - frametime * wishspeed * sidefric);
 585
 586         vel_xy = vel_straight * wishdir + vel_perpend;
 587
 588         if(speedclamp >= 0)
 589         {
 590                 float vel_xy_preclamp;
 591                 vel_xy_preclamp = vlen(vel_xy);
 592                 if(vel_xy_preclamp > 0) // prevent division by zero
 593                 {
 594                         vel_xy_current += (vel_xy_forward - vel_xy_current) * speedclamp;
 595                         if(vel_xy_current < vel_xy_preclamp)
 596                                 vel_xy = vel_xy * (vel_xy_current / vel_xy_preclamp);
 597                 }
 598         }
 599
 600         self.velocity = vel_xy + velZ * '0 0 1';
 601 }
 602
 603 void PM_AirAccelerate(vector wishdir, float wishspeed)
 604 {
 605         vector curvel, wishvel, acceldir, curdir;
 606         float addspeed, accelspeed, curspeed, f;
 607         float dot;
 608
 609         if(wishspeed == 0)
 610                 return;
 611
 612         curvel = self.velocity;
 613         curvel.z = 0;
 614         curspeed = vlen(curvel);
 615
 616         if(wishspeed > curspeed * 1.01)
 617         {
 618                 wishspeed = min(wishspeed, curspeed + autocvar_sv_warsowbunny_airforwardaccel * self.stat_sv_maxspeed * frametime);
 619         }
 620         else
 621         {
 622                 f = max(0, (autocvar_sv_warsowbunny_topspeed - curspeed) / (autocvar_sv_warsowbunny_topspeed - self.stat_sv_maxspeed));
 623                 wishspeed = max(curspeed, self.stat_sv_maxspeed) + autocvar_sv_warsowbunny_accel * f * self.stat_sv_maxspeed * frametime;
 624         }
 625         wishvel = wishdir * wishspeed;
 626         acceldir = wishvel - curvel;
 627         addspeed = vlen(acceldir);
 628         acceldir = normalize(acceldir);
 629
 630         accelspeed = min(addspeed, autocvar_sv_warsowbunny_turnaccel * self.stat_sv_maxspeed * frametime);
 631
 632         if(autocvar_sv_warsowbunny_backtosideratio < 1)
 633         {
 634                 curdir = normalize(curvel);
 635                 dot = acceldir * curdir;
 636                 if(dot < 0)
 637                         acceldir = acceldir - (1 - autocvar_sv_warsowbunny_backtosideratio) * dot * curdir;
 638         }
 639
 640         self.velocity += accelspeed * acceldir;
 641 }
 642
 643 .vector movement_old;
 644 .float buttons_old;
 645 .vector v_angle_old;
 646 .string lastclassname;
 647
 648 .float() PlayerPhysplug;
 649
 650 string specialcommand = "xwxwxsxsxaxdxaxdx1x ";
 651 .float specialcommand_pos;
 652 void SpecialCommand()
 653 {
 654 #ifdef TETRIS
 655         TetrisImpulse();
 656 #else
 657         if(!CheatImpulse(99))
 658                 print("A hollow voice says \"Plugh\".\n");
 659 #endif
 660 }
 661
 662 float speedaward_speed;
 663 string speedaward_holder;
 664 string speedaward_uid;
 665 void race_send_speedaward(float msg)
 666 {
 667         // send the best speed of the round
 668         WriteByte(msg, SVC_TEMPENTITY);
 669         WriteByte(msg, TE_CSQC_RACE);
 670         WriteByte(msg, RACE_NET_SPEED_AWARD);
 671         WriteInt24_t(msg, floor(speedaward_speed+0.5));
 672         WriteString(msg, speedaward_holder);
 673 }
 674
 675 float speedaward_alltimebest;
 676 string speedaward_alltimebest_holder;
 677 string speedaward_alltimebest_uid;
 678 void race_send_speedaward_alltimebest(float msg)
 679 {
 680         // send the best speed
 681         WriteByte(msg, SVC_TEMPENTITY);
 682         WriteByte(msg, TE_CSQC_RACE);
 683         WriteByte(msg, RACE_NET_SPEED_AWARD_BEST);
 684         WriteInt24_t(msg, floor(speedaward_alltimebest+0.5));
 685         WriteString(msg, speedaward_alltimebest_holder);
 686 }
 687
 688 string GetMapname(void);
 689 float speedaward_lastupdate;
 690 float speedaward_lastsent;
 691 void SV_PlayerPhysics()
 692 {
 693         vector wishvel, wishdir, v;
 694         float wishspeed, f, maxspd_mod, spd, maxairspd, airaccel, swampspd_mod, buttons;
 695         string temps;
 696         int buttons_prev;
 697         float not_allowed_to_move;
 698         string c;
 699
 700         WarpZone_PlayerPhysics_FixVAngle();
 701
 702         maxspd_mod = 1;
 703         if(self.ballcarried)
 704                 if(g_keepaway)
 705                         maxspd_mod *= autocvar_g_keepaway_ballcarrier_highspeed;
 706
 707         maxspd_mod *= autocvar_g_movement_highspeed;
 708
 709         // fix physics stats for g_movement_highspeed
 710         // TODO maybe rather use maxairspeed? needs testing
 711         self.stat_sv_airaccel_qw = AdjustAirAccelQW(autocvar_sv_airaccel_qw, maxspd_mod);
 712         if(autocvar_sv_airstrafeaccel_qw)
 713                 self.stat_sv_airstrafeaccel_qw = AdjustAirAccelQW(autocvar_sv_airstrafeaccel_qw, maxspd_mod);
 714         else
 715                 self.stat_sv_airstrafeaccel_qw = 0;
 716         self.stat_sv_airspeedlimit_nonqw = autocvar_sv_airspeedlimit_nonqw * maxspd_mod;
 717         self.stat_sv_maxspeed = autocvar_sv_maxspeed * maxspd_mod; // also slow walking
 718
 719     if(self.PlayerPhysplug)
 720         if(self.PlayerPhysplug())
 721             return;
 722
 723         self.race_movetime_frac += frametime;
 724         f = floor(self.race_movetime_frac);
 725         self.race_movetime_frac -= f;
 726         self.race_movetime_count += f;
 727         self.race_movetime = self.race_movetime_frac + self.race_movetime_count;
 728
 729         anticheat_physics();
 730
 731         buttons = self.BUTTON_ATCK + 2 * self.BUTTON_JUMP + 4 * self.BUTTON_ATCK2 + 8 * self.BUTTON_ZOOM + 16 * self.BUTTON_CROUCH + 32 * self.BUTTON_HOOK + 64 * self.BUTTON_USE + 128 * (self.movement.x < 0) + 256 * (self.movement.x > 0) + 512 * (self.movement.y < 0) + 1024 * (self.movement.y > 0);
 732
 733         if(!buttons)
 734                 c = "x";
 735         else if(buttons == 1)
 736                 c = "1";
 737         else if(buttons == 2)
 738                 c = " ";
 739         else if(buttons == 128)
 740                 c = "s";
 741         else if(buttons == 256)
 742                 c = "w";
 743         else if(buttons == 512)
 744                 c = "a";
 745         else if(buttons == 1024)
 746                 c = "d";
 747         else
 748                 c = "?";
 749
 750         if(c == substring(specialcommand, self.specialcommand_pos, 1))
 751         {
 752                 self.specialcommand_pos += 1;
 753                 if(self.specialcommand_pos >= strlen(specialcommand))
 754                 {
 755                         self.specialcommand_pos = 0;
 756                         SpecialCommand();
 757                         return;
 758                 }
 759         }
 760         else if(self.specialcommand_pos && (c != substring(specialcommand, self.specialcommand_pos - 1, 1)))
 761                 self.specialcommand_pos = 0;
 762
 763         if(sv_maxidle > 0)
 764         {
 765                 if(buttons != self.buttons_old || self.movement != self.movement_old || self.v_angle != self.v_angle_old)
 766                         self.parm_idlesince = time;
 767         }
 768         buttons_prev = self.buttons_old;
 769         self.buttons_old = buttons;
 770         self.movement_old = self.movement;
 771         self.v_angle_old = self.v_angle;
 772
 773         if(time < self.nickspamtime)
 774         if(self.nickspamcount >= autocvar_g_nick_flood_penalty_yellow)
 775         {
 776                 // slight annoyance for nick change scripts
 777                 self.movement = -1 * self.movement;
 778                 self.BUTTON_ATCK = self.BUTTON_JUMP = self.BUTTON_ATCK2 = self.BUTTON_ZOOM = self.BUTTON_CROUCH = self.BUTTON_HOOK = self.BUTTON_USE = 0;
 779
 780                 if(self.nickspamcount >= autocvar_g_nick_flood_penalty_red) // if you are persistent and the slight annoyance above does not stop you, I'll show you!
 781                 {
 782                         self.angles_x = random() * 360;
 783                         self.angles_y = random() * 360;
 784                         // at least I'm not forcing retardedview by also assigning to angles_z
 785                         self.fixangle = true;
 786                 }
 787         }
 788
 789         if (self.punchangle != '0 0 0')
 790         {
 791                 f = vlen(self.punchangle) - 10 * frametime;
 792                 if (f > 0)
 793                         self.punchangle = normalize(self.punchangle) * f;
 794                 else
 795                         self.punchangle = '0 0 0';
 796         }
 797
 798         if (self.punchvector != '0 0 0')
 799         {
 800                 f = vlen(self.punchvector) - 30 * frametime;
 801                 if (f > 0)
 802                         self.punchvector = normalize(self.punchvector) * f;
 803                 else
 804                         self.punchvector = '0 0 0';
 805         }
 806
 807         if (IS_BOT_CLIENT(self))
 808         {
 809                 if(playerdemo_read())
 810                         return;
 811                 bot_think();
 812         }
 813
 814         if(IS_PLAYER(self))
 815         {
 816                 if(self.race_penalty)
 817                         if(time > self.race_penalty)
 818                                 self.race_penalty = 0;
 819
 820                 not_allowed_to_move = 0;
 821                 if(self.race_penalty)
 822                         not_allowed_to_move = 1;
 823                 if(time < game_starttime)
 824                         not_allowed_to_move = 1;
 825
 826                 if(not_allowed_to_move)
 827                 {
 828                         self.velocity = '0 0 0';
 829                         self.movetype = MOVETYPE_NONE;
 830                         self.disableclientprediction = 2;
 831                 }
 832                 else if(self.disableclientprediction == 2)
 833                 {
 834                         if(self.movetype == MOVETYPE_NONE)
 835                                 self.movetype = MOVETYPE_WALK;
 836                         self.disableclientprediction = 0;
 837                 }
 838         }
 839
 840         if (self.movetype == MOVETYPE_NONE)
 841                 return;
 842
 843         // when we get here, disableclientprediction cannot be 2
 844         self.disableclientprediction = 0;
 845         if(time < self.ladder_time)
 846                 self.disableclientprediction = 1;
 847
 848         if(time < self.spider_slowness)
 849         {
 850                 self.stat_sv_maxspeed *= 0.5; // half speed while slow from spider
 851                 self.stat_sv_airspeedlimit_nonqw *= 0.5;
 852         }
 853
 854         if(self.frozen)
 855         {
 856                 if(autocvar_sv_dodging_frozen && IS_REAL_CLIENT(self))
 857                 {
 858                         self.movement_x = bound(-5, self.movement.x, 5);
 859                         self.movement_y = bound(-5, self.movement.y, 5);
 860                         self.movement_z = bound(-5, self.movement.z, 5);
 861                 }
 862                 else
 863                         self.movement = '0 0 0';
 864                 self.disableclientprediction = 1;
 865
 866                 vector midpoint = ((self.absmin + self.absmax) * 0.5);
 867                 if(pointcontents(midpoint) == CONTENT_WATER)
 868                 {
 869                         self.velocity = self.velocity * 0.5;
 870
 871                         if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER)
 872                                 { self.velocity_z = 200; }
 873                 }
 874         }
 875
 876         MUTATOR_CALLHOOK(PlayerPhysics);
 877
 878         if(self.player_blocked)
 879         {
 880                 self.movement = '0 0 0';
 881                 self.disableclientprediction = 1;
 882         }
 883
 884         maxspd_mod = 1;
 885
 886         swampspd_mod = 1;
 887         if(self.in_swamp) {
 888                 swampspd_mod = self.swamp_slowdown; //cvar("g_balance_swamp_moverate");
 889         }
 890
 891         // conveyors: first fix velocity
 892         if(self.conveyor.state)
 893                 self.velocity -= self.conveyor.movedir;
 894
 895         if (!IS_PLAYER(self))
 896         {
 897                 maxspd_mod = autocvar_sv_spectator_speed_multiplier;
 898                 if(!self.spectatorspeed)
 899                         self.spectatorspeed = maxspd_mod;
 900                 if(self.impulse && self.impulse <= 19 || (self.impulse >= 200 && self.impulse <= 209) || (self.impulse >= 220 && self.impulse <= 229))
 901                 {
 902                         if(self.lastclassname != "player")
 903                         {
 904                                 if(self.impulse == 10 || self.impulse == 15 || self.impulse == 18 || (self.impulse >= 200 && self.impulse <= 209))
 905                                         self.spectatorspeed = bound(1, self.spectatorspeed + 0.5, 5);
 906                                 else if(self.impulse == 11)
 907                                         self.spectatorspeed = maxspd_mod;
 908                                 else if(self.impulse == 12 || self.impulse == 16  || self.impulse == 19 || (self.impulse >= 220 && self.impulse <= 229))
 909                                         self.spectatorspeed = bound(1, self.spectatorspeed - 0.5, 5);
 910                                 else if(self.impulse >= 1 && self.impulse <= 9)
 911                                         self.spectatorspeed = 1 + 0.5 * (self.impulse - 1);
 912                         } // otherwise just clear
 913                         self.impulse = 0;
 914                 }
 915                 maxspd_mod = self.spectatorspeed;
 916         }
 917
 918         spd = max(self.stat_sv_maxspeed, autocvar_sv_maxairspeed) * maxspd_mod * swampspd_mod;
 919         if(self.speed != spd)
 920         {
 921                 self.speed = spd;
 922                 temps = ftos(spd);
 923                 stuffcmd(self, strcat("cl_forwardspeed ", temps, "\n"));
 924                 stuffcmd(self, strcat("cl_backspeed ", temps, "\n"));
 925                 stuffcmd(self, strcat("cl_sidespeed ", temps, "\n"));
 926                 stuffcmd(self, strcat("cl_upspeed ", temps, "\n"));
 927         }
 928
 929         maxspd_mod *= swampspd_mod; // only one common speed modder please!
 930         swampspd_mod = 1;
 931
 932         // if dead, behave differently
 933         if (self.deadflag)
 934                 goto end;
 935
 936         if (!self.fixangle && !g_bugrigs)
 937         {
 938                 self.angles_x = 0;
 939                 self.angles_y = self.v_angle.y;
 940                 self.angles_z = 0;
 941         }
 942
 943         if(self.flags & FL_ONGROUND)
 944         if(IS_PLAYER(self)) // no fall sounds for observers thank you very much
 945         if(self.wasFlying)
 946         {
 947                 self.wasFlying = 0;
 948
 949                 if(self.waterlevel < WATERLEVEL_SWIMMING)
 950                 if(time >= self.ladder_time)
 951                 if (!self.hook)
 952                 {
 953                         self.nextstep = time + 0.3 + random() * 0.1;
 954                         trace_dphitq3surfaceflags = 0;
 955                         tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 1', MOVE_NOMONSTERS, self);
 956                         if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOSTEPS))
 957                         {
 958                                 if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_METALSTEPS)
 959                                         GlobalSound(globalsound_metalfall, CH_PLAYER, VOICETYPE_PLAYERSOUND);
 960                                 else
 961                                         GlobalSound(globalsound_fall, CH_PLAYER, VOICETYPE_PLAYERSOUND);
 962                         }
 963                 }
 964         }
 965
 966         if(IsFlying(self))
 967                 self.wasFlying = 1;
 968
 969         if(IS_PLAYER(self))
 970                 CheckPlayerJump();
 971
 972         if (self.flags & FL_WATERJUMP )
 973         {
 974                 self.velocity_x = self.movedir.x;
 975                 self.velocity_y = self.movedir.y;
 976                 if (time > self.teleport_time || self.waterlevel == WATERLEVEL_NONE)
 977                 {
 978                         self.flags &= ~FL_WATERJUMP;
 979                         self.teleport_time = 0;
 980                 }
 981         }
 982         else if (g_bugrigs && IS_PLAYER(self))
 983         {
 984                 RaceCarPhysics();
 985         }
 986         else if (self.movetype == MOVETYPE_NOCLIP || self.movetype == MOVETYPE_FLY || self.movetype == MOVETYPE_FLY_WORLDONLY)
 987         {
 988                 // noclipping or flying
 989                 self.flags &= ~FL_ONGROUND;
 990
 991                 self.velocity = self.velocity * (1 - frametime * autocvar_sv_friction);
 992                 makevectors(self.v_angle);
 993                 //wishvel = v_forward * self.movement_x + v_right * self.movement_y + v_up * self.movement_z;
 994                 wishvel = v_forward * self.movement.x + v_right * self.movement.y + '0 0 1' * self.movement.z;
 995                 // acceleration
 996                 wishdir = normalize(wishvel);
 997                 wishspeed = vlen(wishvel);
 998                 if (wishspeed > self.stat_sv_maxspeed*maxspd_mod)
 999                         wishspeed = self.stat_sv_maxspeed*maxspd_mod;
1000                 if (time >= self.teleport_time)
1001                         PM_Accelerate(wishdir, wishspeed, wishspeed, autocvar_sv_accelerate*maxspd_mod, 1, 0, 0, 0);
1002         }
1003         else if (self.waterlevel >= WATERLEVEL_SWIMMING)
1004         {
1005                 // swimming
1006                 self.flags &= ~FL_ONGROUND;
1007
1008                 makevectors(self.v_angle);
1009                 //wishvel = v_forward * self.movement_x + v_right * self.movement_y + v_up * self.movement_z;
1010                 wishvel = v_forward * self.movement.x + v_right * self.movement.y + '0 0 1' * self.movement.z;
1011                 if (wishvel == '0 0 0')
1012                         wishvel = '0 0 -60'; // drift towards bottom
1013
1014                 wishdir = normalize(wishvel);
1015                 wishspeed = vlen(wishvel);
1016                 if (wishspeed > self.stat_sv_maxspeed*maxspd_mod)
1017                         wishspeed = self.stat_sv_maxspeed*maxspd_mod;
1018                 wishspeed = wishspeed * 0.7;
1019
1020                 // water friction
1021                 self.velocity = self.velocity * (1 - frametime * autocvar_sv_friction);
1022
1023                 // water acceleration
1024                 PM_Accelerate(wishdir, wishspeed, wishspeed, autocvar_sv_accelerate*maxspd_mod, 1, 0, 0, 0);
1025         }
1026         else if (time < self.ladder_time)
1027         {
1028                 // on a spawnfunc_func_ladder or swimming in spawnfunc_func_water
1029                 self.flags &= ~FL_ONGROUND;
1030
1031                 float g;
1032                 g = autocvar_sv_gravity * frametime;
1033                 if(self.gravity)
1034                         g *= self.gravity;
1035                 if(autocvar_sv_gameplayfix_gravityunaffectedbyticrate)
1036                 {
1037                         g *= 0.5;
1038                         self.velocity_z += g;
1039                 }
1040
1041                 self.velocity = self.velocity * (1 - frametime * autocvar_sv_friction);
1042                 makevectors(self.v_angle);
1043                 //wishvel = v_forward * self.movement_x + v_right * self.movement_y + v_up * self.movement_z;
1044                 wishvel = v_forward * self.movement.x + v_right * self.movement.y + '0 0 1' * self.movement.z;
1045                 self.velocity_z += g;
1046                 if (self.ladder_entity.classname == "func_water")
1047                 {
1048                         f = vlen(wishvel);
1049                         if (f > self.ladder_entity.speed)
1050                                 wishvel = wishvel * (self.ladder_entity.speed / f);
1051
1052                         self.watertype = self.ladder_entity.skin;
1053                         f = self.ladder_entity.origin.z + self.ladder_entity.maxs.z;
1054                         if ((self.origin.z + self.view_ofs.z) < f)
1055                                 self.waterlevel = WATERLEVEL_SUBMERGED;
1056                         else if ((self.origin.z + (self.mins.z + self.maxs.z) * 0.5) < f)
1057                                 self.waterlevel = WATERLEVEL_SWIMMING;
1058                         else if ((self.origin.z + self.mins.z + 1) < f)
1059                                 self.waterlevel = WATERLEVEL_WETFEET;
1060                         else
1061                         {
1062                                 self.waterlevel = WATERLEVEL_NONE;
1063                                 self.watertype = CONTENT_EMPTY;
1064                         }
1065                 }
1066                 // acceleration
1067                 wishdir = normalize(wishvel);
1068                 wishspeed = vlen(wishvel);
1069                 if (wishspeed > self.stat_sv_maxspeed*maxspd_mod)
1070                         wishspeed = self.stat_sv_maxspeed*maxspd_mod;
1071                 if (time >= self.teleport_time)
1072                 {
1073                         // water acceleration
1074                         PM_Accelerate(wishdir, wishspeed, wishspeed, autocvar_sv_accelerate*maxspd_mod, 1, 0, 0, 0);
1075                 }
1076         }
1077         else if (self.items & IT_USING_JETPACK)
1078         {
1079                 //makevectors(self.v_angle_y * '0 1 0');
1080                 makevectors(self.v_angle);
1081                 wishvel = v_forward * self.movement.x + v_right * self.movement.y;
1082                 // add remaining speed as Z component
1083                 maxairspd = autocvar_sv_maxairspeed*max(1, maxspd_mod);
1084                 // fix speedhacks :P
1085                 wishvel = normalize(wishvel) * min(vlen(wishvel) / maxairspd, 1);
1086                 // add the unused velocity as up component
1087                 wishvel.z = 0;
1088
1089                 // if(self.BUTTON_JUMP)
1090                         wishvel.z = sqrt(max(0, 1 - wishvel * wishvel));
1091
1092                 // it is now normalized, so...
1093                 float a_side, a_up, a_add, a_diff;
1094                 a_side = autocvar_g_jetpack_acceleration_side;
1095                 a_up = autocvar_g_jetpack_acceleration_up;
1096                 a_add = autocvar_g_jetpack_antigravity * autocvar_sv_gravity;
1097
1098                 wishvel.x *= a_side;
1099                 wishvel.y *= a_side;
1100                 wishvel.z *= a_up;
1101                 wishvel.z += a_add;
1102
1103                 float best;
1104                 best = 0;
1105                 //////////////////////////////////////////////////////////////////////////////////////
1106                 // finding the maximum over all vectors of above form
1107                 // with wishvel having an absolute value of 1
1108                 //////////////////////////////////////////////////////////////////////////////////////
1109                 // we're finding the maximum over
1110                 //   f(a_side, a_up, a_add, z) := a_side * (1 - z^2) + (a_add + a_up * z)^2;
1111                 // for z in the range from -1 to 1
1112                 //////////////////////////////////////////////////////////////////////////////////////
1113                 // maximum is EITHER attained at the single extreme point:
1114                 a_diff = a_side * a_side - a_up * a_up;
1115                 if(a_diff != 0)
1116                 {
1117                         f = a_add * a_up / a_diff; // this is the zero of diff(f(a_side, a_up, a_add, z), z)
1118                         if(f > -1 && f < 1) // can it be attained?
1119                         {
1120                                 best = (a_diff + a_add * a_add) * (a_diff + a_up * a_up) / a_diff;
1121                                 //print("middle\n");
1122                         }
1123                 }
1124                 // OR attained at z = 1:
1125                 f = (a_up + a_add) * (a_up + a_add);
1126                 if(f > best)
1127                 {
1128                         best = f;
1129                         //print("top\n");
1130                 }
1131                 // OR attained at z = -1:
1132                 f = (a_up - a_add) * (a_up - a_add);
1133                 if(f > best)
1134                 {
1135                         best = f;
1136                         //print("bottom\n");
1137                 }
1138                 best = sqrt(best);
1139                 //////////////////////////////////////////////////////////////////////////////////////
1140
1141                 //print("best possible acceleration: ", ftos(best), "\n");
1142
1143                 float fxy, fz;
1144                 fxy = bound(0, 1 - (self.velocity * normalize(wishvel.x * '1 0 0' + wishvel.y * '0 1 0')) / autocvar_g_jetpack_maxspeed_side, 1);
1145                 if(wishvel.z - autocvar_sv_gravity > 0)
1146                         fz = bound(0, 1 - self.velocity.z / autocvar_g_jetpack_maxspeed_up, 1);
1147                 else
1148                         fz = bound(0, 1 + self.velocity.z / autocvar_g_jetpack_maxspeed_up, 1);
1149
1150                 wishvel.x *= fxy;
1151                 wishvel.y *= fxy;
1152                 wishvel.z = (wishvel.z - autocvar_sv_gravity) * fz + autocvar_sv_gravity;
1153
1154                 float fvel;
1155                 fvel = min(1, vlen(wishvel) / best);
1156                 if(autocvar_g_jetpack_fuel && !(self.items & IT_UNLIMITED_WEAPON_AMMO))
1157                         f = min(1, self.ammo_fuel / (autocvar_g_jetpack_fuel * frametime * fvel));
1158                 else
1159                         f = 1;
1160
1161                 //print("this acceleration: ", ftos(vlen(wishvel) * f), "\n");
1162
1163                 if (f > 0 && wishvel != '0 0 0')
1164                 {
1165                         self.velocity = self.velocity + wishvel * f * frametime;
1166                         if (!(self.items & IT_UNLIMITED_WEAPON_AMMO))
1167                                 self.ammo_fuel -= autocvar_g_jetpack_fuel * frametime * fvel * f;
1168                         self.flags &= ~FL_ONGROUND;
1169                         self.items |= IT_USING_JETPACK;
1170
1171                         // jetpack also inhibits health regeneration, but only for 1 second
1172                         self.pauseregen_finished = max(self.pauseregen_finished, time + autocvar_g_balance_pause_fuel_regen);
1173                 }
1174         }
1175         else if (self.flags & FL_ONGROUND)
1176         {
1177                 // we get here if we ran out of ammo
1178                 if((self.items & IT_JETPACK) && self.BUTTON_HOOK && !(buttons_prev & 32) && self.ammo_fuel < 0.01)
1179                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL);
1180
1181                 // walking
1182                 makevectors(self.v_angle.y * '0 1 0');
1183                 wishvel = v_forward * self.movement.x + v_right * self.movement.y;
1184
1185                 if(!(self.lastflags & FL_ONGROUND))
1186                 {
1187                         if(autocvar_speedmeter)
1188                                 dprint(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n"));
1189                         if(self.lastground < time - 0.3)
1190                                 self.velocity = self.velocity * (1 - autocvar_sv_friction_on_land);
1191                         if(self.jumppadcount > 1)
1192                                 dprint(strcat(ftos(self.jumppadcount), "x jumppad combo\n"));
1193                         self.jumppadcount = 0;
1194                 }
1195
1196                 v = self.velocity;
1197                 v.z = 0;
1198                 f = vlen(v);
1199                 if(f > 0)
1200                 {
1201                         if (f < autocvar_sv_stopspeed)
1202                                 f = 1 - frametime * (autocvar_sv_stopspeed / f) * autocvar_sv_friction;
1203                         else
1204                                 f = 1 - frametime * autocvar_sv_friction;
1205                         if (f > 0)
1206                                 self.velocity = self.velocity * f;
1207                         else
1208                                 self.velocity = '0 0 0';
1209                         /*
1210                            Mathematical analysis time!
1211
1212                            Our goal is to invert this mess.
1213
1214                            For the two cases we get:
1215                                 v = v0 * (1 - frametime * (autocvar_sv_stopspeed / v0) * autocvar_sv_friction)
1216                                   = v0 - frametime * autocvar_sv_stopspeed * autocvar_sv_friction
1217                                 v0 = v + frametime * autocvar_sv_stopspeed * autocvar_sv_friction
1218                            and
1219                                 v = v0 * (1 - frametime * autocvar_sv_friction)
1220                                 v0 = v / (1 - frametime * autocvar_sv_friction)
1221
1222                            These cases would be chosen ONLY if:
1223                                 v0 < autocvar_sv_stopspeed
1224                                 v + frametime * autocvar_sv_stopspeed * autocvar_sv_friction < autocvar_sv_stopspeed
1225                                 v < autocvar_sv_stopspeed * (1 - frametime * autocvar_sv_friction)
1226                            and, respectively:
1227                                 v0 >= autocvar_sv_stopspeed
1228                                 v / (1 - frametime * autocvar_sv_friction) >= autocvar_sv_stopspeed
1229                                 v >= autocvar_sv_stopspeed * (1 - frametime * autocvar_sv_friction)
1230                          */
1231                 }
1232
1233                 // acceleration
1234                 wishdir = normalize(wishvel);
1235                 wishspeed = vlen(wishvel);
1236                 if (wishspeed > self.stat_sv_maxspeed*maxspd_mod)
1237                         wishspeed = self.stat_sv_maxspeed*maxspd_mod;
1238                 if (self.crouch)
1239                         wishspeed = wishspeed * 0.5;
1240                 if (time >= self.teleport_time)
1241                         PM_Accelerate(wishdir, wishspeed, wishspeed, autocvar_sv_accelerate*maxspd_mod, 1, 0, 0, 0);
1242         }
1243         else
1244         {
1245                 float wishspeed0;
1246                 // we get here if we ran out of ammo
1247                 if((self.items & IT_JETPACK) && self.BUTTON_HOOK && !(buttons_prev & 32) && self.ammo_fuel < 0.01)
1248                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL);
1249
1250                 if(maxspd_mod < 1)
1251                 {
1252                         maxairspd = autocvar_sv_maxairspeed*maxspd_mod;
1253                         airaccel = autocvar_sv_airaccelerate*maxspd_mod;
1254                 }
1255                 else
1256                 {
1257                         maxairspd = autocvar_sv_maxairspeed;
1258                         airaccel = autocvar_sv_airaccelerate;
1259                 }
1260                 // airborn
1261                 makevectors(self.v_angle.y * '0 1 0');
1262                 wishvel = v_forward * self.movement.x + v_right * self.movement.y;
1263                 // acceleration
1264                 wishdir = normalize(wishvel);
1265                 wishspeed = wishspeed0 = vlen(wishvel);
1266                 if (wishspeed0 > self.stat_sv_maxspeed*maxspd_mod)
1267                         wishspeed0 = self.stat_sv_maxspeed*maxspd_mod;
1268                 if (wishspeed > maxairspd)
1269                         wishspeed = maxairspd;
1270                 if (self.crouch)
1271                         wishspeed = wishspeed * 0.5;
1272                 if (time >= self.teleport_time)
1273                 {
1274                         float accelerating;
1275                         float wishspeed2;
1276                         float airaccelqw;
1277                         float strafity;
1278
1279                         airaccelqw = self.stat_sv_airaccel_qw;
1280                         accelerating = (self.velocity * wishdir > 0);
1281                         wishspeed2 = wishspeed;
1282
1283                         // CPM
1284                         if(autocvar_sv_airstopaccelerate)
1285                         {
1286                                 vector curdir;
1287                                 curdir = self.velocity;
1288                                 curdir.z = 0;
1289                                 curdir = normalize(curdir);
1290                                 airaccel = airaccel + (autocvar_sv_airstopaccelerate*maxspd_mod - airaccel) * max(0, -(curdir * wishdir));
1291                         }
1292                         // note that for straight forward jumping:
1293                         // step = accel * frametime * wishspeed0;
1294                         // accel  = bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
1295                         // -->
1296                         // dv/dt = accel * maxspeed (when slow)
1297                         // dv/dt = accel * maxspeed * (1 - accelqw) (when fast)
1298                         // log dv/dt = logaccel + logmaxspeed (when slow)
1299                         // log dv/dt = logaccel + logmaxspeed + log(1 - accelqw) (when fast)
1300                         strafity = IsMoveInDirection(self.movement, -90) + IsMoveInDirection(self.movement, +90); // if one is nonzero, other is always zero
1301                         if(autocvar_sv_maxairstrafespeed)
1302                                 wishspeed = min(wishspeed, GeomLerp(autocvar_sv_maxairspeed*maxspd_mod, strafity, autocvar_sv_maxairstrafespeed*maxspd_mod));
1303                         if(autocvar_sv_airstrafeaccelerate)
1304                                 airaccel = GeomLerp(airaccel, strafity, autocvar_sv_airstrafeaccelerate*maxspd_mod);
1305                         if(self.stat_sv_airstrafeaccel_qw)
1306                                 airaccelqw = copysign(1-GeomLerp(1-fabs(self.stat_sv_airaccel_qw), strafity, 1-fabs(self.stat_sv_airstrafeaccel_qw)), ((strafity > 0.5) ? self.stat_sv_airstrafeaccel_qw : self.stat_sv_airaccel_qw));
1307                         // !CPM
1308
1309                         if(autocvar_sv_warsowbunny_turnaccel && accelerating && self.movement_y == 0 && self.movement.x != 0)
1310                                 PM_AirAccelerate(wishdir, wishspeed);
1311                         else
1312                                 PM_Accelerate(wishdir, wishspeed, wishspeed0, airaccel, airaccelqw, autocvar_sv_airaccel_qw_stretchfactor, autocvar_sv_airaccel_sideways_friction / maxairspd, self.stat_sv_airspeedlimit_nonqw);
1313
1314                         if(autocvar_sv_aircontrol)
1315                                 CPM_PM_Aircontrol(wishdir, wishspeed2);
1316                 }
1317         }
1318
1319         if((g_cts || g_race) && !IS_OBSERVER(self))
1320         {
1321                 if(vlen(self.velocity - self.velocity.z * '0 0 1') > speedaward_speed)
1322                 {
1323                         speedaward_speed = vlen(self.velocity - self.velocity.z * '0 0 1');
1324                         speedaward_holder = self.netname;
1325                         speedaward_uid = self.crypto_idfp;
1326                         speedaward_lastupdate = time;
1327                 }
1328                 if(speedaward_speed > speedaward_lastsent && time - speedaward_lastupdate > 1)
1329                 {
1330                         string rr = (g_cts) ? CTS_RECORD : RACE_RECORD;
1331                         race_send_speedaward(MSG_ALL);
1332                         speedaward_lastsent = speedaward_speed;
1333                         if (speedaward_speed > speedaward_alltimebest && speedaward_uid != "")
1334                         {
1335                                 speedaward_alltimebest = speedaward_speed;
1336                                 speedaward_alltimebest_holder = speedaward_holder;
1337                                 speedaward_alltimebest_uid = speedaward_uid;
1338                                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/speed"), ftos(speedaward_alltimebest));
1339                                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/crypto_idfp"), speedaward_alltimebest_uid);
1340                                 race_send_speedaward_alltimebest(MSG_ALL);
1341                         }
1342                 }
1343         }
1344
1345         // WEAPONTODO
1346         float xyspeed;
1347         xyspeed = vlen('1 0 0' * self.velocity.x + '0 1 0' * self.velocity.y);
1348         if(self.weapon == WEP_VORTEX && WEP_CVAR(vortex, charge) && WEP_CVAR(vortex, charge_velocity_rate) && xyspeed > WEP_CVAR(vortex, charge_minspeed))
1349         {
1350                 // add a maximum of charge_velocity_rate when going fast (f = 1), gradually increasing from minspeed (f = 0) to maxspeed
1351                 xyspeed = min(xyspeed, WEP_CVAR(vortex, charge_maxspeed));
1352                 f = (xyspeed - WEP_CVAR(vortex, charge_minspeed)) / (WEP_CVAR(vortex, charge_maxspeed) - WEP_CVAR(vortex, charge_minspeed));
1353                 // add the extra charge
1354                 self.vortex_charge = min(1, self.vortex_charge + WEP_CVAR(vortex, charge_velocity_rate) * f * frametime);
1355         }
1356 :end
1357         if(self.flags & FL_ONGROUND)
1358                 self.lastground = time;
1359
1360         // conveyors: then break velocity again
1361         if(self.conveyor.state)
1362                 self.velocity += self.conveyor.movedir;
1363
1364         self.lastflags = self.flags;
1365         self.lastclassname = self.classname;
1366 }