qcsrc/common/physics.qc

   1 #include "physics.qh"
   2 #include "triggers/trigger/swamp.qh"
   3 #include "triggers/trigger/jumppads.qh"
   4 #include "viewloc.qh"
   5
   6 #ifdef SVQC
   7
   8 #include "../server/miscfunctions.qh"
   9 #include "triggers/trigger/viewloc.qh"
  10
  11 // client side physics
  12 bool Physics_Valid(string thecvar)
  13 {
  14         if(!autocvar_g_physics_clientselect) { return false; }
  15
  16         string l = strcat(" ", autocvar_g_physics_clientselect_options, " ");
  17
  18         if(strstrofs(l, strcat(" ", thecvar, " "), 0) >= 0)
  19                 return true;
  20
  21         return false;
  22 }
  23
  24 float Physics_ClientOption(entity pl, string option)
  25 {
  26         if(Physics_Valid(pl.cvar_cl_physics))
  27         {
  28                 string s = sprintf("g_physics_%s_%s", pl.cvar_cl_physics, option);
  29                 if(cvar_type(s) & CVAR_TYPEFLAG_EXISTS)
  30                         return cvar(s);
  31         }
  32         if(autocvar_g_physics_clientselect && autocvar_g_physics_clientselect_default)
  33         {
  34                 string s = sprintf("g_physics_%s_%s", autocvar_g_physics_clientselect_default, option);
  35                 if(cvar_type(s) & CVAR_TYPEFLAG_EXISTS)
  36                         return cvar(s);
  37         }
  38         return cvar(strcat("sv_", option));
  39 }
  40
  41 void Physics_AddStats()
  42 {
  43         // static view offset and hitbox vectors
  44         // networked for all you bandwidth pigs out there
  45         addstat(STAT_PL_VIEW_OFS1, AS_FLOAT, stat_pl_view_ofs_x);
  46         addstat(STAT_PL_VIEW_OFS2, AS_FLOAT, stat_pl_view_ofs_y);
  47         addstat(STAT_PL_VIEW_OFS3, AS_FLOAT, stat_pl_view_ofs_z);
  48         addstat(STAT_PL_CROUCH_VIEW_OFS1, AS_FLOAT, stat_pl_crouch_view_ofs_x);
  49         addstat(STAT_PL_CROUCH_VIEW_OFS2, AS_FLOAT, stat_pl_crouch_view_ofs_y);
  50         addstat(STAT_PL_CROUCH_VIEW_OFS3, AS_FLOAT, stat_pl_crouch_view_ofs_z);
  51
  52         addstat(STAT_PL_MIN1, AS_FLOAT, stat_pl_min_x);
  53         addstat(STAT_PL_MIN2, AS_FLOAT, stat_pl_min_y);
  54         addstat(STAT_PL_MIN3, AS_FLOAT, stat_pl_min_z);
  55         addstat(STAT_PL_MAX1, AS_FLOAT, stat_pl_max_x);
  56         addstat(STAT_PL_MAX2, AS_FLOAT, stat_pl_max_y);
  57         addstat(STAT_PL_MAX3, AS_FLOAT, stat_pl_max_z);
  58         addstat(STAT_PL_CROUCH_MIN1, AS_FLOAT, stat_pl_crouch_min_x);
  59         addstat(STAT_PL_CROUCH_MIN2, AS_FLOAT, stat_pl_crouch_min_y);
  60         addstat(STAT_PL_CROUCH_MIN3, AS_FLOAT, stat_pl_crouch_min_z);
  61         addstat(STAT_PL_CROUCH_MAX1, AS_FLOAT, stat_pl_crouch_max_x);
  62         addstat(STAT_PL_CROUCH_MAX2, AS_FLOAT, stat_pl_crouch_max_y);
  63         addstat(STAT_PL_CROUCH_MAX3, AS_FLOAT, stat_pl_crouch_max_z);
  64
  65         // g_movementspeed hack
  66         addstat(STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW, AS_FLOAT, stat_sv_airspeedlimit_nonqw);
  67         addstat(STAT_MOVEVARS_MAXSPEED, AS_FLOAT, stat_sv_maxspeed);
  68         addstat(STAT_MOVEVARS_AIRACCEL_QW, AS_FLOAT, stat_sv_airaccel_qw);
  69         addstat(STAT_MOVEVARS_AIRSTRAFEACCEL_QW, AS_FLOAT, stat_sv_airstrafeaccel_qw);
  70         addstat(STAT_MOVEVARS_HIGHSPEED, AS_FLOAT, stat_movement_highspeed);
  71
  72         // jet pack
  73         addstat(STAT_JETPACK_ACCEL_SIDE, AS_FLOAT, stat_jetpack_accel_side);
  74         addstat(STAT_JETPACK_ACCEL_UP, AS_FLOAT, stat_jetpack_accel_up);
  75         addstat(STAT_JETPACK_ANTIGRAVITY, AS_FLOAT, stat_jetpack_antigravity);
  76         addstat(STAT_JETPACK_FUEL, AS_FLOAT, stat_jetpack_fuel);
  77         addstat(STAT_JETPACK_MAXSPEED_UP, AS_FLOAT, stat_jetpack_maxspeed_up);
  78         addstat(STAT_JETPACK_MAXSPEED_SIDE, AS_FLOAT, stat_jetpack_maxspeed_side);
  79
  80         // hack to fix track_canjump
  81         addstat(STAT_MOVEVARS_CL_TRACK_CANJUMP, AS_INT, cvar_cl_movement_track_canjump);
  82         addstat(STAT_MOVEVARS_TRACK_CANJUMP, AS_INT, stat_sv_track_canjump);
  83
  84         // double jump
  85         addstat(STAT_DOUBLEJUMP, AS_INT, stat_doublejump);
  86
  87         // jump speed caps
  88         addstat(STAT_MOVEVARS_JUMPSPEEDCAP_DISABLE_ONRAMPS, AS_INT, stat_jumpspeedcap_disable_onramps);
  89
  90         // hacks
  91         addstat(STAT_MOVEVARS_FRICTION_ONLAND, AS_FLOAT, stat_sv_friction_on_land);
  92         addstat(STAT_MOVEVARS_FRICTION_SLICK, AS_FLOAT, stat_sv_friction_slick);
  93         addstat(STAT_GAMEPLAYFIX_EASIERWATERJUMP, AS_INT, stat_gameplayfix_easierwaterjump);
  94
  95         // new properties
  96         addstat(STAT_MOVEVARS_JUMPVELOCITY, AS_FLOAT, stat_sv_jumpvelocity);
  97         addstat(STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR, AS_FLOAT, stat_sv_airaccel_qw_stretchfactor);
  98         addstat(STAT_MOVEVARS_MAXAIRSTRAFESPEED, AS_FLOAT, stat_sv_maxairstrafespeed);
  99         addstat(STAT_MOVEVARS_MAXAIRSPEED, AS_FLOAT, stat_sv_maxairspeed);
 100         addstat(STAT_MOVEVARS_AIRSTRAFEACCELERATE, AS_FLOAT, stat_sv_airstrafeaccelerate);
 101         addstat(STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL, AS_FLOAT, stat_sv_warsowbunny_turnaccel);
 102         addstat(STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION, AS_FLOAT, stat_sv_airaccel_sideways_friction);
 103         addstat(STAT_MOVEVARS_AIRCONTROL, AS_FLOAT, stat_sv_aircontrol);
 104         addstat(STAT_MOVEVARS_AIRCONTROL_POWER, AS_FLOAT, stat_sv_aircontrol_power);
 105         addstat(STAT_MOVEVARS_AIRCONTROL_PENALTY, AS_FLOAT, stat_sv_aircontrol_penalty);
 106         addstat(STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL, AS_FLOAT, stat_sv_warsowbunny_airforwardaccel);
 107         addstat(STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED, AS_FLOAT, stat_sv_warsowbunny_topspeed);
 108         addstat(STAT_MOVEVARS_WARSOWBUNNY_ACCEL, AS_FLOAT, stat_sv_warsowbunny_accel);
 109         addstat(STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO, AS_FLOAT, stat_sv_warsowbunny_backtosideratio);
 110         addstat(STAT_MOVEVARS_FRICTION, AS_FLOAT, stat_sv_friction);
 111         addstat(STAT_MOVEVARS_ACCELERATE, AS_FLOAT, stat_sv_accelerate);
 112         addstat(STAT_MOVEVARS_STOPSPEED, AS_FLOAT, stat_sv_stopspeed);
 113         addstat(STAT_MOVEVARS_AIRACCELERATE, AS_FLOAT, stat_sv_airaccelerate);
 114         addstat(STAT_MOVEVARS_AIRSTOPACCELERATE, AS_FLOAT, stat_sv_airstopaccelerate);
 115
 116         addstat(STAT_GAMEPLAYFIX_UPVELOCITYCLEARSONGROUND, AS_INT, stat_gameplayfix_upvelocityclearsonground);
 117 }
 118
 119 void Physics_UpdateStats(float maxspd_mod)
 120 {SELFPARAM();
 121         // blah
 122         self.stat_pl_view_ofs = PL_VIEW_OFS;
 123         self.stat_pl_crouch_view_ofs = PL_CROUCH_VIEW_OFS;
 124
 125         self.stat_pl_min = PL_MIN;
 126         self.stat_pl_max = PL_MAX;
 127         self.stat_pl_crouch_min = PL_CROUCH_MIN;
 128         self.stat_pl_crouch_max = PL_CROUCH_MAX;
 129
 130
 131         self.stat_sv_airaccel_qw = AdjustAirAccelQW(Physics_ClientOption(self, "airaccel_qw"), maxspd_mod);
 132         if(Physics_ClientOption(self, "airstrafeaccel_qw"))
 133                 self.stat_sv_airstrafeaccel_qw = AdjustAirAccelQW(Physics_ClientOption(self, "airstrafeaccel_qw"), maxspd_mod);
 134         else
 135                 self.stat_sv_airstrafeaccel_qw = 0;
 136         self.stat_sv_airspeedlimit_nonqw = Physics_ClientOption(self, "airspeedlimit_nonqw") * maxspd_mod;
 137         self.stat_sv_maxspeed = Physics_ClientOption(self, "maxspeed") * maxspd_mod; // also slow walking
 138         self.stat_movement_highspeed = PHYS_HIGHSPEED; // TODO: remove this!
 139
 140         self.stat_doublejump = PHYS_DOUBLEJUMP;
 141
 142         self.stat_jetpack_antigravity = PHYS_JETPACK_ANTIGRAVITY;
 143         self.stat_jetpack_accel_up = PHYS_JETPACK_ACCEL_UP;
 144         self.stat_jetpack_accel_side = PHYS_JETPACK_ACCEL_SIDE;
 145         self.stat_jetpack_maxspeed_side = PHYS_JETPACK_MAXSPEED_SIDE;
 146         self.stat_jetpack_maxspeed_up = PHYS_JETPACK_MAXSPEED_UP;
 147         self.stat_jetpack_fuel = PHYS_JETPACK_FUEL;
 148
 149         self.stat_jumpspeedcap_disable_onramps = PHYS_JUMPSPEEDCAP_DISABLE_ONRAMPS;
 150
 151         self.stat_sv_friction_on_land = PHYS_FRICTION_ONLAND;
 152         self.stat_sv_friction_slick = PHYS_FRICTION_SLICK;
 153
 154         self.stat_gameplayfix_easierwaterjump = GAMEPLAYFIX_EASIERWATERJUMP;
 155
 156
 157         // old stats
 158         // fix some new settings
 159         self.stat_sv_airaccel_qw_stretchfactor = Physics_ClientOption(self, "airaccel_qw_stretchfactor");
 160         self.stat_sv_maxairstrafespeed = Physics_ClientOption(self, "maxairstrafespeed");
 161         self.stat_sv_maxairspeed = Physics_ClientOption(self, "maxairspeed");
 162         self.stat_sv_airstrafeaccelerate = Physics_ClientOption(self, "airstrafeaccelerate");
 163         self.stat_sv_warsowbunny_turnaccel = Physics_ClientOption(self, "warsowbunny_turnaccel");
 164         self.stat_sv_airaccel_sideways_friction = Physics_ClientOption(self, "airaccel_sideways_friction");
 165         self.stat_sv_aircontrol = Physics_ClientOption(self, "aircontrol");
 166         self.stat_sv_aircontrol_power = Physics_ClientOption(self, "aircontrol_power");
 167         self.stat_sv_aircontrol_penalty = Physics_ClientOption(self, "aircontrol_penalty");
 168         self.stat_sv_warsowbunny_airforwardaccel = Physics_ClientOption(self, "warsowbunny_airforwardaccel");
 169         self.stat_sv_warsowbunny_topspeed = Physics_ClientOption(self, "warsowbunny_topspeed");
 170         self.stat_sv_warsowbunny_accel = Physics_ClientOption(self, "warsowbunny_accel");
 171         self.stat_sv_warsowbunny_backtosideratio = Physics_ClientOption(self, "warsowbunny_backtosideratio");
 172         self.stat_sv_friction = Physics_ClientOption(self, "friction");
 173         self.stat_sv_accelerate = Physics_ClientOption(self, "accelerate");
 174         self.stat_sv_stopspeed = Physics_ClientOption(self, "stopspeed");
 175         self.stat_sv_airaccelerate = Physics_ClientOption(self, "airaccelerate");
 176         self.stat_sv_airstopaccelerate = Physics_ClientOption(self, "airstopaccelerate");
 177         self.stat_sv_jumpvelocity = Physics_ClientOption(self, "jumpvelocity");
 178
 179         self.stat_sv_track_canjump = Physics_ClientOption(self, "track_canjump");
 180
 181         self.stat_gameplayfix_upvelocityclearsonground = UPWARD_VELOCITY_CLEARS_ONGROUND;
 182 }
 183 #endif
 184
 185 float IsMoveInDirection(vector mv, float ang) // key mix factor
 186 {
 187         if (mv_x == 0 && mv_y == 0)
 188                 return 0; // avoid division by zero
 189         ang -= RAD2DEG * atan2(mv_y, mv_x);
 190         ang = remainder(ang, 360) / 45;
 191         return ang > 1 ? 0 : ang < -1 ? 0 : 1 - fabs(ang);
 192 }
 193
 194 float GeomLerp(float a, float lerp, float b)
 195 {
 196         return a == 0 ? (lerp < 1 ? 0 : b)
 197                 : b == 0 ? (lerp > 0 ? 0 : a)
 198                 : a * pow(fabs(b / a), lerp);
 199 }
 200
 201 noref float pmove_waterjumptime;
 202
 203 const float unstick_count = 27;
 204 vector unstick_offsets[unstick_count] =
 205 {
 206 // 1 no nudge (just return the original if this test passes)
 207         '0.000   0.000  0.000',
 208 // 6 simple nudges
 209         ' 0.000  0.000  0.125', '0.000  0.000 -0.125',
 210         '-0.125  0.000  0.000', '0.125  0.000  0.000',
 211         ' 0.000 -0.125  0.000', '0.000  0.125  0.000',
 212 // 4 diagonal flat nudges
 213         '-0.125 -0.125  0.000', '0.125 -0.125  0.000',
 214         '-0.125  0.125  0.000', '0.125  0.125  0.000',
 215 // 8 diagonal upward nudges
 216         '-0.125  0.000  0.125', '0.125  0.000  0.125',
 217         ' 0.000 -0.125  0.125', '0.000  0.125  0.125',
 218         '-0.125 -0.125  0.125', '0.125 -0.125  0.125',
 219         '-0.125  0.125  0.125', '0.125  0.125  0.125',
 220 // 8 diagonal downward nudges
 221         '-0.125  0.000 -0.125', '0.125  0.000 -0.125',
 222         ' 0.000 -0.125 -0.125', '0.000  0.125 -0.125',
 223         '-0.125 -0.125 -0.125', '0.125 -0.125 -0.125',
 224         '-0.125  0.125 -0.125', '0.125  0.125 -0.125',
 225 };
 226
 227 void PM_ClientMovement_Unstick()
 228 {SELFPARAM();
 229         float i;
 230         for (i = 0; i < unstick_count; i++)
 231         {
 232                 vector neworigin = unstick_offsets[i] + self.origin;
 233                 tracebox(neworigin, PL_CROUCH_MIN, PL_CROUCH_MAX, neworigin, MOVE_NORMAL, self);
 234                 if (!trace_startsolid)
 235                 {
 236                         setorigin(self, neworigin);
 237                         return;// true;
 238                 }
 239         }
 240 }
 241
 242 void PM_ClientMovement_UpdateStatus(bool ground)
 243 {SELFPARAM();
 244         // make sure player is not stuck
 245         PM_ClientMovement_Unstick();
 246
 247         // set crouched
 248         if (PHYS_INPUT_BUTTON_CROUCH(self))
 249         {
 250                 // wants to crouch, this always works..
 251                 if (!IS_DUCKED(self))
 252                         SET_DUCKED(self);
 253         }
 254         else
 255         {
 256                 // wants to stand, if currently crouching we need to check for a
 257                 // low ceiling first
 258                 if (IS_DUCKED(self))
 259                 {
 260                         tracebox(self.origin, PL_MIN, PL_MAX, self.origin, MOVE_NORMAL, self);
 261                         if (!trace_startsolid)
 262                                 UNSET_DUCKED(self);
 263                 }
 264         }
 265
 266         // set onground
 267         vector origin1 = self.origin + '0 0 1';
 268         vector origin2 = self.origin - '0 0 1';
 269
 270         if(ground)
 271         {
 272                 tracebox(origin1, self.mins, self.maxs, origin2, MOVE_NORMAL, self);
 273                 if (trace_fraction < 1.0 && trace_plane_normal_z > 0.7)
 274                 {
 275                         SET_ONGROUND(self);
 276
 277                         // this code actually "predicts" an impact; so let's clip velocity first
 278                         float f = self.velocity * trace_plane_normal;
 279                         self.velocity -= f * trace_plane_normal;
 280                 }
 281                 else
 282                         UNSET_ONGROUND(self);
 283         }
 284
 285         // set watertype/waterlevel
 286         origin1 = self.origin;
 287         origin1_z += self.mins_z + 1;
 288         self.waterlevel = WATERLEVEL_NONE;
 289
 290         int thepoint = pointcontents(origin1);
 291
 292         self.watertype = (thepoint == CONTENT_WATER || thepoint == CONTENT_LAVA || thepoint == CONTENT_SLIME);
 293
 294         if(self.watertype)
 295         {
 296                 self.waterlevel = WATERLEVEL_WETFEET;
 297                 origin1_z = self.origin_z + (self.mins_z + self.maxs_z) * 0.5;
 298                 thepoint = pointcontents(origin1);
 299                 if(thepoint == CONTENT_WATER || thepoint == CONTENT_LAVA || thepoint == CONTENT_SLIME)
 300                 {
 301                         self.waterlevel = WATERLEVEL_SWIMMING;
 302                         origin1_z = self.origin_z + 22;
 303                         thepoint = pointcontents(origin1);
 304                         if(thepoint == CONTENT_WATER || thepoint == CONTENT_LAVA || thepoint == CONTENT_SLIME)
 305                                 self.waterlevel = WATERLEVEL_SUBMERGED;
 306                 }
 307         }
 308
 309         if(IS_ONGROUND(self) || self.velocity_z <= 0 || pmove_waterjumptime <= 0)
 310                 pmove_waterjumptime = 0;
 311 }
 312
 313 void PM_ClientMovement_Move()
 314 {SELFPARAM();
 315 #ifdef CSQC
 316         int bump;
 317         float t;
 318         float f;
 319         vector neworigin;
 320         vector currentorigin2;
 321         vector neworigin2;
 322         vector primalvelocity;
 323
 324         vector trace1_endpos = '0 0 0';
 325         vector trace2_endpos = '0 0 0';
 326         vector trace3_endpos = '0 0 0';
 327         float trace1_fraction = 0;
 328         float trace2_fraction = 0;
 329         float trace3_fraction = 0;
 330         vector trace1_plane_normal = '0 0 0';
 331         vector trace2_plane_normal = '0 0 0';
 332         vector trace3_plane_normal = '0 0 0';
 333
 334
 335         PM_ClientMovement_UpdateStatus(false);
 336         primalvelocity = self.velocity;
 337         for(bump = 0, t = PHYS_INPUT_TIMELENGTH; bump < 8 && (self.velocity * self.velocity) > 0; bump++)
 338         {
 339                 neworigin = self.origin + t * self.velocity;
 340                 tracebox(self.origin, self.mins, self.maxs, neworigin, MOVE_NORMAL, self);
 341                 trace1_endpos = trace_endpos;
 342                 trace1_fraction = trace_fraction;
 343                 trace1_plane_normal = trace_plane_normal;
 344                 if(trace1_fraction < 1 && trace1_plane_normal_z == 0)
 345                 {
 346                         // may be a step or wall, try stepping up
 347                         // first move forward at a higher level
 348                         currentorigin2 = self.origin;
 349                         currentorigin2_z += PHYS_STEPHEIGHT;
 350                         neworigin2 = neworigin;
 351                         neworigin2_z += PHYS_STEPHEIGHT;
 352                         tracebox(currentorigin2, self.mins, self.maxs, neworigin2, MOVE_NORMAL, self);
 353                         trace2_endpos = trace_endpos;
 354                         trace2_fraction = trace_fraction;
 355                         trace2_plane_normal = trace_plane_normal;
 356                         if(!trace_startsolid)
 357                         {
 358                                 // then move down from there
 359                                 currentorigin2 = trace2_endpos;
 360                                 neworigin2 = trace2_endpos;
 361                                 neworigin2_z = self.origin_z;
 362                                 tracebox(currentorigin2, self.mins, self.maxs, neworigin2, MOVE_NORMAL, self);
 363                                 trace3_endpos = trace_endpos;
 364                                 trace3_fraction = trace_fraction;
 365                                 trace3_plane_normal = trace_plane_normal;
 366                                 // accept the new trace if it made some progress
 367                                 if(fabs(trace3_endpos_x - trace1_endpos_x) >= 0.03125 || fabs(trace3_endpos_y - trace1_endpos_y) >= 0.03125)
 368                                 {
 369                                         trace1_endpos = trace2_endpos;
 370                                         trace1_fraction = trace2_fraction;
 371                                         trace1_plane_normal = trace2_plane_normal;
 372                                         trace1_endpos = trace3_endpos;
 373                                 }
 374                         }
 375                 }
 376
 377                 // check if it moved at all
 378                 if(trace1_fraction >= 0.001)
 379                         setorigin(self, trace1_endpos);
 380
 381                 // check if it moved all the way
 382                 if(trace1_fraction == 1)
 383                         break;
 384
 385                 // this is only really needed for nogravityonground combined with gravityunaffectedbyticrate
 386                 // <LordHavoc> I'm pretty sure I commented it out solely because it seemed redundant
 387                 // this got commented out in a change that supposedly makes the code match QW better
 388                 // so if this is broken, maybe put it in an if(cls.protocol != PROTOCOL_QUAKEWORLD) block
 389                 if(trace1_plane_normal_z > 0.7)
 390                         SET_ONGROUND(self);
 391
 392                 t -= t * trace1_fraction;
 393
 394                 f = (self.velocity * trace1_plane_normal);
 395                 self.velocity = self.velocity + -f * trace1_plane_normal;
 396         }
 397         if(pmove_waterjumptime > 0)
 398                 self.velocity = primalvelocity;
 399 #endif
 400 }
 401
 402 void CPM_PM_Aircontrol(vector wishdir, float wishspeed)
 403 {SELFPARAM();
 404         float k = 32 * (2 * IsMoveInDirection(self.movement, 0) - 1);
 405         if (k <= 0)
 406                 return;
 407
 408         k *= bound(0, wishspeed / PHYS_MAXAIRSPEED(self), 1);
 409
 410         float zspeed = self.velocity_z;
 411         self.velocity_z = 0;
 412         float xyspeed = vlen(self.velocity);
 413         self.velocity = normalize(self.velocity);
 414
 415         float dot = self.velocity * wishdir;
 416
 417         if (dot > 0) // we can't change direction while slowing down
 418         {
 419                 k *= pow(dot, PHYS_AIRCONTROL_POWER) * PHYS_INPUT_TIMELENGTH;
 420                 xyspeed = max(0, xyspeed - PHYS_AIRCONTROL_PENALTY * sqrt(max(0, 1 - dot*dot)) * k/32);
 421                 k *= PHYS_AIRCONTROL;
 422                 self.velocity = normalize(self.velocity * xyspeed + wishdir * k);
 423         }
 424
 425         self.velocity = self.velocity * xyspeed;
 426         self.velocity_z = zspeed;
 427 }
 428
 429 float AdjustAirAccelQW(float accelqw, float factor)
 430 {
 431         return copysign(bound(0.000001, 1 - (1 - fabs(accelqw)) * factor, 1), accelqw);
 432 }
 433
 434 // example config for alternate speed clamping:
 435 //   sv_airaccel_qw 0.8
 436 //   sv_airaccel_sideways_friction 0
 437 //   prvm_globalset server speedclamp_mode 1
 438 //     (or 2)
 439 void PM_Accelerate(vector wishdir, float wishspeed, float wishspeed0, float accel, float accelqw, float stretchfactor, float sidefric, float speedlimit)
 440 {SELFPARAM();
 441         float speedclamp = stretchfactor > 0 ? stretchfactor
 442         : accelqw < 0 ? 1 // full clamping, no stretch
 443         : -1; // no clamping
 444
 445         accelqw = fabs(accelqw);
 446
 447         if (GAMEPLAYFIX_Q2AIRACCELERATE)
 448                 wishspeed0 = wishspeed; // don't need to emulate this Q1 bug
 449
 450         float vel_straight = self.velocity * wishdir;
 451         float vel_z = self.velocity_z;
 452         vector vel_xy = vec2(self.velocity);
 453         vector vel_perpend = vel_xy - vel_straight * wishdir;
 454
 455         float step = accel * PHYS_INPUT_TIMELENGTH * wishspeed0;
 456
 457         float vel_xy_current  = vlen(vel_xy);
 458         if (speedlimit)
 459                 accelqw = AdjustAirAccelQW(accelqw, (speedlimit - bound(wishspeed, vel_xy_current, speedlimit)) / max(1, speedlimit - wishspeed));
 460         float vel_xy_forward =  vel_xy_current  + bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
 461         float vel_xy_backward = vel_xy_current  - bound(0, wishspeed + vel_xy_current, step) * accelqw - step * (1 - accelqw);
 462         vel_xy_backward = max(0, vel_xy_backward); // not that it REALLY occurs that this would cause wrong behaviour afterwards
 463         vel_straight =          vel_straight    + bound(0, wishspeed - vel_straight,   step) * accelqw + step * (1 - accelqw);
 464
 465         if (sidefric < 0 && (vel_perpend*vel_perpend))
 466                 // negative: only apply so much sideways friction to stay below the speed you could get by "braking"
 467         {
 468                 float f = max(0, 1 + PHYS_INPUT_TIMELENGTH * wishspeed * sidefric);
 469                 float fmin = (vel_xy_backward * vel_xy_backward - vel_straight * vel_straight) / (vel_perpend * vel_perpend);
 470                 // assume: fmin > 1
 471                 // vel_xy_backward*vel_xy_backward - vel_straight*vel_straight > vel_perpend*vel_perpend
 472                 // vel_xy_backward*vel_xy_backward > vel_straight*vel_straight + vel_perpend*vel_perpend
 473                 // vel_xy_backward*vel_xy_backward > vel_xy * vel_xy
 474                 // obviously, this cannot be
 475                 if (fmin <= 0)
 476                         vel_perpend *= f;
 477                 else
 478                 {
 479                         fmin = sqrt(fmin);
 480                         vel_perpend *= max(fmin, f);
 481                 }
 482         }
 483         else
 484                 vel_perpend *= max(0, 1 - PHYS_INPUT_TIMELENGTH * wishspeed * sidefric);
 485
 486         vel_xy = vel_straight * wishdir + vel_perpend;
 487
 488         if (speedclamp >= 0)
 489         {
 490                 float vel_xy_preclamp;
 491                 vel_xy_preclamp = vlen(vel_xy);
 492                 if (vel_xy_preclamp > 0) // prevent division by zero
 493                 {
 494                         vel_xy_current += (vel_xy_forward - vel_xy_current) * speedclamp;
 495                         if (vel_xy_current < vel_xy_preclamp)
 496                                 vel_xy *= (vel_xy_current / vel_xy_preclamp);
 497                 }
 498         }
 499
 500         self.velocity = vel_xy + vel_z * '0 0 1';
 501 }
 502
 503 void PM_AirAccelerate(vector wishdir, float wishspeed)
 504 {SELFPARAM();
 505         if (wishspeed == 0)
 506                 return;
 507
 508         vector curvel = self.velocity;
 509         curvel_z = 0;
 510         float curspeed = vlen(curvel);
 511
 512         if (wishspeed > curspeed * 1.01)
 513                 wishspeed = min(wishspeed, curspeed + PHYS_WARSOWBUNNY_AIRFORWARDACCEL * PHYS_MAXSPEED(self) * PHYS_INPUT_TIMELENGTH);
 514         else
 515         {
 516                 float f = max(0, (PHYS_WARSOWBUNNY_TOPSPEED - curspeed) / (PHYS_WARSOWBUNNY_TOPSPEED - PHYS_MAXSPEED(self)));
 517                 wishspeed = max(curspeed, PHYS_MAXSPEED(self)) + PHYS_WARSOWBUNNY_ACCEL * f * PHYS_MAXSPEED(self) * PHYS_INPUT_TIMELENGTH;
 518         }
 519         vector wishvel = wishdir * wishspeed;
 520         vector acceldir = wishvel - curvel;
 521         float addspeed = vlen(acceldir);
 522         acceldir = normalize(acceldir);
 523
 524         float accelspeed = min(addspeed, PHYS_WARSOWBUNNY_TURNACCEL * PHYS_MAXSPEED(self) * PHYS_INPUT_TIMELENGTH);
 525
 526         if (PHYS_WARSOWBUNNY_BACKTOSIDERATIO < 1)
 527         {
 528                 vector curdir = normalize(curvel);
 529                 float dot = acceldir * curdir;
 530                 if (dot < 0)
 531                         acceldir -= (1 - PHYS_WARSOWBUNNY_BACKTOSIDERATIO) * dot * curdir;
 532         }
 533
 534         self.velocity += accelspeed * acceldir;
 535 }
 536
 537
 538 /*
 539 =============
 540 PlayerJump
 541
 542 When you press the jump key
 543 returns true if handled
 544 =============
 545 */
 546 bool PlayerJump (void)
 547 {SELFPARAM();
 548         if (PHYS_FROZEN(self))
 549                 return true; // no jumping in freezetag when frozen
 550
 551 #ifdef SVQC
 552         if (self.player_blocked)
 553                 return true; // no jumping while blocked
 554 #endif
 555
 556         bool doublejump = false;
 557         float mjumpheight = PHYS_JUMPVELOCITY;
 558 #ifdef CSQC
 559         player_multijump = doublejump;
 560         player_jumpheight = mjumpheight;
 561 #endif
 562
 563         if (MUTATOR_CALLHOOK(PlayerJump, doublejump, mjumpheight)
 564 #ifdef CSQC
 565                 || PM_multijump_checkjump()
 566 #endif
 567                 ) { return true; }
 568
 569         doublejump = player_multijump;
 570         mjumpheight = player_jumpheight;
 571
 572         if (PHYS_DOUBLEJUMP)
 573         {
 574                 tracebox(self.origin + '0 0 0.01', self.mins, self.maxs, self.origin - '0 0 0.01', MOVE_NORMAL, self);
 575                 if (trace_fraction < 1 && trace_plane_normal_z > 0.7)
 576                 {
 577                         doublejump = true;
 578
 579                         // we MUST clip velocity here!
 580                         float f;
 581                         f = self.velocity * trace_plane_normal;
 582                         if (f < 0)
 583                                 self.velocity -= f * trace_plane_normal;
 584                 }
 585         }
 586
 587         if (self.waterlevel >= WATERLEVEL_SWIMMING)
 588         {
 589                 self.velocity_z = PHYS_MAXSPEED(self) * 0.7;
 590                 return true;
 591         }
 592
 593         if (!doublejump)
 594                 if (!IS_ONGROUND(self))
 595                         return IS_JUMP_HELD(self);
 596
 597         bool track_jump = PHYS_CL_TRACK_CANJUMP(self);
 598         if(PHYS_TRACK_CANJUMP(self))
 599                 track_jump = true;
 600
 601         if (track_jump)
 602                 if (IS_JUMP_HELD(self))
 603                         return true;
 604
 605         // sv_jumpspeedcap_min/sv_jumpspeedcap_max act as baseline
 606         // velocity bounds.  Final velocity is bound between (jumpheight *
 607         // min + jumpheight) and (jumpheight * max + jumpheight);
 608
 609         if(PHYS_JUMPSPEEDCAP_MIN != "")
 610         {
 611                 float minjumpspeed = mjumpheight * stof(PHYS_JUMPSPEEDCAP_MIN);
 612
 613                 if (self.velocity_z < minjumpspeed)
 614                         mjumpheight += minjumpspeed - self.velocity_z;
 615         }
 616
 617         if(PHYS_JUMPSPEEDCAP_MAX != "")
 618         {
 619                 // don't do jump speedcaps on ramps to preserve old xonotic ramjump style
 620                 tracebox(self.origin + '0 0 0.01', self.mins, self.maxs, self.origin - '0 0 0.01', MOVE_NORMAL, self);
 621
 622                 if (!(trace_fraction < 1 && trace_plane_normal_z < 0.98 && PHYS_JUMPSPEEDCAP_DISABLE_ONRAMPS))
 623                 {
 624                         float maxjumpspeed = mjumpheight * stof(PHYS_JUMPSPEEDCAP_MAX);
 625
 626                         if (self.velocity_z > maxjumpspeed)
 627                                 mjumpheight -= self.velocity_z - maxjumpspeed;
 628                 }
 629         }
 630
 631         if (!WAS_ONGROUND(self))
 632         {
 633 #ifdef SVQC
 634                 if(autocvar_speedmeter)
 635                         LOG_TRACE(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n"));
 636 #endif
 637                 if(self.lastground < time - 0.3)
 638                 {
 639                         self.velocity_x *= (1 - PHYS_FRICTION_ONLAND);
 640                         self.velocity_y *= (1 - PHYS_FRICTION_ONLAND);
 641                 }
 642 #ifdef SVQC
 643                 if(self.jumppadcount > 1)
 644                         LOG_TRACE(strcat(ftos(self.jumppadcount), "x jumppad combo\n"));
 645                 self.jumppadcount = 0;
 646 #endif
 647         }
 648
 649         self.velocity_z += mjumpheight;
 650
 651         UNSET_ONGROUND(self);
 652         SET_JUMP_HELD(self);
 653
 654 #ifdef SVQC
 655
 656         self.oldvelocity_z = self.velocity_z;
 657
 658         animdecide_setaction(self, ANIMACTION_JUMP, true);
 659
 660         if (autocvar_g_jump_grunt)
 661                 PlayerSound(playersound_jump, CH_PLAYER, VOICETYPE_PLAYERSOUND);
 662 #endif
 663         return true;
 664 }
 665
 666 void CheckWaterJump()
 667 {SELFPARAM();
 668 // check for a jump-out-of-water
 669         makevectors(self.v_angle);
 670         vector start = self.origin;
 671         start_z += 8;
 672         v_forward_z = 0;
 673         normalize(v_forward);
 674         vector end = start + v_forward*24;
 675         traceline (start, end, true, self);
 676         if (trace_fraction < 1)
 677         {       // solid at waist
 678                 start_z = start_z + self.maxs_z - 8;
 679                 end = start + v_forward*24;
 680                 self.movedir = trace_plane_normal * -50;
 681                 traceline(start, end, true, self);
 682                 if (trace_fraction == 1)
 683                 {       // open at eye level
 684                         self.velocity_z = 225;
 685                         self.flags |= FL_WATERJUMP;
 686                         SET_JUMP_HELD(self);
 687 #ifdef SVQC
 688                         self.teleport_time = time + 2;  // safety net
 689 #elif defined(CSQC)
 690                         pmove_waterjumptime = time + 2;
 691 #endif
 692                 }
 693         }
 694 }
 695
 696
 697 #ifdef SVQC
 698         #define JETPACK_JUMP(s) s.cvar_cl_jetpack_jump
 699 #elif defined(CSQC)
 700         float autocvar_cl_jetpack_jump;
 701         #define JETPACK_JUMP(s) autocvar_cl_jetpack_jump
 702 #endif
 703 .float jetpack_stopped;
 704 // Hack: shouldn't need to know about this
 705 .float multijump_count;
 706 void CheckPlayerJump()
 707 {SELFPARAM();
 708 #ifdef SVQC
 709         float was_flying = ITEMS_STAT(self) & IT_USING_JETPACK;
 710 #endif
 711         if (JETPACK_JUMP(self) < 2)
 712                 ITEMS_STAT(self) &= ~IT_USING_JETPACK;
 713
 714         if(PHYS_INPUT_BUTTON_JUMP(self) || PHYS_INPUT_BUTTON_JETPACK(self))
 715         {
 716                 float air_jump = !PlayerJump() || self.multijump_count > 0; // PlayerJump() has important side effects
 717                 float activate = JETPACK_JUMP(self) && air_jump && PHYS_INPUT_BUTTON_JUMP(self) || PHYS_INPUT_BUTTON_JETPACK(self);
 718                 float has_fuel = !PHYS_JETPACK_FUEL || PHYS_AMMO_FUEL(self) || ITEMS_STAT(self) & IT_UNLIMITED_WEAPON_AMMO;
 719
 720                 if (!(ITEMS_STAT(self) & ITEM_Jetpack.m_itemid)) { }
 721                 else if (self.jetpack_stopped) { }
 722                 else if (!has_fuel)
 723                 {
 724 #ifdef SVQC
 725                         if (was_flying) // TODO: ran out of fuel message
 726                                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL);
 727                         else if (activate)
 728                                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL);
 729 #endif
 730                         self.jetpack_stopped = true;
 731                         ITEMS_STAT(self) &= ~IT_USING_JETPACK;
 732                 }
 733                 else if (activate && !PHYS_FROZEN(self))
 734                         ITEMS_STAT(self) |= IT_USING_JETPACK;
 735         }
 736         else
 737         {
 738                 self.jetpack_stopped = false;
 739                 ITEMS_STAT(self) &= ~IT_USING_JETPACK;
 740         }
 741         if (!PHYS_INPUT_BUTTON_JUMP(self))
 742                 UNSET_JUMP_HELD(self);
 743
 744         if (self.waterlevel == WATERLEVEL_SWIMMING)
 745                 CheckWaterJump();
 746 }
 747
 748 float racecar_angle(float forward, float down)
 749 {
 750         if (forward < 0)
 751         {
 752                 forward = -forward;
 753                 down = -down;
 754         }
 755
 756         float ret = vectoyaw('0 1 0' * down + '1 0 0' * forward);
 757
 758         float angle_mult = forward / (800 + forward);
 759
 760         if (ret > 180)
 761                 return ret * angle_mult + 360 * (1 - angle_mult);
 762         else
 763                 return ret * angle_mult;
 764 }
 765
 766 void RaceCarPhysics()
 767 {SELFPARAM();
 768 #ifdef SVQC
 769         // using this move type for "big rigs"
 770         // the engine does not push the entity!
 771
 772         vector rigvel;
 773
 774         vector angles_save = self.angles;
 775         float accel = bound(-1, self.movement.x / PHYS_MAXSPEED(self), 1);
 776         float steer = bound(-1, self.movement.y / PHYS_MAXSPEED(self), 1);
 777
 778         if (g_bugrigs_reverse_speeding)
 779         {
 780                 if (accel < 0)
 781                 {
 782                         // back accel is DIGITAL
 783                         // to prevent speedhack
 784                         if (accel < -0.5)
 785                                 accel = -1;
 786                         else
 787                                 accel = 0;
 788                 }
 789         }
 790
 791         self.angles_x = 0;
 792         self.angles_z = 0;
 793         makevectors(self.angles); // new forward direction!
 794
 795         if (IS_ONGROUND(self) || g_bugrigs_air_steering)
 796         {
 797                 float myspeed = self.velocity * v_forward;
 798                 float upspeed = self.velocity * v_up;
 799
 800                 // responsiveness factor for steering and acceleration
 801                 float f = 1 / (1 + pow(max(-myspeed, myspeed) / g_bugrigs_speed_ref, g_bugrigs_speed_pow));
 802                 //MAXIMA: f(v) := 1 / (1 + (v / g_bugrigs_speed_ref) ^ g_bugrigs_speed_pow);
 803
 804                 float steerfactor;
 805                 if (myspeed < 0 && g_bugrigs_reverse_spinning)
 806                         steerfactor = -myspeed * g_bugrigs_steer;
 807                 else
 808                         steerfactor = -myspeed * f * g_bugrigs_steer;
 809
 810                 float accelfactor;
 811                 if (myspeed < 0 && g_bugrigs_reverse_speeding)
 812                         accelfactor = g_bugrigs_accel;
 813                 else
 814                         accelfactor = f * g_bugrigs_accel;
 815                 //MAXIMA: accel(v) := f(v) * g_bugrigs_accel;
 816
 817                 if (accel < 0)
 818                 {
 819                         if (myspeed > 0)
 820                         {
 821                                 myspeed = max(0, myspeed - PHYS_INPUT_TIMELENGTH * (g_bugrigs_friction_floor - g_bugrigs_friction_brake * accel));
 822                         }
 823                         else
 824                         {
 825                                 if (!g_bugrigs_reverse_speeding)
 826                                         myspeed = min(0, myspeed + PHYS_INPUT_TIMELENGTH * g_bugrigs_friction_floor);
 827                         }
 828                 }
 829                 else
 830                 {
 831                         if (myspeed >= 0)
 832                         {
 833                                 myspeed = max(0, myspeed - PHYS_INPUT_TIMELENGTH * g_bugrigs_friction_floor);
 834                         }
 835                         else
 836                         {
 837                                 if (g_bugrigs_reverse_stopping)
 838                                         myspeed = 0;
 839                                 else
 840                                         myspeed = min(0, myspeed + PHYS_INPUT_TIMELENGTH * (g_bugrigs_friction_floor + g_bugrigs_friction_brake * accel));
 841                         }
 842                 }
 843                 // terminal velocity = velocity at which 50 == accelfactor, that is, 1549 units/sec
 844                 //MAXIMA: friction(v) := g_bugrigs_friction_floor;
 845
 846                 self.angles_y += steer * PHYS_INPUT_TIMELENGTH * steerfactor; // apply steering
 847                 makevectors(self.angles); // new forward direction!
 848
 849                 myspeed += accel * accelfactor * PHYS_INPUT_TIMELENGTH;
 850
 851                 rigvel = myspeed * v_forward + '0 0 1' * upspeed;
 852         }
 853         else
 854         {
 855                 float myspeed = vlen(self.velocity);
 856
 857                 // responsiveness factor for steering and acceleration
 858                 float f = 1 / (1 + pow(max(0, myspeed / g_bugrigs_speed_ref), g_bugrigs_speed_pow));
 859                 float steerfactor = -myspeed * f;
 860                 self.angles_y += steer * PHYS_INPUT_TIMELENGTH * steerfactor; // apply steering
 861
 862                 rigvel = self.velocity;
 863                 makevectors(self.angles); // new forward direction!
 864         }
 865
 866         rigvel *= max(0, 1 - vlen(rigvel) * g_bugrigs_friction_air * PHYS_INPUT_TIMELENGTH);
 867         //MAXIMA: airfriction(v) := v * v * g_bugrigs_friction_air;
 868         //MAXIMA: total_acceleration(v) := accel(v) - friction(v) - airfriction(v);
 869         //MAXIMA: solve(total_acceleration(v) = 0, v);
 870
 871         if (g_bugrigs_planar_movement)
 872         {
 873                 vector rigvel_xy, neworigin, up;
 874                 float mt;
 875
 876                 rigvel_z -= PHYS_INPUT_TIMELENGTH * PHYS_GRAVITY; // 4x gravity plays better
 877                 rigvel_xy = vec2(rigvel);
 878
 879                 if (g_bugrigs_planar_movement_car_jumping)
 880                         mt = MOVE_NORMAL;
 881                 else
 882                         mt = MOVE_NOMONSTERS;
 883
 884                 tracebox(self.origin, self.mins, self.maxs, self.origin + '0 0 1024', mt, self);
 885                 up = trace_endpos - self.origin;
 886
 887                 // BUG RIGS: align the move to the surface instead of doing collision testing
 888                 // can we move?
 889                 tracebox(trace_endpos, self.mins, self.maxs, trace_endpos + rigvel_xy * PHYS_INPUT_TIMELENGTH, mt, self);
 890
 891                 // align to surface
 892                 tracebox(trace_endpos, self.mins, self.maxs, trace_endpos - up + '0 0 1' * rigvel_z * PHYS_INPUT_TIMELENGTH, mt, self);
 893
 894                 if (trace_fraction < 0.5)
 895                 {
 896                         trace_fraction = 1;
 897                         neworigin = self.origin;
 898                 }
 899                 else
 900                         neworigin = trace_endpos;
 901
 902                 if (trace_fraction < 1)
 903                 {
 904                         // now set angles_x so that the car points parallel to the surface
 905                         self.angles = vectoangles(
 906                                         '1 0 0' * v_forward_x * trace_plane_normal_z
 907                                         +
 908                                         '0 1 0' * v_forward_y * trace_plane_normal_z
 909                                         +
 910                                         '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y)
 911                                         );
 912                         SET_ONGROUND(self);
 913                 }
 914                 else
 915                 {
 916                         // now set angles_x so that the car points forward, but is tilted in velocity direction
 917                         UNSET_ONGROUND(self);
 918                 }
 919
 920                 self.velocity = (neworigin - self.origin) * (1.0 / PHYS_INPUT_TIMELENGTH);
 921                 self.movetype = MOVETYPE_NOCLIP;
 922         }
 923         else
 924         {
 925                 rigvel_z -= PHYS_INPUT_TIMELENGTH * PHYS_GRAVITY; // 4x gravity plays better
 926                 self.velocity = rigvel;
 927                 self.movetype = MOVETYPE_FLY;
 928         }
 929
 930         trace_fraction = 1;
 931         tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 4', MOVE_NORMAL, self);
 932         if (trace_fraction != 1)
 933         {
 934                 self.angles = vectoangles2(
 935                                 '1 0 0' * v_forward_x * trace_plane_normal_z
 936                                 +
 937                                 '0 1 0' * v_forward_y * trace_plane_normal_z
 938                                 +
 939                                 '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y),
 940                                 trace_plane_normal
 941                                 );
 942         }
 943         else
 944         {
 945                 vector vel_local;
 946
 947                 vel_local_x = v_forward * self.velocity;
 948                 vel_local_y = v_right * self.velocity;
 949                 vel_local_z = v_up * self.velocity;
 950
 951                 self.angles_x = racecar_angle(vel_local_x, vel_local_z);
 952                 self.angles_z = racecar_angle(-vel_local_y, vel_local_z);
 953         }
 954
 955         // smooth the angles
 956         vector vf1, vu1, smoothangles;
 957         makevectors(self.angles);
 958         float f = bound(0, PHYS_INPUT_TIMELENGTH * g_bugrigs_angle_smoothing, 1);
 959         if (f == 0)
 960                 f = 1;
 961         vf1 = v_forward * f;
 962         vu1 = v_up * f;
 963         makevectors(angles_save);
 964         vf1 = vf1 + v_forward * (1 - f);
 965         vu1 = vu1 + v_up * (1 - f);
 966         smoothangles = vectoangles2(vf1, vu1);
 967         self.angles_x = -smoothangles_x;
 968         self.angles_z =  smoothangles_z;
 969 #endif
 970 }
 971
 972 string specialcommand = "xwxwxsxsxaxdxaxdx1x ";
 973 .float specialcommand_pos;
 974 void SpecialCommand()
 975 {
 976 #ifdef SVQC
 977 #ifdef TETRIS
 978         TetrisImpulse();
 979 #else
 980         if (!CheatImpulse(99))
 981                 LOG_INFO("A hollow voice says \"Plugh\".\n");
 982 #endif
 983 #endif
 984 }
 985
 986 void PM_check_race_movetime(void)
 987 {SELFPARAM();
 988 #ifdef SVQC
 989         self.race_movetime_frac += PHYS_INPUT_TIMELENGTH;
 990         float f = floor(self.race_movetime_frac);
 991         self.race_movetime_frac -= f;
 992         self.race_movetime_count += f;
 993         self.race_movetime = self.race_movetime_frac + self.race_movetime_count;
 994 #endif
 995 }
 996
 997 float PM_check_specialcommand(float buttons)
 998 {SELFPARAM();
 999 #ifdef SVQC
1000         string c;
1001         if (!buttons)
1002                 c = "x";
1003         else if (buttons == 1)
1004                 c = "1";
1005         else if (buttons == 2)
1006                 c = " ";
1007         else if (buttons == 128)
1008                 c = "s";
1009         else if (buttons == 256)
1010                 c = "w";
1011         else if (buttons == 512)
1012                 c = "a";
1013         else if (buttons == 1024)
1014                 c = "d";
1015         else
1016                 c = "?";
1017
1018         if (c == substring(specialcommand, self.specialcommand_pos, 1))
1019         {
1020                 self.specialcommand_pos += 1;
1021                 if (self.specialcommand_pos >= strlen(specialcommand))
1022                 {
1023                         self.specialcommand_pos = 0;
1024                         SpecialCommand();
1025                         return true;
1026                 }
1027         }
1028         else if (self.specialcommand_pos && (c != substring(specialcommand, self.specialcommand_pos - 1, 1)))
1029                 self.specialcommand_pos = 0;
1030 #endif
1031         return false;
1032 }
1033
1034 void PM_check_nickspam(void)
1035 {SELFPARAM();
1036 #ifdef SVQC
1037         if (time >= self.nickspamtime)
1038                 return;
1039         if (self.nickspamcount >= autocvar_g_nick_flood_penalty_yellow)
1040         {
1041                 // slight annoyance for nick change scripts
1042                 self.movement = -1 * self.movement;
1043                 self.BUTTON_ATCK = self.BUTTON_JUMP = self.BUTTON_ATCK2 = self.BUTTON_ZOOM = self.BUTTON_CROUCH = self.BUTTON_HOOK = self.BUTTON_USE = 0;
1044
1045                 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!
1046                 {
1047                         self.v_angle_x = random() * 360;
1048                         self.v_angle_y = random() * 360;
1049                         // at least I'm not forcing retardedview by also assigning to angles_z
1050                         self.fixangle = true;
1051                 }
1052         }
1053 #endif
1054 }
1055
1056 void PM_check_punch()
1057 {SELFPARAM();
1058 #ifdef SVQC
1059         if (self.punchangle != '0 0 0')
1060         {
1061                 float f = vlen(self.punchangle) - 10 * PHYS_INPUT_TIMELENGTH;
1062                 if (f > 0)
1063                         self.punchangle = normalize(self.punchangle) * f;
1064                 else
1065                         self.punchangle = '0 0 0';
1066         }
1067
1068         if (self.punchvector != '0 0 0')
1069         {
1070                 float f = vlen(self.punchvector) - 30 * PHYS_INPUT_TIMELENGTH;
1071                 if (f > 0)
1072                         self.punchvector = normalize(self.punchvector) * f;
1073                 else
1074                         self.punchvector = '0 0 0';
1075         }
1076 #endif
1077 }
1078
1079 void PM_check_spider(void)
1080 {SELFPARAM();
1081 #ifdef SVQC
1082         if (time >= self.spider_slowness)
1083                 return;
1084         PHYS_MAXSPEED(self) *= 0.5; // half speed while slow from spider
1085         PHYS_MAXAIRSPEED(self) *= 0.5;
1086         PHYS_AIRSPEEDLIMIT_NONQW(self) *= 0.5;
1087         PHYS_AIRSTRAFEACCELERATE(self) *= 0.5;
1088 #endif
1089 }
1090
1091 // predict frozen movement, as frozen players CAN move in some cases
1092 void PM_check_frozen(void)
1093 {SELFPARAM();
1094         if (!PHYS_FROZEN(self))
1095                 return;
1096         if (PHYS_DODGING_FROZEN
1097 #ifdef SVQC
1098         && IS_REAL_CLIENT(self)
1099 #endif
1100         )
1101         {
1102                 self.movement_x = bound(-5, self.movement.x, 5);
1103                 self.movement_y = bound(-5, self.movement.y, 5);
1104                 self.movement_z = bound(-5, self.movement.z, 5);
1105         }
1106         else
1107                 self.movement = '0 0 0';
1108
1109         vector midpoint = ((self.absmin + self.absmax) * 0.5);
1110         if (pointcontents(midpoint) == CONTENT_WATER)
1111         {
1112                 self.velocity = self.velocity * 0.5;
1113
1114                 if (pointcontents(midpoint + '0 0 16') == CONTENT_WATER)
1115                         self.velocity_z = 200;
1116         }
1117 }
1118
1119 void PM_check_hitground()
1120 {SELFPARAM();
1121 #ifdef SVQC
1122         if (IS_ONGROUND(self))
1123         if (IS_PLAYER(self)) // no fall sounds for observers thank you very much
1124         if (self.wasFlying)
1125         {
1126                 self.wasFlying = 0;
1127                 if (self.waterlevel < WATERLEVEL_SWIMMING)
1128                 if (time >= self.ladder_time)
1129                 if (!self.hook)
1130                 {
1131                         self.nextstep = time + 0.3 + random() * 0.1;
1132                         trace_dphitq3surfaceflags = 0;
1133                         tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 1', MOVE_NOMONSTERS, self);
1134                         if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOSTEPS))
1135                         {
1136                                 if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_METALSTEPS)
1137                                         GlobalSound(globalsound_metalfall, CH_PLAYER, VOICETYPE_PLAYERSOUND);
1138                                 else
1139                                         GlobalSound(globalsound_fall, CH_PLAYER, VOICETYPE_PLAYERSOUND);
1140                         }
1141                 }
1142         }
1143 #endif
1144 }
1145
1146 void PM_check_blocked(void)
1147 {SELFPARAM();
1148 #ifdef SVQC
1149         if (!self.player_blocked)
1150                 return;
1151         self.movement = '0 0 0';
1152         self.disableclientprediction = 1;
1153 #endif
1154 }
1155
1156 #ifdef SVQC
1157 float speedaward_lastsent;
1158 float speedaward_lastupdate;
1159 #endif
1160 void PM_check_race(void)
1161 {SELFPARAM();
1162 #ifdef SVQC
1163         if(!(g_cts || g_race))
1164                 return;
1165         if (vlen(self.velocity - self.velocity_z * '0 0 1') > speedaward_speed)
1166         {
1167                 speedaward_speed = vlen(self.velocity - self.velocity_z * '0 0 1');
1168                 speedaward_holder = self.netname;
1169                 speedaward_uid = self.crypto_idfp;
1170                 speedaward_lastupdate = time;
1171         }
1172         if (speedaward_speed > speedaward_lastsent && time - speedaward_lastupdate > 1)
1173         {
1174                 string rr = (g_cts) ? CTS_RECORD : RACE_RECORD;
1175                 race_send_speedaward(MSG_ALL);
1176                 speedaward_lastsent = speedaward_speed;
1177                 if (speedaward_speed > speedaward_alltimebest && speedaward_uid != "")
1178                 {
1179                         speedaward_alltimebest = speedaward_speed;
1180                         speedaward_alltimebest_holder = speedaward_holder;
1181                         speedaward_alltimebest_uid = speedaward_uid;
1182                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/speed"), ftos(speedaward_alltimebest));
1183                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/crypto_idfp"), speedaward_alltimebest_uid);
1184                         race_send_speedaward_alltimebest(MSG_ALL);
1185                 }
1186         }
1187 #endif
1188 }
1189
1190 void PM_check_vortex(void)
1191 {SELFPARAM();
1192 #ifdef SVQC
1193         // WEAPONTODO
1194         float xyspeed = vlen(vec2(self.velocity));
1195         if (self.weapon == WEP_VORTEX.m_id && WEP_CVAR(vortex, charge) && WEP_CVAR(vortex, charge_velocity_rate) && xyspeed > WEP_CVAR(vortex, charge_minspeed))
1196         {
1197                 // add a maximum of charge_velocity_rate when going fast (f = 1), gradually increasing from minspeed (f = 0) to maxspeed
1198                 xyspeed = min(xyspeed, WEP_CVAR(vortex, charge_maxspeed));
1199                 float f = (xyspeed - WEP_CVAR(vortex, charge_minspeed)) / (WEP_CVAR(vortex, charge_maxspeed) - WEP_CVAR(vortex, charge_minspeed));
1200                 // add the extra charge
1201                 self.vortex_charge = min(1, self.vortex_charge + WEP_CVAR(vortex, charge_velocity_rate) * f * PHYS_INPUT_TIMELENGTH);
1202         }
1203 #endif
1204 }
1205
1206 void PM_fly(float maxspd_mod)
1207 {SELFPARAM();
1208         // noclipping or flying
1209         UNSET_ONGROUND(self);
1210
1211         self.velocity = self.velocity * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION);
1212         makevectors(self.v_angle);
1213         //wishvel = v_forward * self.movement.x + v_right * self.movement.y + v_up * self.movement.z;
1214         vector wishvel = v_forward * self.movement.x
1215                                         + v_right * self.movement.y
1216                                         + '0 0 1' * self.movement.z;
1217         // acceleration
1218         vector wishdir = normalize(wishvel);
1219         float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod);
1220 #ifdef SVQC
1221         if (time >= self.teleport_time)
1222 #endif
1223                 PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE * maxspd_mod, 1, 0, 0, 0);
1224         PM_ClientMovement_Move();
1225 }
1226
1227 void PM_swim(float maxspd_mod)
1228 {SELFPARAM();
1229         // swimming
1230         UNSET_ONGROUND(self);
1231
1232         float jump = PHYS_INPUT_BUTTON_JUMP(self);
1233         // water jump only in certain situations
1234         // this mimics quakeworld code
1235         if (jump && self.waterlevel == WATERLEVEL_SWIMMING && self.velocity_z >= -180)
1236         {
1237                 vector yawangles = '0 1 0' * self.v_angle.y;
1238                 makevectors(yawangles);
1239                 vector forward = v_forward;
1240                 vector spot = self.origin + 24 * forward;
1241                 spot_z += 8;
1242                 traceline(spot, spot, MOVE_NOMONSTERS, self);
1243                 if (trace_startsolid)
1244                 {
1245                         spot_z += 24;
1246                         traceline(spot, spot, MOVE_NOMONSTERS, self);
1247                         if (!trace_startsolid)
1248                         {
1249                                 self.velocity = forward * 50;
1250                                 self.velocity_z = 310;
1251                                 pmove_waterjumptime = 2;
1252                                 UNSET_ONGROUND(self);
1253                                 SET_JUMP_HELD(self);
1254                         }
1255                 }
1256         }
1257         makevectors(self.v_angle);
1258         //wishvel = v_forward * self.movement.x + v_right * self.movement.y + v_up * self.movement.z;
1259         vector wishvel = v_forward * self.movement.x
1260                                         + v_right * self.movement.y
1261                                         + '0 0 1' * self.movement.z;
1262         if (wishvel == '0 0 0')
1263                 wishvel = '0 0 -60'; // drift towards bottom
1264
1265         vector wishdir = normalize(wishvel);
1266         float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod) * 0.7;
1267
1268         if (IS_DUCKED(self))
1269         wishspeed *= 0.5;
1270
1271 //      if (pmove_waterjumptime <= 0) // TODO: use
1272     {
1273                 // water friction
1274                 float f = 1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION;
1275                 f = min(max(0, f), 1);
1276                 self.velocity *= f;
1277
1278                 f = wishspeed - self.velocity * wishdir;
1279                 if (f > 0)
1280                 {
1281                         float accelspeed = min(PHYS_ACCELERATE * PHYS_INPUT_TIMELENGTH * wishspeed, f);
1282                         self.velocity += accelspeed * wishdir;
1283                 }
1284
1285                 // holding jump button swims upward slowly
1286                 if (jump)
1287                 {
1288 #if 0
1289                         if (self.watertype & CONTENT_LAVA)
1290                                 self.velocity_z =  50;
1291                         else if (self.watertype & CONTENT_SLIME)
1292                                 self.velocity_z =  80;
1293                         else
1294                         {
1295                                 if (IS_NEXUIZ_DERIVED(gamemode))
1296 #endif
1297                                         self.velocity_z = 200;
1298 #if 0
1299                                 else
1300                                         self.velocity_z = 100;
1301                         }
1302 #endif
1303                 }
1304         }
1305         // water acceleration
1306         PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE * maxspd_mod, 1, 0, 0, 0);
1307         PM_ClientMovement_Move();
1308 }
1309
1310 void PM_ladder(float maxspd_mod)
1311 {SELFPARAM();
1312         // on a spawnfunc_func_ladder or swimming in spawnfunc_func_water
1313         UNSET_ONGROUND(self);
1314
1315         float g;
1316         g = PHYS_GRAVITY * PHYS_INPUT_TIMELENGTH;
1317         if (PHYS_ENTGRAVITY(self))
1318                 g *= PHYS_ENTGRAVITY(self);
1319         if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
1320         {
1321                 g *= 0.5;
1322                 self.velocity_z += g;
1323         }
1324
1325         self.velocity = self.velocity * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION);
1326         makevectors(self.v_angle);
1327         //wishvel = v_forward * self.movement.x + v_right * self.movement.y + v_up * self.movement.z;
1328         vector wishvel = v_forward * self.movement_x
1329                                         + v_right * self.movement_y
1330                                         + '0 0 1' * self.movement_z;
1331         self.velocity_z += g;
1332         if (self.ladder_entity.classname == "func_water")
1333         {
1334                 float f = vlen(wishvel);
1335                 if (f > self.ladder_entity.speed)
1336                         wishvel *= (self.ladder_entity.speed / f);
1337
1338                 self.watertype = self.ladder_entity.skin;
1339                 f = self.ladder_entity.origin_z + self.ladder_entity.maxs_z;
1340                 if ((self.origin_z + self.view_ofs_z) < f)
1341                         self.waterlevel = WATERLEVEL_SUBMERGED;
1342                 else if ((self.origin_z + (self.mins_z + self.maxs_z) * 0.5) < f)
1343                         self.waterlevel = WATERLEVEL_SWIMMING;
1344                 else if ((self.origin_z + self.mins_z + 1) < f)
1345                         self.waterlevel = WATERLEVEL_WETFEET;
1346                 else
1347                 {
1348                         self.waterlevel = WATERLEVEL_NONE;
1349                         self.watertype = CONTENT_EMPTY;
1350                 }
1351         }
1352         // acceleration
1353         vector wishdir = normalize(wishvel);
1354         float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod);
1355 #ifdef SVQC
1356         if (time >= self.teleport_time)
1357 #endif
1358                 // water acceleration
1359                 PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE*maxspd_mod, 1, 0, 0, 0);
1360         PM_ClientMovement_Move();
1361 }
1362
1363 void PM_jetpack(float maxspd_mod)
1364 {SELFPARAM();
1365         //makevectors(self.v_angle.y * '0 1 0');
1366         makevectors(self.v_angle);
1367         vector wishvel = v_forward * self.movement_x
1368                                         + v_right * self.movement_y;
1369         // add remaining speed as Z component
1370         float maxairspd = PHYS_MAXAIRSPEED(self) * max(1, maxspd_mod);
1371         // fix speedhacks :P
1372         wishvel = normalize(wishvel) * min(1, vlen(wishvel) / maxairspd);
1373         // add the unused velocity as up component
1374         wishvel_z = 0;
1375
1376         // if (self.BUTTON_JUMP)
1377                 wishvel_z = sqrt(max(0, 1 - wishvel * wishvel));
1378
1379         // it is now normalized, so...
1380         float a_side = PHYS_JETPACK_ACCEL_SIDE;
1381         float a_up = PHYS_JETPACK_ACCEL_UP;
1382         float a_add = PHYS_JETPACK_ANTIGRAVITY * PHYS_GRAVITY;
1383
1384         wishvel_x *= a_side;
1385         wishvel_y *= a_side;
1386         wishvel_z *= a_up;
1387         wishvel_z += a_add;
1388
1389         float best = 0;
1390         //////////////////////////////////////////////////////////////////////////////////////
1391         // finding the maximum over all vectors of above form
1392         // with wishvel having an absolute value of 1
1393         //////////////////////////////////////////////////////////////////////////////////////
1394         // we're finding the maximum over
1395         //   f(a_side, a_up, a_add, z) := a_side * (1 - z^2) + (a_add + a_up * z)^2;
1396         // for z in the range from -1 to 1
1397         //////////////////////////////////////////////////////////////////////////////////////
1398         // maximum is EITHER attained at the single extreme point:
1399         float a_diff = a_side * a_side - a_up * a_up;
1400         float f;
1401         if (a_diff != 0)
1402         {
1403                 f = a_add * a_up / a_diff; // this is the zero of diff(f(a_side, a_up, a_add, z), z)
1404                 if (f > -1 && f < 1) // can it be attained?
1405                 {
1406                         best = (a_diff + a_add * a_add) * (a_diff + a_up * a_up) / a_diff;
1407                         //print("middle\n");
1408                 }
1409         }
1410         // OR attained at z = 1:
1411         f = (a_up + a_add) * (a_up + a_add);
1412         if (f > best)
1413         {
1414                 best = f;
1415                 //print("top\n");
1416         }
1417         // OR attained at z = -1:
1418         f = (a_up - a_add) * (a_up - a_add);
1419         if (f > best)
1420         {
1421                 best = f;
1422                 //print("bottom\n");
1423         }
1424         best = sqrt(best);
1425         //////////////////////////////////////////////////////////////////////////////////////
1426
1427         //print("best possible acceleration: ", ftos(best), "\n");
1428
1429         float fxy, fz;
1430         fxy = bound(0, 1 - (self.velocity * normalize(wishvel_x * '1 0 0' + wishvel_y * '0 1 0')) / PHYS_JETPACK_MAXSPEED_SIDE, 1);
1431         if (wishvel_z - PHYS_GRAVITY > 0)
1432                 fz = bound(0, 1 - self.velocity_z / PHYS_JETPACK_MAXSPEED_UP, 1);
1433         else
1434                 fz = bound(0, 1 + self.velocity_z / PHYS_JETPACK_MAXSPEED_UP, 1);
1435
1436         float fvel;
1437         fvel = vlen(wishvel);
1438         wishvel_x *= fxy;
1439         wishvel_y *= fxy;
1440         wishvel_z = (wishvel_z - PHYS_GRAVITY) * fz + PHYS_GRAVITY;
1441
1442         fvel = min(1, vlen(wishvel) / best);
1443         if (PHYS_JETPACK_FUEL && !(ITEMS_STAT(self) & IT_UNLIMITED_WEAPON_AMMO))
1444                 f = min(1, PHYS_AMMO_FUEL(self) / (PHYS_JETPACK_FUEL * PHYS_INPUT_TIMELENGTH * fvel));
1445         else
1446                 f = 1;
1447
1448         //print("this acceleration: ", ftos(vlen(wishvel) * f), "\n");
1449
1450         if (f > 0 && wishvel != '0 0 0')
1451         {
1452                 self.velocity = self.velocity + wishvel * f * PHYS_INPUT_TIMELENGTH;
1453                 UNSET_ONGROUND(self);
1454
1455 #ifdef SVQC
1456                 if (!(ITEMS_STAT(self) & IT_UNLIMITED_WEAPON_AMMO))
1457                         self.ammo_fuel -= PHYS_JETPACK_FUEL * PHYS_INPUT_TIMELENGTH * fvel * f;
1458
1459                 ITEMS_STAT(self) |= IT_USING_JETPACK;
1460
1461                 // jetpack also inhibits health regeneration, but only for 1 second
1462                 self.pauseregen_finished = max(self.pauseregen_finished, time + autocvar_g_balance_pause_fuel_regen);
1463 #endif
1464         }
1465
1466 #ifdef CSQC
1467         float g = PHYS_GRAVITY * PHYS_ENTGRAVITY(self) * PHYS_INPUT_TIMELENGTH;
1468         if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
1469                 self.velocity_z -= g * 0.5;
1470         else
1471                 self.velocity_z -= g;
1472         PM_ClientMovement_Move();
1473         if (!IS_ONGROUND(self) || !(GAMEPLAYFIX_NOGRAVITYONGROUND))
1474                 if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
1475                         self.velocity_z -= g * 0.5;
1476 #endif
1477 }
1478
1479 void PM_walk(float buttons_prev, float maxspd_mod)
1480 {SELFPARAM();
1481         if (!WAS_ONGROUND(self))
1482         {
1483 #ifdef SVQC
1484                 if (autocvar_speedmeter)
1485                         LOG_TRACE(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n"));
1486 #endif
1487                 if (self.lastground < time - 0.3)
1488                         self.velocity *= (1 - PHYS_FRICTION_ONLAND);
1489 #ifdef SVQC
1490                 if (self.jumppadcount > 1)
1491                         LOG_TRACE(strcat(ftos(self.jumppadcount), "x jumppad combo\n"));
1492                 self.jumppadcount = 0;
1493 #endif
1494         }
1495
1496         // walking
1497         makevectors(self.v_angle.y * '0 1 0');
1498         vector wishvel = v_forward * self.movement.x
1499                                         + v_right * self.movement.y;
1500         // acceleration
1501         vector wishdir = normalize(wishvel);
1502         float wishspeed = vlen(wishvel);
1503
1504         wishspeed = min(wishspeed, PHYS_MAXSPEED(self) * maxspd_mod);
1505         if (IS_DUCKED(self))
1506                 wishspeed *= 0.5;
1507
1508         // apply edge friction
1509         float f = vlen(vec2(self.velocity));
1510         if (f > 0)
1511         {
1512                 float realfriction;
1513                 trace_dphitq3surfaceflags = 0;
1514                 tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 1', MOVE_NOMONSTERS, self);
1515                 // TODO: apply edge friction
1516                 // apply ground friction
1517                 if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SLICK)
1518                         realfriction = PHYS_FRICTION_SLICK;
1519                 else
1520                         realfriction = PHYS_FRICTION;
1521
1522                 f = 1 - PHYS_INPUT_TIMELENGTH * realfriction * ((f < PHYS_STOPSPEED) ? (PHYS_STOPSPEED / f) : 1);
1523                 f = max(0, f);
1524                 self.velocity *= f;
1525                 /*
1526                    Mathematical analysis time!
1527
1528                    Our goal is to invert this mess.
1529
1530                    For the two cases we get:
1531                         v = v0 * (1 - PHYS_INPUT_TIMELENGTH * (PHYS_STOPSPEED / v0) * PHYS_FRICTION)
1532                           = v0 - PHYS_INPUT_TIMELENGTH * PHYS_STOPSPEED * PHYS_FRICTION
1533                         v0 = v + PHYS_INPUT_TIMELENGTH * PHYS_STOPSPEED * PHYS_FRICTION
1534                    and
1535                         v = v0 * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION)
1536                         v0 = v / (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION)
1537
1538                    These cases would be chosen ONLY if:
1539                         v0 < PHYS_STOPSPEED
1540                         v + PHYS_INPUT_TIMELENGTH * PHYS_STOPSPEED * PHYS_FRICTION < PHYS_STOPSPEED
1541                         v < PHYS_STOPSPEED * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION)
1542                    and, respectively:
1543                         v0 >= PHYS_STOPSPEED
1544                         v / (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION) >= PHYS_STOPSPEED
1545                         v >= PHYS_STOPSPEED * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION)
1546                  */
1547         }
1548         float addspeed = wishspeed - self.velocity * wishdir;
1549         if (addspeed > 0)
1550         {
1551                 float accelspeed = min(PHYS_ACCELERATE * PHYS_INPUT_TIMELENGTH * wishspeed, addspeed);
1552                 self.velocity += accelspeed * wishdir;
1553         }
1554         float g = PHYS_GRAVITY * PHYS_ENTGRAVITY(self) * PHYS_INPUT_TIMELENGTH;
1555         if (!(GAMEPLAYFIX_NOGRAVITYONGROUND))
1556                 self.velocity_z -= g * (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE ? 0.5 : 1);
1557         if (self.velocity * self.velocity)
1558                 PM_ClientMovement_Move();
1559         if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
1560                 if (!IS_ONGROUND(self) || !GAMEPLAYFIX_NOGRAVITYONGROUND)
1561                         self.velocity_z -= g * 0.5;
1562 }
1563
1564 void PM_air(float buttons_prev, float maxspd_mod)
1565 {SELFPARAM();
1566         makevectors(self.v_angle.y * '0 1 0');
1567         vector wishvel = v_forward * self.movement.x
1568                                         + v_right * self.movement.y;
1569         // acceleration
1570         vector wishdir = normalize(wishvel);
1571         float wishspeed = vlen(wishvel);
1572
1573 #ifdef SVQC
1574         if (time >= self.teleport_time)
1575 #else
1576         if (pmove_waterjumptime <= 0)
1577 #endif
1578         {
1579                 float maxairspd = PHYS_MAXAIRSPEED(self) * min(maxspd_mod, 1);
1580
1581                 // apply air speed limit
1582                 float airaccelqw = PHYS_AIRACCEL_QW(self);
1583                 float wishspeed0 = wishspeed;
1584                 wishspeed = min(wishspeed, maxairspd);
1585                 if (IS_DUCKED(self))
1586                         wishspeed *= 0.5;
1587                 float airaccel = PHYS_AIRACCELERATE * min(maxspd_mod, 1);
1588
1589                 float accelerating = (self.velocity * wishdir > 0);
1590                 float wishspeed2 = wishspeed;
1591
1592                 // CPM: air control
1593                 if (PHYS_AIRSTOPACCELERATE)
1594                 {
1595                         vector curdir = normalize(vec2(self.velocity));
1596                         airaccel += (PHYS_AIRSTOPACCELERATE*maxspd_mod - airaccel) * max(0, -(curdir * wishdir));
1597                 }
1598                 // note that for straight forward jumping:
1599                 // step = accel * PHYS_INPUT_TIMELENGTH * wishspeed0;
1600                 // accel  = bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
1601                 // -->
1602                 // dv/dt = accel * maxspeed (when slow)
1603                 // dv/dt = accel * maxspeed * (1 - accelqw) (when fast)
1604                 // log dv/dt = logaccel + logmaxspeed (when slow)
1605                 // log dv/dt = logaccel + logmaxspeed + log(1 - accelqw) (when fast)
1606                 float strafity = IsMoveInDirection(self.movement, -90) + IsMoveInDirection(self.movement, +90); // if one is nonzero, other is always zero
1607                 if (PHYS_MAXAIRSTRAFESPEED)
1608                         wishspeed = min(wishspeed, GeomLerp(PHYS_MAXAIRSPEED(self)*maxspd_mod, strafity, PHYS_MAXAIRSTRAFESPEED*maxspd_mod));
1609                 if (PHYS_AIRSTRAFEACCELERATE(self))
1610                         airaccel = GeomLerp(airaccel, strafity, PHYS_AIRSTRAFEACCELERATE(self)*maxspd_mod);
1611                 if (PHYS_AIRSTRAFEACCEL_QW(self))
1612                         airaccelqw =
1613                 (((strafity > 0.5 ? PHYS_AIRSTRAFEACCEL_QW(self) : PHYS_AIRACCEL_QW(self)) >= 0) ? +1 : -1)
1614                 *
1615                 (1 - GeomLerp(1 - fabs(PHYS_AIRACCEL_QW(self)), strafity, 1 - fabs(PHYS_AIRSTRAFEACCEL_QW(self))));
1616                 // !CPM
1617
1618                 if (PHYS_WARSOWBUNNY_TURNACCEL && accelerating && self.movement.y == 0 && self.movement.x != 0)
1619                         PM_AirAccelerate(wishdir, wishspeed2);
1620                 else
1621                         PM_Accelerate(wishdir, wishspeed, wishspeed0, airaccel, airaccelqw, PHYS_AIRACCEL_QW_STRETCHFACTOR(self), PHYS_AIRACCEL_SIDEWAYS_FRICTION / maxairspd, PHYS_AIRSPEEDLIMIT_NONQW(self));
1622
1623                 if (PHYS_AIRCONTROL)
1624                         CPM_PM_Aircontrol(wishdir, wishspeed2);
1625         }
1626         float g = PHYS_GRAVITY * PHYS_ENTGRAVITY(self) * PHYS_INPUT_TIMELENGTH;
1627         if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
1628                 self.velocity_z -= g * 0.5;
1629         else
1630                 self.velocity_z -= g;
1631         PM_ClientMovement_Move();
1632         if (!IS_ONGROUND(self) || !(GAMEPLAYFIX_NOGRAVITYONGROUND))
1633                 if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE)
1634                         self.velocity_z -= g * 0.5;
1635 }
1636
1637 // used for calculating airshots
1638 bool IsFlying(entity a)
1639 {
1640         if(IS_ONGROUND(a))
1641                 return false;
1642         if(a.waterlevel >= WATERLEVEL_SWIMMING)
1643                 return false;
1644         traceline(a.origin, a.origin - '0 0 48', MOVE_NORMAL, a);
1645         if(trace_fraction < 1)
1646                 return false;
1647         return true;
1648 }
1649
1650 void PM_Main()
1651 {SELFPARAM();
1652         int buttons = PHYS_INPUT_BUTTON_MASK(self);
1653 #ifdef CSQC
1654         self.items = getstati(STAT_ITEMS, 0, 24);
1655
1656         self.movement = PHYS_INPUT_MOVEVALUES(self);
1657
1658         vector oldv_angle = self.v_angle;
1659         vector oldangles = self.angles; // we need to save these, as they're abused by other code
1660         self.v_angle = PHYS_INPUT_ANGLES(self);
1661         self.angles = PHYS_WORLD_ANGLES(self);
1662
1663         self.team = myteam + 1; // is this correct?
1664         if (!(PHYS_INPUT_BUTTON_JUMP(self))) // !jump
1665                 UNSET_JUMP_HELD(self); // canjump = true
1666         pmove_waterjumptime -= PHYS_INPUT_TIMELENGTH;
1667
1668         PM_ClientMovement_UpdateStatus(true);
1669 #endif
1670
1671
1672 #ifdef SVQC
1673         WarpZone_PlayerPhysics_FixVAngle();
1674 #endif
1675         float maxspeed_mod = 1;
1676         maxspeed_mod *= PHYS_HIGHSPEED;
1677
1678 #ifdef SVQC
1679         Physics_UpdateStats(maxspeed_mod);
1680
1681         if (self.PlayerPhysplug)
1682                 if (self.PlayerPhysplug())
1683                         return;
1684 #endif
1685
1686         PM_check_race_movetime();
1687 #ifdef SVQC
1688         anticheat_physics();
1689 #endif
1690
1691         if (PM_check_specialcommand(buttons))
1692                 return;
1693 #ifdef SVQC
1694         if (sv_maxidle > 0)
1695         {
1696                 if (buttons != self.buttons_old || self.movement != self.movement_old || self.v_angle != self.v_angle_old)
1697                         self.parm_idlesince = time;
1698         }
1699 #endif
1700         int buttons_prev = self.buttons_old;
1701         self.buttons_old = buttons;
1702         self.movement_old = self.movement;
1703         self.v_angle_old = self.v_angle;
1704
1705         PM_check_nickspam();
1706
1707         PM_check_punch();
1708 #ifdef SVQC
1709         if (IS_BOT_CLIENT(self))
1710         {
1711                 if (playerdemo_read())
1712                         return;
1713                 bot_think();
1714         }
1715
1716         if (IS_PLAYER(self))
1717 #endif
1718         {
1719 #ifdef SVQC
1720                 if (self.race_penalty)
1721                         if (time > self.race_penalty)
1722                                 self.race_penalty = 0;
1723 #endif
1724
1725                 bool not_allowed_to_move = false;
1726 #ifdef SVQC
1727                 if (self.race_penalty)
1728                         not_allowed_to_move = true;
1729 #endif
1730 #ifdef SVQC
1731                 if (time < game_starttime)
1732                         not_allowed_to_move = true;
1733 #endif
1734
1735                 if (not_allowed_to_move)
1736                 {
1737                         self.velocity = '0 0 0';
1738                         self.movetype = MOVETYPE_NONE;
1739 #ifdef SVQC
1740                         self.disableclientprediction = 2;
1741 #endif
1742                 }
1743 #ifdef SVQC
1744                 else if (self.disableclientprediction == 2)
1745                 {
1746                         if (self.movetype == MOVETYPE_NONE)
1747                                 self.movetype = MOVETYPE_WALK;
1748                         self.disableclientprediction = 0;
1749                 }
1750 #endif
1751         }
1752
1753 #ifdef SVQC
1754         if (self.movetype == MOVETYPE_NONE)
1755                 return;
1756
1757         // when we get here, disableclientprediction cannot be 2
1758         self.disableclientprediction = 0;
1759 #endif
1760
1761         viewloc_PlayerPhysics();
1762
1763         PM_check_spider();
1764
1765         PM_check_frozen();
1766
1767         PM_check_blocked();
1768
1769         maxspeed_mod = 1;
1770
1771         if (self.in_swamp)
1772                 maxspeed_mod *= self.swamp_slowdown; //cvar("g_balance_swamp_moverate");
1773
1774         // conveyors: first fix velocity
1775         if (self.conveyor.state)
1776                 self.velocity -= self.conveyor.movedir;
1777
1778 #ifdef SVQC
1779         MUTATOR_CALLHOOK(PlayerPhysics);
1780 #endif
1781 #ifdef CSQC
1782         PM_multijump();
1783 #endif
1784
1785 //      float forcedodge = 1;
1786 //      if(forcedodge) {
1787 //#ifdef CSQC
1788 //              PM_dodging_checkpressedkeys();
1789 //#endif
1790 //              PM_dodging();
1791 //              PM_ClientMovement_Move();
1792 //              return;
1793 //      }
1794
1795 #ifdef SVQC
1796         if (!IS_PLAYER(self))
1797         {
1798                 maxspeed_mod = autocvar_sv_spectator_speed_multiplier;
1799                 if (!self.spectatorspeed)
1800                         self.spectatorspeed = maxspeed_mod;
1801                 if (self.impulse && self.impulse <= 19 || (self.impulse >= 200 && self.impulse <= 209) || (self.impulse >= 220 && self.impulse <= 229))
1802                 {
1803                         if (self.lastclassname != "player")
1804                         {
1805                                 if (self.impulse == 10 || self.impulse == 15 || self.impulse == 18 || (self.impulse >= 200 && self.impulse <= 209))
1806                                         self.spectatorspeed = bound(1, self.spectatorspeed + 0.5, 5);
1807                                 else if (self.impulse == 11)
1808                                         self.spectatorspeed = maxspeed_mod;
1809                                 else if (self.impulse == 12 || self.impulse == 16  || self.impulse == 19 || (self.impulse >= 220 && self.impulse <= 229))
1810                                         self.spectatorspeed = bound(1, self.spectatorspeed - 0.5, 5);
1811                                 else if (self.impulse >= 1 && self.impulse <= 9)
1812                                         self.spectatorspeed = 1 + 0.5 * (self.impulse - 1);
1813                         } // otherwise just clear
1814                         self.impulse = 0;
1815                 }
1816                 maxspeed_mod = self.spectatorspeed;
1817         }
1818
1819         float spd = max(PHYS_MAXSPEED(self), PHYS_MAXAIRSPEED(self)) * maxspeed_mod;
1820         if(self.speed != spd)
1821         {
1822                 self.speed = spd;
1823                 string temps = ftos(spd);
1824                 stuffcmd(self, strcat("cl_forwardspeed ", temps, "\n"));
1825                 stuffcmd(self, strcat("cl_backspeed ", temps, "\n"));
1826                 stuffcmd(self, strcat("cl_sidespeed ", temps, "\n"));
1827                 stuffcmd(self, strcat("cl_upspeed ", temps, "\n"));
1828         }
1829
1830         if(self.stat_jumpspeedcap_min != PHYS_JUMPSPEEDCAP_MIN)
1831         {
1832                 self.stat_jumpspeedcap_min = PHYS_JUMPSPEEDCAP_MIN;
1833                 stuffcmd(self, strcat("cl_jumpspeedcap_min ", PHYS_JUMPSPEEDCAP_MIN, "\n"));
1834         }
1835         if(self.stat_jumpspeedcap_max != PHYS_JUMPSPEEDCAP_MAX)
1836         {
1837                 self.stat_jumpspeedcap_min = PHYS_JUMPSPEEDCAP_MAX;
1838                 stuffcmd(self, strcat("cl_jumpspeedcap_max ", PHYS_JUMPSPEEDCAP_MAX, "\n"));
1839         }
1840 #endif
1841
1842         if(PHYS_DEAD(self))
1843         {
1844                 // handle water here
1845                 vector midpoint = ((self.absmin + self.absmax) * 0.5);
1846                 if(pointcontents(midpoint) == CONTENT_WATER)
1847                 {
1848                         self.velocity = self.velocity * 0.5;
1849
1850                         // do we want this?
1851                         //if(pointcontents(midpoint + '0 0 2') == CONTENT_WATER)
1852                                 //{ self.velocity_z = 70; }
1853                 }
1854                 goto end;
1855         }
1856
1857 #ifdef SVQC
1858         if (!self.fixangle && !g_bugrigs)
1859                 self.angles = '0 1 0' * self.v_angle.y;
1860 #endif
1861
1862         PM_check_hitground();
1863
1864         if(IsFlying(self))
1865                 self.wasFlying = 1;
1866
1867         if (IS_PLAYER(self))
1868                 CheckPlayerJump();
1869
1870         if (self.flags & FL_WATERJUMP)
1871         {
1872                 self.velocity_x = self.movedir_x;
1873                 self.velocity_y = self.movedir_y;
1874                 if (time > self.teleport_time || self.waterlevel == WATERLEVEL_NONE)
1875                 {
1876                         self.flags &= ~FL_WATERJUMP;
1877                         self.teleport_time = 0;
1878                 }
1879         }
1880
1881 #ifdef SVQC
1882         else if (g_bugrigs && IS_PLAYER(self))
1883                 RaceCarPhysics();
1884 #endif
1885
1886         else if (self.movetype == MOVETYPE_NOCLIP || self.movetype == MOVETYPE_FLY || self.movetype == MOVETYPE_FLY_WORLDONLY || (BUFFS_STAT(self) & BUFF_FLIGHT.m_itemid))
1887                 PM_fly(maxspeed_mod);
1888
1889         else if (self.waterlevel >= WATERLEVEL_SWIMMING)
1890                 PM_swim(maxspeed_mod);
1891
1892         else if (time < self.ladder_time)
1893                 PM_ladder(maxspeed_mod);
1894
1895         else if (ITEMS_STAT(self) & IT_USING_JETPACK)
1896                 PM_jetpack(maxspeed_mod);
1897
1898         else if (IS_ONGROUND(self))
1899                 PM_walk(buttons_prev, maxspeed_mod);
1900
1901         else
1902                 PM_air(buttons_prev, maxspeed_mod);
1903
1904 #ifdef SVQC
1905         if (!IS_OBSERVER(self))
1906                 PM_check_race();
1907 #endif
1908         PM_check_vortex();
1909
1910 :end
1911         if (IS_ONGROUND(self))
1912                 self.lastground = time;
1913
1914         // conveyors: then break velocity again
1915         if(self.conveyor.state)
1916                 self.velocity += self.conveyor.movedir;
1917
1918         self.lastflags = self.flags;
1919
1920         self.lastclassname = self.classname;
1921
1922 #ifdef CSQC
1923         self.v_angle = oldv_angle;
1924         self.angles = oldangles;
1925 #endif
1926 }
1927
1928 #ifdef SVQC
1929 void SV_PlayerPhysics(void)
1930 #elif defined(CSQC)
1931 void CSQC_ClientMovement_PlayerMove_Frame(void)
1932 #endif
1933 {SELFPARAM();
1934         PM_Main();
1935
1936 #ifdef CSQC
1937         self.pmove_flags =
1938                         ((self.flags & FL_DUCKED) ? PMF_DUCKED : 0) |
1939                         (!(self.flags & FL_JUMPRELEASED) ? 0 : PMF_JUMP_HELD) |
1940                         ((self.flags & FL_ONGROUND) ? PMF_ONGROUND : 0);
1941 #endif
1942 }