X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fxonotic-data.pk3dir.git;a=blobdiff_plain;f=qcsrc%2Fserver%2Fmutators%2Fmutator_dodging.qc;h=a293b9f96a05c56bf4279ecb5e3946c83a7696bf;hp=2eaa5f0b24725c5b2c1adc133c4ce0dd2267e057;hb=6f37a8f8076a572097afb13de2c367a72717c927;hpb=46ab0565581b318ba02e7f9e9ddf879e90b8d452

diff --git a/qcsrc/server/mutators/mutator_dodging.qc b/qcsrc/server/mutators/mutator_dodging.qc
index 2eaa5f0b2..a293b9f96 100644
--- a/qcsrc/server/mutators/mutator_dodging.qc
+++ b/qcsrc/server/mutators/mutator_dodging.qc
@@ -1,3 +1,9 @@
+#include "mutator_dodging.qh"
+#include "../_.qh"
+
+#include "mutator.qh"
+
+#include "../../common/animdecide.qh"
 
 .float cvar_cl_dodging_timeout;
 
@@ -9,8 +15,7 @@
 .float last_RIGHT_KEY_time;
 
 // these store the movement direction at the time of the dodge action happening.
-.float dodging_direction_x;
-.float dodging_direction_y;
+.vector dodging_direction;
 
 // this indicates the last time a dodge was executed. used to check if another one is allowed
 // and to ramp up the dodge acceleration in the physics hook.
