]> git.rm.cloudns.org Git - xonotic/xonotic-data.pk3dir.git/commitdiff
Decouple bugrigs from the main code base
authorMario <mario@smbclan.net>
Mon, 23 Nov 2015 13:58:59 +0000 (23:58 +1000)
committerMario <mario@smbclan.net>
Mon, 23 Nov 2015 13:58:59 +0000 (23:58 +1000)
qcsrc/common/mutators/all.inc
qcsrc/common/mutators/events.qh
qcsrc/common/mutators/mutator/bugrigs/bugrigs.qc [new file with mode: 0644]
qcsrc/common/mutators/mutator/bugrigs/module.inc [new file with mode: 0644]
qcsrc/common/physics.qc
qcsrc/common/physics.qh
qcsrc/server/autocvars.qh
qcsrc/server/cl_client.qc
qcsrc/server/miscfunctions.qh

index bef00c649e890c2b71cb34a392ae4c9d77542b1a..b7d5b4495c679cff03e9dd3a56babd38dee3ce89 100644 (file)
@@ -10,6 +10,7 @@
 #include "mutator/bloodloss/module.inc"
 #include "mutator/breakablehook/module.inc"
 #include "mutator/buffs/module.inc"
+#include "mutator/bugrigs/module.inc"
 #include "mutator/campcheck/module.inc"
 #include "mutator/cloaked/module.inc"
 #include "mutator/damagetext/module.inc"
index 05f567d761c136079415f1decdaf2f0cf87e6557..49a2a0761162ce2be18605ac72bdb86eb057b6f8 100644 (file)
@@ -78,4 +78,11 @@ float player_multijump;
 float player_jumpheight;
 MUTATOR_HOOKABLE(PlayerJump, EV_PlayerJump);
 
+/** called during player physics, allows adjusting the movement type used */
+#define EV_PM_Physics(i, o) \
+    /**/ i(float, pm_maxspeed_mod) \
+    /**/
+float pm_maxspeed_mod;
+MUTATOR_HOOKABLE(PM_Physics, EV_PM_Physics);
+
 #endif
