Possible fix for insanely fast dodging speed

diff --git a/qcsrc/server/mutators/mutator_dodging.qc b/qcsrc/server/mutators/mutator_dodging.qc
index e4e492607be0cddea30bb87d8bb4f01f48c82f64..1e88634d455a13b65d2599cba164548b9a7b9483 100644 (file)
--- a/qcsrc/server/mutators/mutator_dodging.qc
+++ b/qcsrc/server/mutators/mutator_dodging.qc
@@ -91,12 +91,12 @@ MUTATOR_HOOKFUNCTION(dodging_PlayerPhysics) {
        // ramp up dodging speed by adding some velocity each frame.. TODO: do it! :D
        if (self.dodging_action == 1) {
                //disable jump key during dodge accel phase
-               if (self.movement.z > 0) self.movement_z = 0;
+               if (self.movement_z > 0) self.movement_z = 0;
 
                self.velocity +=
                          self.velocity
-                       + ((self.dodging_direction.y * velocity_difference) * v_right)
-                       + ((self.dodging_direction.x * velocity_difference) * v_forward);
+                       + ((self.dodging_direction_y * velocity_difference) * v_right)
+                       + ((self.dodging_direction_x * velocity_difference) * v_forward);
 
                self.dodging_velocity_gain = self.dodging_velocity_gain - velocity_difference;
        }
@@ -207,21 +207,21 @@ MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
                && check_close_to_wall(autocvar_sv_dodging_wall_distance_threshold) != 1)
                return 0;
 
-       if (self.movement.x > 0) {
+       if (self.movement_x > 0) {
                // is this a state change?
                if (!(self.pressedkeys & KEY_FORWARD) || frozen_no_doubletap) {
                        if ((time - self.last_FORWARD_KEY_time) < self.cvar_cl_dodging_timeout) {
-                               tap_direction.x = 1.0;
+                               tap_direction_x = 1.0;
                                dodge_detected = 1;
                        }
                        self.last_FORWARD_KEY_time = time;
                }
        }
 
-       if (self.movement.x < 0) {
+       if (self.movement_x < 0) {
                // is this a state change?
                if (!(self.pressedkeys & KEY_BACKWARD) || frozen_no_doubletap) {
-                       tap_direction.x = -1.0;
+                       tap_direction_x = -1.0;
                        if ((time - self.last_BACKWARD_KEY_time) < self.cvar_cl_dodging_timeout)        {
                                dodge_detected = 1;
                        }
@@ -229,10 +229,10 @@ MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
                }
        }
 
-       if (self.movement.y > 0) {
+       if (self.movement_y > 0) {
                // is this a state change?
                if (!(self.pressedkeys & KEY_RIGHT) || frozen_no_doubletap) {
-                       tap_direction.y = 1.0;
+                       tap_direction_y = 1.0;
                        if ((time - self.last_RIGHT_KEY_time) < self.cvar_cl_dodging_timeout)   {
                                dodge_detected = 1;
                        }
@@ -240,10 +240,10 @@ MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
                }
        }
 
-       if (self.movement.y < 0) {
+       if (self.movement_y < 0) {
                // is this a state change?
                if (!(self.pressedkeys & KEY_LEFT) || frozen_no_doubletap) {
-                       tap_direction.y = -1.0;
+                       tap_direction_y = -1.0;
                        if ((time - self.last_LEFT_KEY_time) < self.cvar_cl_dodging_timeout)    {
                                dodge_detected = 1;
                        }
@@ -259,16 +259,16 @@ MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
 
                self.dodging_velocity_gain = autocvar_sv_dodging_horiz_speed;
 
-               self.dodging_direction_x = tap_direction.x;
-               self.dodging_direction_y = tap_direction.y;
+               self.dodging_direction_x = tap_direction_x;
+               self.dodging_direction_y = tap_direction_y;
 
                // normalize the dodging_direction vector.. (unlike UT99) XD
-               length =          self.dodging_direction.x * self.dodging_direction.x;
-               length = length + self.dodging_direction.y * self.dodging_direction.y;
+               length =          self.dodging_direction_x * self.dodging_direction_x;
+               length = length + self.dodging_direction_y * self.dodging_direction_y;
                length = sqrt(length);
 
-               self.dodging_direction_x = self.dodging_direction.x * 1.0/length;
-               self.dodging_direction_y = self.dodging_direction.y * 1.0/length;
+               self.dodging_direction_x = self.dodging_direction_x * 1.0/length;
+               self.dodging_direction_y = self.dodging_direction_y * 1.0/length;
        }
 
        return 0;