@@ -34,8 +39,8 @@ MUTATOR_HOOKFUNCTION(dodging_PlayerPhysics) {
 	float velocity_difference;
 	float clean_up_and_do_nothing;
 	float horiz_speed = autocvar_sv_dodging_horiz_speed;
-	
-	if(self.freezetag_frozen)
+
+	if(self.frozen)
 		horiz_speed = autocvar_sv_dodging_horiz_speed_frozen;
 
     if (self.deadflag != DEAD_NO)
@@ -61,13 +66,13 @@ MUTATOR_HOOKFUNCTION(dodging_PlayerPhysics) {
 	// make sure v_up, v_right and v_forward are sane
 	makevectors(self.angles);
 
-	// if we have e.g. 0.5 sec ramptime and a frametime of 0.25, then the ramp code 
-	// will be called ramp_time/frametime times = 2 times. so, we need to 
+	// if we have e.g. 0.5 sec ramptime and a frametime of 0.25, then the ramp code
+	// will be called ramp_time/frametime times = 2 times. so, we need to
 	// add 0.5 * the total speed each frame until the dodge action is done..
 	common_factor = sys_frametime / autocvar_sv_dodging_ramp_time;
 
 	// if ramp time is smaller than frametime we get problems ;D
-	if (common_factor > 1) 
+	if (common_factor > 1)
 		common_factor = 1;
 
 	new_velocity_gain = self.dodging_velocity_gain - (common_factor * horiz_speed);
@@ -79,12 +84,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.velocity =
+			  self.velocity
+			+ ((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;
 	}
@@ -93,14 +98,14 @@ MUTATOR_HOOKFUNCTION(dodging_PlayerPhysics) {
 	if (self.dodging_single_action == 1) {
 		self.flags &= ~FL_ONGROUND;
 
-		self.velocity = 
-			  self.velocity 
+		self.velocity =
+			  self.velocity
 			+ (autocvar_sv_dodging_up_speed * v_up);
 
-		if (autocvar_sv_dodging_sound == 1)
+		if (autocvar_sv_dodging_sound)
 			PlayerSound(playersound_jump, CH_PLAYER, VOICETYPE_PLAYERSOUND);
 
-		animdecide_setaction(self, ANIMACTION_JUMP, TRUE);
+		animdecide_setaction(self, ANIMACTION_JUMP, true);
 
 		self.dodging_single_action = 0;
 	}
@@ -119,9 +124,10 @@ MUTATOR_HOOKFUNCTION(dodging_PlayerPhysics) {
 
 
 // returns 1 if the player is close to a wall
-float check_close_to_wall(float threshold) {
-	if (autocvar_sv_dodging_wall_dodging == 0)
-		return 0;
+bool check_close_to_wall(float threshold)
+{
+	if(!autocvar_sv_dodging_wall_dodging)
+		return false;
 
 	vector trace_start;
 	vector trace_end;
@@ -129,33 +135,34 @@ float check_close_to_wall(float threshold) {
 	trace_start = self.origin;
 
 	trace_end = self.origin + (1000*v_right);
-	tracebox(trace_start, self.mins, self.maxs, trace_end, TRUE, self);
+	tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
 	if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
-		return 1;
+		return true;
 
 	trace_end = self.origin - (1000*v_right);
-	tracebox(trace_start, self.mins, self.maxs, trace_end, TRUE, self);
+	tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
 	if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
-		return 1;
+		return true;
 
 	trace_end = self.origin + (1000*v_forward);
-	tracebox(trace_start, self.mins, self.maxs, trace_end, TRUE, self);
+	tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
 	if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
-		return 1;
+		return true;
 
 	trace_end = self.origin - (1000*v_forward);
-	tracebox(trace_start, self.mins, self.maxs, trace_end, TRUE, self);
+	tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
 	if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
-		return 1;
+		return true;
 
-	return 0;
+	return false;
 }
 
-float check_close_to_ground(float threshold) {
+bool check_close_to_ground(float threshold)
+{
 	if (self.flags & FL_ONGROUND)
-		return 1;
+		return true;
 
-	return 0;
+	return false;
 }
 
 
@@ -163,14 +170,11 @@ MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
 	// print("dodging_PlayerPhysics\n");
 
 	float length;
-	float tap_direction_x;
-	float tap_direction_y;
+	vector tap_direction = '0 0 0';
 
-	tap_direction_x = 0;
-	tap_direction_y = 0;
-	
-	float frozen_dodging;
-	frozen_dodging = (self.freezetag_frozen && autocvar_sv_dodging_frozen);
+	float frozen_dodging, frozen_no_doubletap;
+	frozen_dodging = (self.frozen && autocvar_sv_dodging_frozen);
+	frozen_no_doubletap = (frozen_dodging && !autocvar_sv_dodging_frozen_doubletap);
 
 	float dodge_detected;
 	if (g_dodging == 0)
@@ -182,48 +186,48 @@ MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
 	if ((time - self.last_dodging_time) < autocvar_sv_dodging_delay)
 		return 0;
 
-	if (check_close_to_ground(autocvar_sv_dodging_height_threshold) != 1 
+	if (check_close_to_ground(autocvar_sv_dodging_height_threshold) != 1
 		&& 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_dodging) {
-			if ((time - self.last_FORWARD_KEY_time) < self.cvar_cl_dodging_timeout)	{ 
-				tap_direction_x = 1.0;
+		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;
 				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_dodging) {
-			tap_direction_x = -1.0;
-			if ((time - self.last_BACKWARD_KEY_time) < self.cvar_cl_dodging_timeout)	{ 
+ 		if (!(self.pressedkeys & KEY_BACKWARD) || frozen_no_doubletap) {
+			tap_direction.x = -1.0;
+			if ((time - self.last_BACKWARD_KEY_time) < self.cvar_cl_dodging_timeout)	{
 				dodge_detected = 1;
 			}
  			self.last_BACKWARD_KEY_time = time;
  		}
 	}
 
-	if (self.movement_y > 0) {
+	if (self.movement.y > 0) {
 		// is this a state change?
-		if (!(self.pressedkeys & KEY_RIGHT) || frozen_dodging) {
-			tap_direction_y = 1.0;
-			if ((time - self.last_RIGHT_KEY_time) < self.cvar_cl_dodging_timeout)	{ 
+		if (!(self.pressedkeys & KEY_RIGHT) || frozen_no_doubletap) {
+			tap_direction.y = 1.0;
+			if ((time - self.last_RIGHT_KEY_time) < self.cvar_cl_dodging_timeout)	{
 				dodge_detected = 1;
 			}
  			self.last_RIGHT_KEY_time = time;
  		}
 	}
 
-	if (self.movement_y < 0) {
+	if (self.movement.y < 0) {
 		// is this a state change?
-		if (!(self.pressedkeys & KEY_LEFT) || frozen_dodging) {
-			tap_direction_y = -1.0;
-			if ((time - self.last_LEFT_KEY_time) < self.cvar_cl_dodging_timeout)	{ 
+		if (!(self.pressedkeys & KEY_LEFT) || frozen_no_doubletap) {
+			tap_direction.y = -1.0;
+			if ((time - self.last_LEFT_KEY_time) < self.cvar_cl_dodging_timeout)	{
 				dodge_detected = 1;
 			}
  			self.last_LEFT_KEY_time = time;
@@ -238,16 +242,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;