diff --git a/qcsrc/common/mutators/mutator/bugrigs/bugrigs.qc b/qcsrc/common/mutators/mutator/bugrigs/bugrigs.qc
new file mode 100644 (file)
index 0000000..c310170
--- /dev/null
@@ -0,0 +1,406 @@
+#ifdef IMPLEMENTATION
+#ifdef SVQC
+       #include "../../../../server/antilag.qh"
+#endif
+#include "../../../physics.qh"
+
+
+#if defined(SVQC)
+void bugrigs_SetVars();
+void bugrigs_AddStats();
+
+REGISTER_MUTATOR(bugrigs, cvar("g_bugrigs"))
+{
+       MUTATOR_ONADD
+       {
+               bugrigs_SetVars();
+               bugrigs_AddStats();
+       }
+       return false;
+}
+#elif defined(CSQC)
+REGISTER_MUTATOR(bugrigs, true);
+#endif
+
+
+#ifdef CSQC
+
+#define PHYS_BUGRIGS                                           getstati(STAT_BUGRIGS)
+#define PHYS_BUGRIGS_ANGLE_SMOOTHING           getstati(STAT_BUGRIGS_ANGLE_SMOOTHING)
+#define PHYS_BUGRIGS_PLANAR_MOVEMENT           getstati(STAT_BUGRIGS_PLANAR_MOVEMENT)
+#define PHYS_BUGRIGS_REVERSE_SPEEDING          getstati(STAT_BUGRIGS_REVERSE_SPEEDING)
+#define PHYS_BUGRIGS_FRICTION_FLOOR            getstatf(STAT_BUGRIGS_FRICTION_FLOOR)
+#define PHYS_BUGRIGS_AIR_STEERING                      getstati(STAT_BUGRIGS_AIR_STEERING)
+#define PHYS_BUGRIGS_FRICTION_BRAKE            getstatf(STAT_BUGRIGS_FRICTION_BRAKE)
+#define PHYS_BUGRIGS_ACCEL                                     getstatf(STAT_BUGRIGS_ACCEL)
+#define PHYS_BUGRIGS_SPEED_REF                                 getstatf(STAT_BUGRIGS_SPEED_REF)
+#define PHYS_BUGRIGS_SPEED_POW                                 getstatf(STAT_BUGRIGS_SPEED_POW)
+#define PHYS_BUGRIGS_STEER                                     getstatf(STAT_BUGRIGS_STEER)
+#define PHYS_BUGRIGS_FRICTION_AIR                      getstatf(STAT_BUGRIGS_FRICTION_AIR)
+#define PHYS_BUGRIGS_CAR_JUMPING                       getstatf(STAT_BUGRIGS_CAR_JUMPING)
+#define PHYS_BUGRIGS_REVERSE_SPINNING          getstatf(STAT_BUGRIGS_REVERSE_SPINNING)
+#define PHYS_BUGRIGS_REVERSE_STOPPING          getstatf(STAT_BUGRIGS_REVERSE_STOPPING)
+
+#elif defined(SVQC)
+
+bool g_bugrigs;
+bool g_bugrigs_planar_movement;
+bool g_bugrigs_planar_movement_car_jumping;
+float g_bugrigs_reverse_spinning;
+float g_bugrigs_reverse_speeding;
+float g_bugrigs_reverse_stopping;
+float g_bugrigs_air_steering;
+float g_bugrigs_angle_smoothing;
+float g_bugrigs_friction_floor;
+float g_bugrigs_friction_brake;
+float g_bugrigs_friction_air;
+float g_bugrigs_accel;
+float g_bugrigs_speed_ref;
+float g_bugrigs_speed_pow;
+float g_bugrigs_steer;
+
+#define PHYS_BUGRIGS                                           g_bugrigs
+#define PHYS_BUGRIGS_ANGLE_SMOOTHING           g_bugrigs_angle_smoothing
+#define PHYS_BUGRIGS_PLANAR_MOVEMENT           g_bugrigs_planar_movement
+#define PHYS_BUGRIGS_REVERSE_SPEEDING          g_bugrigs_reverse_speeding
+#define PHYS_BUGRIGS_FRICTION_FLOOR                    g_bugrigs_friction_floor
+#define PHYS_BUGRIGS_AIR_STEERING                      g_bugrigs_air_steering
+#define PHYS_BUGRIGS_FRICTION_BRAKE                    g_bugrigs_friction_brake
+#define PHYS_BUGRIGS_ACCEL                                     g_bugrigs_accel
+#define PHYS_BUGRIGS_SPEED_REF                         g_bugrigs_speed_ref
+#define PHYS_BUGRIGS_SPEED_POW                         g_bugrigs_speed_pow
+#define PHYS_BUGRIGS_STEER                                     g_bugrigs_steer
+#define PHYS_BUGRIGS_FRICTION_AIR                      g_bugrigs_friction_air
+#define PHYS_BUGRIGS_CAR_JUMPING                       g_bugrigs_planar_movement_car_jumping
+#define PHYS_BUGRIGS_REVERSE_SPINNING          g_bugrigs_reverse_spinning
+#define PHYS_BUGRIGS_REVERSE_STOPPING          g_bugrigs_reverse_stopping
+
+.float stat_bugrigs;
+.float stat_bugrigs_angle_smoothing;
+.float stat_bugrigs_planar_movement;
+.float stat_bugrigs_reverse_speeding;
+.float stat_bugrigs_friction_floor;
+.float stat_bugrigs_air_steering;
+.float stat_bugrigs_friction_brake;
+.float stat_bugrigs_accel;
+.float stat_bugrigs_speed_ref;
+.float stat_bugrigs_speed_pow;
+.float stat_bugrigs_steer;
+.float stat_bugrigs_friction_air;
+.float stat_bugrigs_car_jumping;
+.float stat_bugrigs_reverse_spinning;
+.float stat_bugrigs_reverse_stopping;
+
+void bugrigs_SetVars()
+{
+       g_bugrigs = cvar("g_bugrigs");
+       g_bugrigs_planar_movement = cvar("g_bugrigs_planar_movement");
+       g_bugrigs_planar_movement_car_jumping = cvar("g_bugrigs_planar_movement_car_jumping");
+       g_bugrigs_reverse_spinning = cvar("g_bugrigs_reverse_spinning");
+       g_bugrigs_reverse_speeding = cvar("g_bugrigs_reverse_speeding");
+       g_bugrigs_reverse_stopping = cvar("g_bugrigs_reverse_stopping");
+       g_bugrigs_air_steering = cvar("g_bugrigs_air_steering");
+       g_bugrigs_angle_smoothing = cvar("g_bugrigs_angle_smoothing");
+       g_bugrigs_friction_floor = cvar("g_bugrigs_friction_floor");
+       g_bugrigs_friction_brake = cvar("g_bugrigs_friction_brake");
+       g_bugrigs_friction_air = cvar("g_bugrigs_friction_air");
+       g_bugrigs_accel = cvar("g_bugrigs_accel");
+       g_bugrigs_speed_ref = cvar("g_bugrigs_speed_ref");
+       g_bugrigs_speed_pow = cvar("g_bugrigs_speed_pow");
+       g_bugrigs_steer = cvar("g_bugrigs_steer");
+}
+
+void bugrigs_UpdateStats(entity this)
+{
+       this.stat_bugrigs = PHYS_BUGRIGS;
+       this.stat_bugrigs_angle_smoothing = PHYS_BUGRIGS_ANGLE_SMOOTHING;
+       this.stat_bugrigs_planar_movement = PHYS_BUGRIGS_PLANAR_MOVEMENT;
+       this.stat_bugrigs_reverse_speeding = PHYS_BUGRIGS_REVERSE_SPEEDING;
+       this.stat_bugrigs_friction_floor = PHYS_BUGRIGS_FRICTION_FLOOR;
+       this.stat_bugrigs_air_steering = PHYS_BUGRIGS_AIR_STEERING;
+       this.stat_bugrigs_friction_brake = PHYS_BUGRIGS_FRICTION_BRAKE;
+       this.stat_bugrigs_accel = PHYS_BUGRIGS_ACCEL;
+       this.stat_bugrigs_speed_ref = PHYS_BUGRIGS_SPEED_REF;
+       this.stat_bugrigs_speed_pow = PHYS_BUGRIGS_SPEED_POW;
+       this.stat_bugrigs_steer = PHYS_BUGRIGS_STEER;
+       this.stat_bugrigs_friction_air = PHYS_BUGRIGS_FRICTION_AIR;
+       this.stat_bugrigs_car_jumping = PHYS_BUGRIGS_CAR_JUMPING;
+       this.stat_bugrigs_reverse_spinning = PHYS_BUGRIGS_REVERSE_SPINNING;
+       this.stat_bugrigs_reverse_stopping = PHYS_BUGRIGS_REVERSE_STOPPING;
+}
+
+void bugrigs_AddStats()
+{
+       addstat(STAT_BUGRIGS, AS_INT, stat_bugrigs);
+       addstat(STAT_BUGRIGS_ANGLE_SMOOTHING, AS_INT, stat_bugrigs_angle_smoothing);
+       addstat(STAT_BUGRIGS_PLANAR_MOVEMENT, AS_INT, stat_bugrigs_planar_movement);
+       addstat(STAT_BUGRIGS_REVERSE_SPEEDING, AS_INT, stat_bugrigs_reverse_speeding);
+       addstat(STAT_BUGRIGS_FRICTION_FLOOR, AS_FLOAT, stat_bugrigs_friction_floor);
+       addstat(STAT_BUGRIGS_AIR_STEERING, AS_INT, stat_bugrigs_air_steering);
+       addstat(STAT_BUGRIGS_FRICTION_BRAKE, AS_FLOAT, stat_bugrigs_friction_brake);
+       addstat(STAT_BUGRIGS_ACCEL, AS_FLOAT, stat_bugrigs_accel);
+       addstat(STAT_BUGRIGS_SPEED_REF, AS_FLOAT, stat_bugrigs_speed_ref);
+       addstat(STAT_BUGRIGS_SPEED_POW, AS_FLOAT, stat_bugrigs_speed_pow);
+       addstat(STAT_BUGRIGS_STEER, AS_FLOAT, stat_bugrigs_steer);
+       addstat(STAT_BUGRIGS_FRICTION_AIR, AS_FLOAT, stat_bugrigs_friction_air);
+       addstat(STAT_BUGRIGS_CAR_JUMPING, AS_FLOAT, stat_bugrigs_car_jumping);
+       addstat(STAT_BUGRIGS_REVERSE_SPINNING, AS_FLOAT, stat_bugrigs_reverse_spinning);
+       addstat(STAT_BUGRIGS_REVERSE_STOPPING, AS_FLOAT, stat_bugrigs_reverse_stopping);
+}
+
+#endif
+
+void RaceCarPhysics(entity this)
+{
+       // using this move type for "big rigs"
+       // the engine does not push the entity!
+
+       vector rigvel;
+
+       vector angles_save = this.angles;
+       float accel = bound(-1, this.movement.x / PHYS_MAXSPEED(this), 1);
+       float steer = bound(-1, this.movement.y / PHYS_MAXSPEED(this), 1);
+
+       if (PHYS_BUGRIGS_REVERSE_SPEEDING)
+       {
+               if (accel < 0)
+               {
+                       // back accel is DIGITAL
+                       // to prevent speedhack
+                       if (accel < -0.5)
+                               accel = -1;
+                       else
+                               accel = 0;
+               }
+       }
+
+       this.angles_x = 0;
+       this.angles_z = 0;
+       makevectors(this.angles); // new forward direction!
+
+       if (IS_ONGROUND(this) || PHYS_BUGRIGS_AIR_STEERING)
+       {
+               float myspeed = this.velocity * v_forward;
+               float upspeed = this.velocity * v_up;
+
+               // responsiveness factor for steering and acceleration
+               float f = 1 / (1 + pow(max(-myspeed, myspeed) / PHYS_BUGRIGS_SPEED_REF, PHYS_BUGRIGS_SPEED_POW));
+               //MAXIMA: f(v) := 1 / (1 + (v / PHYS_BUGRIGS_SPEED_REF) ^ PHYS_BUGRIGS_SPEED_POW);
+
+               float steerfactor;
+               if (myspeed < 0 && PHYS_BUGRIGS_REVERSE_SPINNING)
+                       steerfactor = -myspeed * PHYS_BUGRIGS_STEER;
+               else
+                       steerfactor = -myspeed * f * PHYS_BUGRIGS_STEER;
+
+               float accelfactor;
+               if (myspeed < 0 && PHYS_BUGRIGS_REVERSE_SPEEDING)
+                       accelfactor = PHYS_BUGRIGS_ACCEL;
+               else
+                       accelfactor = f * PHYS_BUGRIGS_ACCEL;
+               //MAXIMA: accel(v) := f(v) * PHYS_BUGRIGS_ACCEL;
+
+               if (accel < 0)
+               {
+                       if (myspeed > 0)
+                       {
+                               myspeed = max(0, myspeed - PHYS_INPUT_TIMELENGTH * (PHYS_BUGRIGS_FRICTION_FLOOR - PHYS_BUGRIGS_FRICTION_BRAKE * accel));
+                       }
+                       else
+                       {
+                               if (!PHYS_BUGRIGS_REVERSE_SPEEDING)
+                                       myspeed = min(0, myspeed + PHYS_INPUT_TIMELENGTH * PHYS_BUGRIGS_FRICTION_FLOOR);
+                       }
+               }
+               else
+               {
+                       if (myspeed >= 0)
+                       {
+                               myspeed = max(0, myspeed - PHYS_INPUT_TIMELENGTH * PHYS_BUGRIGS_FRICTION_FLOOR);
+                       }
+                       else
+                       {
+                               if (PHYS_BUGRIGS_REVERSE_STOPPING)
+                                       myspeed = 0;
+                               else
+                                       myspeed = min(0, myspeed + PHYS_INPUT_TIMELENGTH * (PHYS_BUGRIGS_FRICTION_FLOOR + PHYS_BUGRIGS_FRICTION_BRAKE * accel));
+                       }
+               }
+               // terminal velocity = velocity at which 50 == accelfactor, that is, 1549 units/sec
+               //MAXIMA: friction(v) := PHYS_BUGRIGS_FRICTION_FLOOR;
+
+               this.angles_y += steer * PHYS_INPUT_TIMELENGTH * steerfactor; // apply steering
+               makevectors(this.angles); // new forward direction!
+
+               myspeed += accel * accelfactor * PHYS_INPUT_TIMELENGTH;
+
+               rigvel = myspeed * v_forward + '0 0 1' * upspeed;
+       }
+       else
+       {
+               float myspeed = vlen(this.velocity);
+
+               // responsiveness factor for steering and acceleration
+               float f = 1 / (1 + pow(max(0, myspeed / PHYS_BUGRIGS_SPEED_REF), PHYS_BUGRIGS_SPEED_POW));
+               float steerfactor = -myspeed * f;
+               this.angles_y += steer * PHYS_INPUT_TIMELENGTH * steerfactor; // apply steering
+
+               rigvel = this.velocity;
+               makevectors(this.angles); // new forward direction!
+       }
+
+       rigvel *= max(0, 1 - vlen(rigvel) * PHYS_BUGRIGS_FRICTION_AIR * PHYS_INPUT_TIMELENGTH);
+       //MAXIMA: airfriction(v) := v * v * PHYS_BUGRIGS_FRICTION_AIR;
+       //MAXIMA: total_acceleration(v) := accel(v) - friction(v) - airfriction(v);
+       //MAXIMA: solve(total_acceleration(v) = 0, v);
+
+       if (PHYS_BUGRIGS_PLANAR_MOVEMENT)
+       {
+               vector rigvel_xy, neworigin, up;
+               float mt;
+
+               rigvel_z -= PHYS_INPUT_TIMELENGTH * PHYS_GRAVITY; // 4x gravity plays better
+               rigvel_xy = vec2(rigvel);
+
+               if (PHYS_BUGRIGS_CAR_JUMPING)
+                       mt = MOVE_NORMAL;
+               else
+                       mt = MOVE_NOMONSTERS;
+
+               tracebox(this.origin, this.mins, this.maxs, this.origin + '0 0 1024', mt, this);
+               up = trace_endpos - this.origin;
+
+               // BUG RIGS: align the move to the surface instead of doing collision testing
+               // can we move?
+               tracebox(trace_endpos, this.mins, this.maxs, trace_endpos + rigvel_xy * PHYS_INPUT_TIMELENGTH, mt, this);
+
+               // align to surface
+               tracebox(trace_endpos, this.mins, this.maxs, trace_endpos - up + '0 0 1' * rigvel_z * PHYS_INPUT_TIMELENGTH, mt, this);
+
+               if (trace_fraction < 0.5)
+               {
+                       trace_fraction = 1;
+                       neworigin = this.origin;
+               }
+               else
+                       neworigin = trace_endpos;
+
+               if (trace_fraction < 1)
+               {
+                       // now set angles_x so that the car points parallel to the surface
+                       this.angles = vectoangles(
+                                       '1 0 0' * v_forward_x * trace_plane_normal_z
+                                       +
+                                       '0 1 0' * v_forward_y * trace_plane_normal_z
+                                       +
+                                       '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y)
+                                       );
+                       SET_ONGROUND(this);
+               }
+               else
+               {
+                       // now set angles_x so that the car points forward, but is tilted in velocity direction
+                       UNSET_ONGROUND(this);
+               }
+
+               this.velocity = (neworigin - this.origin) * (1.0 / PHYS_INPUT_TIMELENGTH);
+               this.movetype = MOVETYPE_NOCLIP;
+       }
+       else
+       {
+               rigvel_z -= PHYS_INPUT_TIMELENGTH * PHYS_GRAVITY; // 4x gravity plays better
+               this.velocity = rigvel;
+               this.movetype = MOVETYPE_FLY;
+       }
+
+       trace_fraction = 1;
+       tracebox(this.origin, this.mins, this.maxs, this.origin - '0 0 4', MOVE_NORMAL, this);
+       if (trace_fraction != 1)
+       {
+               this.angles = vectoangles2(
+                               '1 0 0' * v_forward_x * trace_plane_normal_z
+                               +
+                               '0 1 0' * v_forward_y * trace_plane_normal_z
+                               +
+                               '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y),
+                               trace_plane_normal
+                               );
+       }
+       else
+       {
+               vector vel_local;
+
+               vel_local_x = v_forward * this.velocity;
+               vel_local_y = v_right * this.velocity;
+               vel_local_z = v_up * this.velocity;
+
+               this.angles_x = racecar_angle(vel_local_x, vel_local_z);
+               this.angles_z = racecar_angle(-vel_local_y, vel_local_z);
+       }
+
+       // smooth the angles
+       vector vf1, vu1, smoothangles;
+       makevectors(this.angles);
+       float f = bound(0, PHYS_INPUT_TIMELENGTH * PHYS_BUGRIGS_ANGLE_SMOOTHING, 1);
+       if (f == 0)
+               f = 1;
+       vf1 = v_forward * f;
+       vu1 = v_up * f;
+       makevectors(angles_save);
+       vf1 = vf1 + v_forward * (1 - f);
+       vu1 = vu1 + v_up * (1 - f);
+       smoothangles = vectoangles2(vf1, vu1);
+       this.angles_x = -smoothangles_x;
+       this.angles_z =  smoothangles_z;
+
+       PM_ClientMovement_Move();
+}
+
+#ifdef SVQC
+.vector bugrigs_prevangles;
+#endif
+MUTATOR_HOOKFUNCTION(bugrigs, PM_Physics)
+{
+       if(!PHYS_BUGRIGS || !IS_PLAYER(self)) { return false; }
+
+#ifdef SVQC
+       self.angles = self.bugrigs_prevangles;
+#endif
+
+       RaceCarPhysics(self);
+       return true;
+}
+
+MUTATOR_HOOKFUNCTION(bugrigs, PlayerPhysics)
+{
+       if(!PHYS_BUGRIGS) { return false; }
+#ifdef SVQC
+       self.bugrigs_prevangles = self.angles;
+
+       bugrigs_UpdateStats(self);
+#endif
+       return false;
+}
+
+#ifdef SVQC
+
+MUTATOR_HOOKFUNCTION(bugrigs, ClientConnect)
+{
+       stuffcmd(self, "cl_cmd settemp chase_active 1\n");
+       return false;
+}
+
+MUTATOR_HOOKFUNCTION(bugrigs, BuildMutatorsString)
+{
+       ret_string = strcat(ret_string, ":bugrigs");
+       return false;
+}
+
+MUTATOR_HOOKFUNCTION(bugrigs, BuildMutatorsPrettyString)
+{
+       ret_string = strcat(ret_string, ", Bug rigs");
+       return false;
+}
+
+#endif
+#endif
diff --git a/qcsrc/common/mutators/mutator/bugrigs/module.inc b/qcsrc/common/mutators/mutator/bugrigs/module.inc
new file mode 100644 (file)
index 0000000..cef744f
--- /dev/null
@@ -0,0 +1,3 @@
+#ifndef MENUQC
+#include "bugrigs.qc"
+#endif
index f42d06ed2f3230df4605d7625f23f97cdc4fc273..299a0570e273526e2de5792155f35b8788c9730f 100644 (file)
@@ -747,212 +747,6 @@ float racecar_angle(float forward, float down)
                return ret * angle_mult;
 }
 
