data/qcsrc/server/gamec/cl_physics.c

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