data/qcsrc/server/cl_physics.qc

   1 float sv_accelerate;
   2 float sv_friction;
   3 float sv_maxspeed;
   4 float sv_airaccelerate;
   5 float sv_maxairspeed;
   6 float sv_stopspeed;
   7 float sv_gravity;
   8 float sv_airaccel_sideways_friction;
   9 float sv_airaccel_qw;
  10 .float ladder_time;
  11 .entity ladder_entity;
  12 .float gravity;
  13 .float swamp_slowdown;
  14 .float lastflags;
  15 .float lastground;
  16
  17 void Nixnex_GiveCurrentWeapon();
  18 void SV_PlayerPhysics()
  19 {
  20         local vector wishvel, wishdir, v;
  21         local float wishspeed, f, maxspd_mod, spd, maxairspd, airaccel, swampspd_mod;
  22         string temps;
  23
  24         if (clienttype(self) == CLIENTTYPE_BOT)
  25                 bot_think();
  26
  27         // doing this HERE because this is called for every client input frame, and
  28         // client input frames update this
  29         if(self.cursor_trace_ent)
  30                 if(self.cursor_trace_ent.classname == "player")
  31                         self.last_trace_player = self.cursor_trace_ent;
  32
  33         if (self.movetype == MOVETYPE_NONE)
  34                 return;
  35
  36         if (self.punchangle != '0 0 0')
  37         {
  38                 f = vlen(self.punchangle) - 10 * frametime;
  39                 if (f > 0)
  40                         self.punchangle = normalize(self.punchangle) * f;
  41                 else
  42                         self.punchangle = '0 0 0';
  43         }
  44
  45         if (self.punchvector != '0 0 0')
  46         {
  47                 f = vlen(self.punchvector) - 30 * frametime;
  48                 if (f > 0)
  49                         self.punchvector = normalize(self.punchvector) * f;
  50                 else
  51                         self.punchvector = '0 0 0';
  52         }
  53
  54         maxspd_mod = 1;
  55
  56         if(cvar("g_runematch"))
  57         {
  58                 if(self.runes & RUNE_SPEED)
  59                 {
  60                         if(self.runes & CURSE_SLOW)
  61                                 maxspd_mod = maxspd_mod * cvar("g_balance_rune_speed_combo_moverate");
  62                         else
  63                                 maxspd_mod = maxspd_mod * cvar("g_balance_rune_speed_moverate");
  64                 }
  65                 else if(self.runes & CURSE_SLOW)
  66                 {
  67                         maxspd_mod = maxspd_mod * cvar("g_balance_curse_slow_moverate");
  68                 }
  69         }
  70
  71         if(cvar("g_minstagib") && (self.items & IT_INVINCIBLE))
  72         {
  73                 maxspd_mod = cvar("g_balance_rune_speed_moverate");
  74         }
  75
  76         swampspd_mod = 1;
  77         if(self.in_swamp) {
  78                 swampspd_mod = self.swamp_slowdown; //cvar("g_balance_swamp_moverate");
  79         }
  80
  81         if(self.flags & FL_NOTARGET)
  82                 maxspd_mod = cvar("sv_spectator_speed_multiplier");
  83
  84         spd = sv_maxspeed * maxspd_mod * swampspd_mod;
  85
  86         if(self.speed != spd)
  87         {
  88                 self.speed = spd;
  89                 temps = ftos(spd);
  90                 stuffcmd(self, strcat("cl_forwardspeed ", temps, "\n"));
  91                 stuffcmd(self, strcat("cl_backspeed ", temps, "\n"));
  92                 stuffcmd(self, strcat("cl_sidespeed ", temps, "\n"));
  93                 stuffcmd(self, strcat("cl_upspeed ", temps, "\n"));
  94
  95                 temps = ftos(sv_accelerate * maxspd_mod);
  96                 stuffcmd(self, strcat("cl_movement_accelerate ", temps, "\n"));
  97         }
  98
  99         // if dead, behave differently
 100         if (self.deadflag)
 101                 return;
 102
 103         if (!self.fixangle)
 104         {
 105                 self.angles_x = 0;
 106                 self.angles_y = self.v_angle_y;
 107                 self.angles_z = 0;
 108         }
 109
 110         if (self.flags & FL_WATERJUMP )
 111         {
 112                 self.velocity_x = self.movedir_x;
 113                 self.velocity_y = self.movedir_y;
 114                 if (time > self.teleport_time || self.waterlevel == 0)
 115                 {
 116                         self.flags = self.flags - (self.flags & FL_WATERJUMP);
 117                         self.teleport_time = 0;
 118                 }
 119         }
 120         else if (self.movetype == MOVETYPE_NOCLIP || self.movetype == MOVETYPE_FLY)
 121         {
 122                 // noclipping or flying
 123                 self.flags = self.flags - (self.flags & FL_ONGROUND);
 124
 125                 self.velocity = self.velocity * (1 - frametime * sv_friction);
 126                 makevectors(self.v_angle);
 127                 //wishvel = v_forward * self.movement_x + v_right * self.movement_y + v_up * self.movement_z;
 128                 wishvel = v_forward * self.movement_x + v_right * self.movement_y + '0 0 1' * self.movement_z;
 129                 // acceleration
 130                 wishdir = normalize(wishvel);
 131                 wishspeed = vlen(wishvel);
 132                 if (wishspeed > sv_maxspeed*maxspd_mod)
 133                         wishspeed = sv_maxspeed*maxspd_mod;
 134                 if (time >= self.teleport_time)
 135                 {
 136                         f = wishspeed - (self.velocity * wishdir);
 137                         if (f > 0)
 138                                 self.velocity = self.velocity + wishdir * min(f, sv_accelerate*maxspd_mod * frametime * wishspeed);
 139                 }
 140         }
 141         else if (self.waterlevel >= 2)
 142         {
 143                 // swimming
 144                 self.flags = self.flags - (self.flags & FL_ONGROUND);
 145
 146                 makevectors(self.v_angle);
 147                 //wishvel = v_forward * self.movement_x + v_right * self.movement_y + v_up * self.movement_z;
 148                 wishvel = v_forward * self.movement_x + v_right * self.movement_y + '0 0 1' * self.movement_z;
 149                 if (wishvel == '0 0 0')
 150                         wishvel = '0 0 -60'; // drift towards bottom
 151
 152                 wishdir = normalize(wishvel);
 153                 wishspeed = vlen(wishvel);
 154                 if (wishspeed > sv_maxspeed*maxspd_mod)
 155                         wishspeed = sv_maxspeed*maxspd_mod;
 156                 wishspeed = wishspeed * 0.7;
 157
 158                 // water friction
 159                 self.velocity = self.velocity * (1 - frametime * sv_friction);
 160
 161                 // water acceleration
 162                 f = wishspeed - (self.velocity * wishdir);
 163                 if (f > 0)
 164                         self.velocity = self.velocity + wishdir * min(f, sv_accelerate*maxspd_mod * frametime * wishspeed);
 165         }
 166         else if (time < self.ladder_time)
 167         {
 168                 // on a func_ladder or swimming in func_water
 169                 self.flags = self.flags - (self.flags & FL_ONGROUND);
 170
 171                 self.velocity = self.velocity * (1 - frametime * sv_friction);
 172                 makevectors(self.v_angle);
 173                 //wishvel = v_forward * self.movement_x + v_right * self.movement_y + v_up * self.movement_z;
 174                 wishvel = v_forward * self.movement_x + v_right * self.movement_y + '0 0 1' * self.movement_z;
 175                 if (self.gravity)
 176                         self.velocity_z = self.velocity_z + self.gravity * sv_gravity * frametime;
 177                 else
 178                         self.velocity_z = self.velocity_z + sv_gravity * frametime;
 179                 if (self.ladder_entity.classname == "func_water")
 180                 {
 181                         f = vlen(wishvel);
 182                         if (f > self.ladder_entity.speed)
 183                                 wishvel = wishvel * (self.ladder_entity.speed / f);
 184
 185                         self.watertype = self.ladder_entity.skin;
 186                         f = self.ladder_entity.origin_z + self.ladder_entity.maxs_z;
 187                         if ((self.origin_z + self.view_ofs_z) < f)
 188                                 self.waterlevel = 3;
 189                         else if ((self.origin_z + (self.mins_z + self.maxs_z) * 0.5) < f)
 190                                 self.waterlevel = 2;
 191                         else if ((self.origin_z + self.mins_z + 1) < f)
 192                                 self.waterlevel = 1;
 193                         else
 194                         {
 195                                 self.waterlevel = 0;
 196                                 self.watertype = CONTENT_EMPTY;
 197                         }
 198                 }
 199                 // acceleration
 200                 wishdir = normalize(wishvel);
 201                 wishspeed = vlen(wishvel);
 202                 if (wishspeed > sv_maxspeed)
 203                         wishspeed = sv_maxspeed;
 204                 if (time >= self.teleport_time)
 205                 {
 206                         f = wishspeed - (self.velocity * wishdir);
 207                         if (f > 0)
 208                                 self.velocity = self.velocity + wishdir * min(f, sv_accelerate*maxspd_mod * frametime * wishspeed);
 209                 }
 210         }
 211         else if (self.flags & FL_ONGROUND)
 212         {
 213                 // walking
 214                 makevectors(self.v_angle_y * '0 1 0');
 215                 wishvel = v_forward * self.movement_x + v_right * self.movement_y;
 216
 217                 if(!(self.lastflags & FL_ONGROUND))
 218                 {
 219                         if(cvar("speedmeter"))
 220                                 dprint(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n"));
 221                         if(self.lastground < time - 0.3)
 222                                 self.velocity = self.velocity * (1 - cvar("sv_friction_on_land"));
 223                         if(self.jumppadcount > 1)
 224                                 dprint(strcat(ftos(self.jumppadcount), "x jumppad combo\n"));
 225                         self.jumppadcount = 0;
 226                 }
 227
 228                 if (self.velocity_x || self.velocity_y)
 229                 if (!(self.flags & FL_JUMPRELEASED) || !self.button2)
 230                 {
 231                         v = self.velocity;
 232                         v_z = 0;
 233                         f = vlen(v);
 234                         if (f < sv_stopspeed)
 235                                 f = 1 - frametime * (sv_stopspeed / f) * sv_friction;
 236                         else
 237                                 f = 1 - frametime * sv_friction;
 238                         if (f > 0)
 239                                 self.velocity = self.velocity * f;
 240                         else
 241                                 self.velocity = '0 0 0';
 242                 }
 243                 // acceleration
 244                 wishdir = normalize(wishvel);
 245                 wishspeed = vlen(wishvel);
 246                 if (wishspeed > sv_maxspeed*maxspd_mod)
 247                         wishspeed = sv_maxspeed*maxspd_mod;
 248                 if (self.crouch)
 249                         wishspeed = wishspeed * 0.5;
 250                 if (time >= self.teleport_time)
 251                 {
 252                         f = wishspeed - (self.velocity * wishdir);
 253                         if (f > 0)
 254                                 self.velocity = self.velocity + wishdir * min(f, sv_accelerate*maxspd_mod * frametime * wishspeed);
 255                 }
 256         }
 257         else
 258         {
 259                 if(maxspd_mod < 1)
 260                 {
 261                         maxairspd = sv_maxairspeed*maxspd_mod;
 262                         airaccel = sv_airaccelerate*maxspd_mod;
 263                 }
 264                 else
 265                 {
 266                         maxairspd = sv_maxairspeed;
 267                         airaccel = sv_airaccelerate;
 268                 }
 269                 // airborn
 270                 makevectors(self.v_angle_y * '0 1 0');
 271                 wishvel = v_forward * self.movement_x + v_right * self.movement_y;
 272                 // acceleration
 273                 wishdir = normalize(wishvel);
 274                 wishspeed = vlen(wishvel);
 275                 if (wishspeed > maxairspd)
 276                         wishspeed = maxairspd;
 277                 if (self.crouch)
 278                         wishspeed = wishspeed * 0.5;
 279                 if (time >= self.teleport_time)
 280                 {
 281                         // NOTE: this does the same as the commented out old code if:
 282                         //   sv_airaccel_qw 0
 283                         //   sv_airaccel_sideways_friction 0
 284
 285                         float vel_straight;
 286                         float vel_z;
 287                         vector vel_perpend;
 288                         vel_straight = self.velocity * wishdir;
 289                         vel_z = self.velocity_z;
 290                         vel_perpend = self.velocity - vel_straight * wishdir - vel_z * '0 0 1';
 291
 292                         f = wishspeed - vel_straight;
 293                         if(f > 0)
 294                                 vel_straight = vel_straight + min(f, airaccel * frametime * wishspeed) * sv_airaccel_qw;
 295                         if(wishspeed > 0)
 296                                 vel_straight = vel_straight + min(wishspeed, airaccel * frametime * wishspeed) * (1 - sv_airaccel_qw);
 297
 298                         // anti-sideways friction to fix QW-style bunnyhopping
 299                         vel_perpend = vel_perpend * (1 - frametime * (wishspeed / maxairspd) * sv_airaccel_sideways_friction);
 300
 301                         self.velocity = vel_straight * wishdir + vel_z * '0 0 1' + vel_perpend;
 302
 303                         /*
 304                         f = wishspeed;// - (self.velocity * wishdir);
 305                         if (f > 0)
 306                                 self.velocity = self.velocity + wishdir * min(f, airaccel * frametime * wishspeed);
 307                         */
 308                 }
 309         }
 310
 311         if(self.flags & FL_ONGROUND)
 312                 self.lastground = time;
 313
 314         self.lastflags = self.flags;
 315 };