-void RaceCarPhysics()
-{SELFPARAM();
-#ifdef SVQC
-       // using this move type for "big rigs"
-       // the engine does not push the entity!
-
-       vector rigvel;
-
-       vector angles_save = self.angles;
-       float accel = bound(-1, self.movement.x / PHYS_MAXSPEED(self), 1);
-       float steer = bound(-1, self.movement.y / PHYS_MAXSPEED(self), 1);
-
-       if (g_bugrigs_reverse_speeding)
-       {
-               if (accel < 0)
-               {
-                       // back accel is DIGITAL
-                       // to prevent speedhack
-                       if (accel < -0.5)
-                               accel = -1;
-                       else
-                               accel = 0;
-               }
-       }
-
-       self.angles_x = 0;
-       self.angles_z = 0;
-       makevectors(self.angles); // new forward direction!
-
-       if (IS_ONGROUND(self) || g_bugrigs_air_steering)
-       {
-               float myspeed = self.velocity * v_forward;
-               float upspeed = self.velocity * v_up;
-
-               // responsiveness factor for steering and acceleration
-               float f = 1 / (1 + pow(max(-myspeed, myspeed) / g_bugrigs_speed_ref, g_bugrigs_speed_pow));
-               //MAXIMA: f(v) := 1 / (1 + (v / g_bugrigs_speed_ref) ^ g_bugrigs_speed_pow);
-
-               float steerfactor;
-               if (myspeed < 0 && g_bugrigs_reverse_spinning)
-                       steerfactor = -myspeed * g_bugrigs_steer;
-               else
-                       steerfactor = -myspeed * f * g_bugrigs_steer;
-
-               float accelfactor;
-               if (myspeed < 0 && g_bugrigs_reverse_speeding)
-                       accelfactor = g_bugrigs_accel;
-               else
-                       accelfactor = f * g_bugrigs_accel;
-               //MAXIMA: accel(v) := f(v) * g_bugrigs_accel;
-
-               if (accel < 0)
-               {
-                       if (myspeed > 0)
-                       {
-                               myspeed = max(0, myspeed - PHYS_INPUT_TIMELENGTH * (g_bugrigs_friction_floor - g_bugrigs_friction_brake * accel));
-                       }
-                       else
-                       {
-                               if (!g_bugrigs_reverse_speeding)
-                                       myspeed = min(0, myspeed + PHYS_INPUT_TIMELENGTH * g_bugrigs_friction_floor);
-                       }
-               }
-               else
-               {
-                       if (myspeed >= 0)
-                       {
-                               myspeed = max(0, myspeed - PHYS_INPUT_TIMELENGTH * g_bugrigs_friction_floor);
-                       }
-                       else
-                       {
-                               if (g_bugrigs_reverse_stopping)
-                                       myspeed = 0;
-                               else
-                                       myspeed = min(0, myspeed + PHYS_INPUT_TIMELENGTH * (g_bugrigs_friction_floor + g_bugrigs_friction_brake * accel));
-                       }
-               }
-               // terminal velocity = velocity at which 50 == accelfactor, that is, 1549 units/sec
-               //MAXIMA: friction(v) := g_bugrigs_friction_floor;
-
-               self.angles_y += steer * PHYS_INPUT_TIMELENGTH * steerfactor; // apply steering
-               makevectors(self.angles); // new forward direction!
-
-               myspeed += accel * accelfactor * PHYS_INPUT_TIMELENGTH;
-
-               rigvel = myspeed * v_forward + '0 0 1' * upspeed;
-       }
-       else
-       {
-               float myspeed = vlen(self.velocity);
-
-               // responsiveness factor for steering and acceleration
-               float f = 1 / (1 + pow(max(0, myspeed / g_bugrigs_speed_ref), g_bugrigs_speed_pow));
-               float steerfactor = -myspeed * f;
-               self.angles_y += steer * PHYS_INPUT_TIMELENGTH * steerfactor; // apply steering
-
-               rigvel = self.velocity;
-               makevectors(self.angles); // new forward direction!
-       }
-
-       rigvel *= max(0, 1 - vlen(rigvel) * g_bugrigs_friction_air * PHYS_INPUT_TIMELENGTH);
-       //MAXIMA: airfriction(v) := v * v * g_bugrigs_friction_air;
-       //MAXIMA: total_acceleration(v) := accel(v) - friction(v) - airfriction(v);
-       //MAXIMA: solve(total_acceleration(v) = 0, v);
-
-       if (g_bugrigs_planar_movement)
-       {
-               vector rigvel_xy, neworigin, up;
-               float mt;
-
-               rigvel_z -= PHYS_INPUT_TIMELENGTH * PHYS_GRAVITY; // 4x gravity plays better
-               rigvel_xy = vec2(rigvel);
-
-               if (g_bugrigs_planar_movement_car_jumping)
-                       mt = MOVE_NORMAL;
-               else
-                       mt = MOVE_NOMONSTERS;
-
-               tracebox(self.origin, self.mins, self.maxs, self.origin + '0 0 1024', mt, self);
-               up = trace_endpos - self.origin;
-
-               // BUG RIGS: align the move to the surface instead of doing collision testing
-               // can we move?
-               tracebox(trace_endpos, self.mins, self.maxs, trace_endpos + rigvel_xy * PHYS_INPUT_TIMELENGTH, mt, self);
-
-               // align to surface
-               tracebox(trace_endpos, self.mins, self.maxs, trace_endpos - up + '0 0 1' * rigvel_z * PHYS_INPUT_TIMELENGTH, mt, self);
-
-               if (trace_fraction < 0.5)
-               {
-                       trace_fraction = 1;
-                       neworigin = self.origin;
-               }
-               else
-                       neworigin = trace_endpos;
-
-               if (trace_fraction < 1)
-               {
-                       // now set angles_x so that the car points parallel to the surface
-                       self.angles = vectoangles(
-                                       '1 0 0' * v_forward_x * trace_plane_normal_z
-                                       +
-                                       '0 1 0' * v_forward_y * trace_plane_normal_z
-                                       +
-                                       '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y)
-                                       );
-                       SET_ONGROUND(self);
-               }
-               else
-               {
-                       // now set angles_x so that the car points forward, but is tilted in velocity direction
-                       UNSET_ONGROUND(self);
-               }
-
-               self.velocity = (neworigin - self.origin) * (1.0 / PHYS_INPUT_TIMELENGTH);
-               self.movetype = MOVETYPE_NOCLIP;
-       }
-       else
-       {
-               rigvel_z -= PHYS_INPUT_TIMELENGTH * PHYS_GRAVITY; // 4x gravity plays better
-               self.velocity = rigvel;
-               self.movetype = MOVETYPE_FLY;
-       }
-
-       trace_fraction = 1;
-       tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 4', MOVE_NORMAL, self);
-       if (trace_fraction != 1)
-       {
-               self.angles = vectoangles2(
-                               '1 0 0' * v_forward_x * trace_plane_normal_z
-                               +
-                               '0 1 0' * v_forward_y * trace_plane_normal_z
-                               +
-                               '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y),
-                               trace_plane_normal
-                               );
-       }
-       else
-       {
-               vector vel_local;
-
-               vel_local_x = v_forward * self.velocity;
-               vel_local_y = v_right * self.velocity;
-               vel_local_z = v_up * self.velocity;
-
-               self.angles_x = racecar_angle(vel_local_x, vel_local_z);
-               self.angles_z = racecar_angle(-vel_local_y, vel_local_z);
-       }
-
-       // smooth the angles
-       vector vf1, vu1, smoothangles;
-       makevectors(self.angles);
-       float f = bound(0, PHYS_INPUT_TIMELENGTH * g_bugrigs_angle_smoothing, 1);
-       if (f == 0)
-               f = 1;
-       vf1 = v_forward * f;
-       vu1 = v_up * f;
-       makevectors(angles_save);
-       vf1 = vf1 + v_forward * (1 - f);
-       vu1 = vu1 + v_up * (1 - f);
-       smoothangles = vectoangles2(vf1, vu1);
-       self.angles_x = -smoothangles_x;
-       self.angles_z =  smoothangles_z;
-#endif
-}
-
 string specialcommand = "xwxwxsxsxaxdxaxdx1x ";
 .float specialcommand_pos;
 void SpecialCommand()
@@ -1750,7 +1544,7 @@ void PM_Main(entity this)
        }
 
 #ifdef SVQC
-       if (!this.fixangle && !g_bugrigs)
+       if (!this.fixangle)
                this.angles = '0 1 0' * this.v_angle.y;
 #endif
 
@@ -1773,10 +1567,8 @@ void PM_Main(entity this)
                }
        }
 
-#ifdef SVQC
-       else if (g_bugrigs && IS_PLAYER(this))
-               RaceCarPhysics();
-#endif
+       else if (MUTATOR_CALLHOOK(PM_Physics, maxspeed_mod))
+               { }
 
        else if (this.movetype == MOVETYPE_NOCLIP || this.movetype == MOVETYPE_FLY || this.movetype == MOVETYPE_FLY_WORLDONLY || MUTATOR_CALLHOOK(IsFlying, this))
                PM_fly(maxspeed_mod);
index 070f07ebc4d8cf5ed6f22bf8f217bb92248d4a11..7b46b0379384fde56bbcc357f1d29c3d49381a7b 100644 (file)
@@ -101,22 +101,6 @@ bool IsFlying(entity a);
 
        #define PHYS_DOUBLEJUMP                                         getstati(STAT_DOUBLEJUMP)
 
-       #define PHYS_BUGRIGS                                            getstati(STAT_BUGRIGS)
-       #define PHYS_BUGRIGS_ANGLE_SMOOTHING            getstati(STAT_BUGRIGS_ANGLE_SMOOTHING)
-       #define PHYS_BUGRIGS_PLANAR_MOVEMENT            getstati(STAT_BUGRIGS_PLANAR_MOVEMENT)
-       #define PHYS_BUGRIGS_REVERSE_SPEEDING           getstati(STAT_BUGRIGS_REVERSE_SPEEDING)
-       #define PHYS_BUGRIGS_FRICTION_FLOOR             getstatf(STAT_BUGRIGS_FRICTION_FLOOR)
-       #define PHYS_BUGRIGS_AIR_STEERING                       getstati(STAT_BUGRIGS_AIR_STEERING)
-       #define PHYS_BUGRIGS_FRICTION_BRAKE             getstatf(STAT_BUGRIGS_FRICTION_BRAKE)
-       #define PHYS_BUGRIGS_ACCEL                                      getstatf(STAT_BUGRIGS_ACCEL)
-       #define PHYS_BUGRIGS_SPEED_REF                          getstatf(STAT_BUGRIGS_SPEED_REF)
-       #define PHYS_BUGRIGS_SPEED_POW                          getstatf(STAT_BUGRIGS_SPEED_POW)
-       #define PHYS_BUGRIGS_STEER                                      getstatf(STAT_BUGRIGS_STEER)
-       #define PHYS_BUGRIGS_FRICTION_AIR                       getstatf(STAT_BUGRIGS_FRICTION_AIR)
-       #define PHYS_BUGRIGS_CAR_JUMPING                        getstatf(STAT_BUGRIGS_CAR_JUMPING)
-       #define PHYS_BUGRIGS_REVERSE_SPINNING           getstatf(STAT_BUGRIGS_REVERSE_SPINNING)
-       #define PHYS_BUGRIGS_REVERSE_STOPPING           getstatf(STAT_BUGRIGS_REVERSE_STOPPING)
-
        #define PHYS_JUMPSPEEDCAP_MIN                           cvar_string("cl_jumpspeedcap_min")
        #define PHYS_JUMPSPEEDCAP_MAX                           cvar_string("cl_jumpspeedcap_max")
        #define PHYS_JUMPSPEEDCAP_DISABLE_ONRAMPS       getstati(STAT_MOVEVARS_JUMPSPEEDCAP_DISABLE_ONRAMPS)
@@ -206,22 +190,6 @@ bool IsFlying(entity a);
        .float stat_gameplayfix_unstickplayers;
        .float stat_gameplayfix_stepdown;
 
-       .float stat_bugrigs;
-       .float stat_bugrigs_angle_smoothing;
-       .float stat_bugrigs_planar_movement;
-       .float stat_bugrigs_reverse_speeding;
-       .float stat_bugrigs_friction_floor;
-       .float stat_bugrigs_air_steering;
-       .float stat_bugrigs_friction_brake;
-       .float stat_bugrigs_accel;
-       .float stat_bugrigs_speed_ref;
-       .float stat_bugrigs_speed_pow;
-       .float stat_bugrigs_steer;
-       .float stat_bugrigs_friction_air;
-       .float stat_bugrigs_car_jumping;
-       .float stat_bugrigs_reverse_spinning;
-       .float stat_bugrigs_reverse_stopping;
-
        // new properties
        .float stat_sv_jumpvelocity;
        .float stat_sv_airaccel_qw_stretchfactor;
@@ -304,22 +272,6 @@ bool IsFlying(entity a);
 
        #define PHYS_DOUBLEJUMP                                         autocvar_sv_doublejump
 
-       #define PHYS_BUGRIGS                                            g_bugrigs
-       #define PHYS_BUGRIGS_ANGLE_SMOOTHING            g_bugrigs_angle_smoothing
-       #define PHYS_BUGRIGS_PLANAR_MOVEMENT            g_bugrigs_planar_movement
-       #define PHYS_BUGRIGS_REVERSE_SPEEDING           g_bugrigs_reverse_speeding
-       #define PHYS_BUGRIGS_FRICTION_FLOOR                     g_bugrigs_friction_floor
-       #define PHYS_BUGRIGS_AIR_STEERING                       g_bugrigs_air_steering
-       #define PHYS_BUGRIGS_FRICTION_BRAKE                     g_bugrigs_friction_brake
-       #define PHYS_BUGRIGS_ACCEL                                      g_bugrigs_accel
-       #define PHYS_BUGRIGS_SPEED_REF                          g_bugrigs_speed_ref
-       #define PHYS_BUGRIGS_SPEED_POW                          g_bugrigs_speed_pow
-       #define PHYS_BUGRIGS_STEER                                      g_bugrigs_steer
-       #define PHYS_BUGRIGS_FRICTION_AIR                       g_bugrigs_friction_air
-       #define PHYS_BUGRIGS_CAR_JUMPING                        g_bugrigs_planar_movement_car_jumping
-       #define PHYS_BUGRIGS_REVERSE_SPINNING           g_bugrigs_reverse_spinning
-       #define PHYS_BUGRIGS_REVERSE_STOPPING           g_bugrigs_reverse_stopping
-
        #define PHYS_JUMPSPEEDCAP_MIN                           autocvar_sv_jumpspeedcap_min
        #define PHYS_JUMPSPEEDCAP_MAX                           autocvar_sv_jumpspeedcap_max
        #define PHYS_JUMPSPEEDCAP_DISABLE_ONRAMPS       autocvar_sv_jumpspeedcap_max_disable_on_ramps
index c271b65b49523721b47972de15f7a6caf9e6b8de..fff61774b1eb4236f84e019ff3a7a2f452971371 100644 (file)
@@ -155,7 +155,6 @@ string autocvar_g_ban_sync_uri;
 string autocvar_g_banned_list;
 bool autocvar_g_banned_list_idmode;
 bool autocvar_g_botclip_collisions;
-bool autocvar_g_bugrigs;
 bool autocvar_g_campaign;
 #define autocvar_g_campaign_forceteam cvar("g_campaign_forceteam")
 int autocvar_g_campaign_skill;
index 47aff4a0b0c4dacad39a7263b960b63cc0984c06..6dc4ac881483fed9443e9f34853a82d8d63c759f 100644 (file)
@@ -1199,7 +1199,7 @@ void ClientConnect ()
                        Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_MOTD, getwelcomemessage());
                }
 
-               if(autocvar_g_bugrigs || (g_weaponarena_weapons == WEPSET(TUBA)))
+               if(g_weaponarena_weapons == WEPSET(TUBA))
                        stuffcmd(self, "cl_cmd settemp chase_active 1\n");
        }
 
index f7479af965ee8246f531d2c1885bcf3ae26c9d4d..0976e60e581c4751a8701bf293529ca57faad2ec 100644 (file)
@@ -240,22 +240,6 @@ float g_weapon_stay;
 float want_weapon(entity weaponinfo, float allguns); // WEAPONTODO: what still needs done?
 void readplayerstartcvars();
 
-float g_bugrigs;
-float g_bugrigs_planar_movement;
-float g_bugrigs_planar_movement_car_jumping;
-float g_bugrigs_reverse_spinning;
-float g_bugrigs_reverse_speeding;
-float g_bugrigs_reverse_stopping;
-float g_bugrigs_air_steering;
-float g_bugrigs_angle_smoothing;
-float g_bugrigs_friction_floor;
-float g_bugrigs_friction_brake;
-float g_bugrigs_friction_air;
-float g_bugrigs_accel;
-float g_bugrigs_speed_ref;
-float g_bugrigs_speed_pow;
-float g_bugrigs_steer;
-
 float sv_autotaunt;
 float sv_taunt;
 
@@ -265,22 +249,6 @@ void readlevelcvars()
        if(cvar("sv_allow_fullbright"))
                serverflags |= SERVERFLAG_ALLOW_FULLBRIGHT;
 
-    g_bugrigs = cvar("g_bugrigs");
-    g_bugrigs_planar_movement = cvar("g_bugrigs_planar_movement");
-    g_bugrigs_planar_movement_car_jumping = cvar("g_bugrigs_planar_movement_car_jumping");
-    g_bugrigs_reverse_spinning = cvar("g_bugrigs_reverse_spinning");
-    g_bugrigs_reverse_speeding = cvar("g_bugrigs_reverse_speeding");
-    g_bugrigs_reverse_stopping = cvar("g_bugrigs_reverse_stopping");
-    g_bugrigs_air_steering = cvar("g_bugrigs_air_steering");
-    g_bugrigs_angle_smoothing = cvar("g_bugrigs_angle_smoothing");
-    g_bugrigs_friction_floor = cvar("g_bugrigs_friction_floor");
-    g_bugrigs_friction_brake = cvar("g_bugrigs_friction_brake");
-    g_bugrigs_friction_air = cvar("g_bugrigs_friction_air");
-    g_bugrigs_accel = cvar("g_bugrigs_accel");
-    g_bugrigs_speed_ref = cvar("g_bugrigs_speed_ref");
-    g_bugrigs_speed_pow = cvar("g_bugrigs_speed_pow");
-    g_bugrigs_steer = cvar("g_bugrigs_steer");
-
        g_instagib = cvar("g_instagib");
 
        sv_clones = cvar("sv_clones");