From 206456c572a467a5e6ff1d7e423a8a19558288b1 Mon Sep 17 00:00:00 2001 From: Mario Date: Mon, 23 Nov 2015 22:33:30 +1000 Subject: [PATCH] Move dodging related stuff into the dodging file (no prediction yet, sorry) --- .../mutators/mutator/dodging/dodging.qc | 190 ++++++++++-------- .../mutators/mutator/dodging/module.inc | 2 +- qcsrc/common/physics.qc | 10 - 3 files changed, 107 insertions(+), 95 deletions(-) diff --git a/qcsrc/common/mutators/mutator/dodging/dodging.qc b/qcsrc/common/mutators/mutator/dodging/dodging.qc index f014ebbc5..b2140bbfc 100644 --- a/qcsrc/common/mutators/mutator/dodging/dodging.qc +++ b/qcsrc/common/mutators/mutator/dodging/dodging.qc @@ -97,6 +97,8 @@ REGISTER_MUTATOR(dodging, cvar("g_dodging")) return false; } +#elif defined(CSQC) +REGISTER_MUTATOR(dodging, true); #endif // set to 1 to indicate dodging has started.. reset by physics hook after dodge has been done.. @@ -126,33 +128,32 @@ REGISTER_MUTATOR(dodging, cvar("g_dodging")) #ifdef CSQC .int pressedkeys; +#endif -#elif defined(SVQC) - -void dodging_UpdateStats() -{SELFPARAM(); - self.stat_dodging = PHYS_DODGING; - self.stat_dodging_delay = PHYS_DODGING_DELAY; - self.stat_dodging_horiz_speed_frozen = PHYS_DODGING_HORIZ_SPEED_FROZEN; - self.stat_dodging_frozen = PHYS_DODGING_FROZEN; - self.stat_dodging_frozen_nodoubletap = PHYS_DODGING_FROZEN_NODOUBLETAP; - self.stat_dodging_height_threshold = PHYS_DODGING_HEIGHT_THRESHOLD; - self.stat_dodging_distance_threshold = PHYS_DODGING_DISTANCE_THRESHOLD; - self.stat_dodging_ramp_time = PHYS_DODGING_RAMP_TIME; - self.stat_dodging_up_speed = PHYS_DODGING_UP_SPEED; - self.stat_dodging_wall = PHYS_DODGING_WALL; -} - +void dodging_UpdateStats(entity this) +{ +#ifdef SVQC + this.stat_dodging = PHYS_DODGING; + this.stat_dodging_delay = PHYS_DODGING_DELAY; + this.stat_dodging_horiz_speed_frozen = PHYS_DODGING_HORIZ_SPEED_FROZEN; + this.stat_dodging_frozen = PHYS_DODGING_FROZEN; + this.stat_dodging_frozen_nodoubletap = PHYS_DODGING_FROZEN_NODOUBLETAP; + this.stat_dodging_height_threshold = PHYS_DODGING_HEIGHT_THRESHOLD; + this.stat_dodging_distance_threshold = PHYS_DODGING_DISTANCE_THRESHOLD; + this.stat_dodging_ramp_time = PHYS_DODGING_RAMP_TIME; + this.stat_dodging_up_speed = PHYS_DODGING_UP_SPEED; + this.stat_dodging_wall = PHYS_DODGING_WALL; #endif +} // returns 1 if the player is close to a wall -bool check_close_to_wall(float threshold) -{SELFPARAM(); +bool check_close_to_wall(entity this, float threshold) +{ if (PHYS_DODGING_WALL == 0) { return false; } #define X(OFFSET) \ - tracebox(self.origin, self.mins, self.maxs, self.origin + OFFSET, true, self); \ - if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold) \ + tracebox(this.origin, this.mins, this.maxs, this.origin + OFFSET, true, this); \ + if (trace_fraction < 1 && vlen (this.origin - trace_endpos) < threshold) \ return true; X(1000*v_right); X(-1000*v_right); @@ -163,41 +164,41 @@ bool check_close_to_wall(float threshold) return false; } -bool check_close_to_ground(float threshold) -{SELFPARAM(); - return IS_ONGROUND(self) ? true : false; +bool check_close_to_ground(entity this, float threshold) +{ + return IS_ONGROUND(this) ? true : false; } -float PM_dodging_checkpressedkeys() -{SELFPARAM(); +float PM_dodging_checkpressedkeys(entity this) +{ if(!PHYS_DODGING) return false; - float frozen_dodging = (PHYS_FROZEN(self) && PHYS_DODGING_FROZEN); + float frozen_dodging = (PHYS_FROZEN(this) && PHYS_DODGING_FROZEN); float frozen_no_doubletap = (frozen_dodging && !PHYS_DODGING_FROZEN_NODOUBLETAP); // first check if the last dodge is far enough back in time so we can dodge again - if ((time - self.last_dodging_time) < PHYS_DODGING_DELAY) + if ((time - this.last_dodging_time) < PHYS_DODGING_DELAY) return false; - makevectors(self.angles); + makevectors(this.angles); - if (check_close_to_ground(PHYS_DODGING_HEIGHT_THRESHOLD) != 1 - && check_close_to_wall(PHYS_DODGING_DISTANCE_THRESHOLD) != 1) + if (check_close_to_ground(this, PHYS_DODGING_HEIGHT_THRESHOLD) != 1 + && check_close_to_wall(this, PHYS_DODGING_DISTANCE_THRESHOLD) != 1) return true; float tap_direction_x = 0; float tap_direction_y = 0; - float dodge_detected = 0; + bool dodge_detected = false; #define X(COND,BTN,RESULT) \ - if (self.movement_##COND) \ + if (this.movement_##COND) \ /* is this a state change? */ \ - if(!(PHYS_DODGING_PRESSED_KEYS(self) & KEY_##BTN) || frozen_no_doubletap) { \ + if(!(PHYS_DODGING_PRESSED_KEYS(this) & KEY_##BTN) || frozen_no_doubletap) { \ tap_direction_##RESULT; \ - if ((time - self.last_##BTN##_KEY_time) < PHYS_DODGING_TIMEOUT(self)) \ - dodge_detected = 1; \ - self.last_##BTN##_KEY_time = time; \ + if ((time - this.last_##BTN##_KEY_time) < PHYS_DODGING_TIMEOUT(this)) \ + dodge_detected = true; \ + this.last_##BTN##_KEY_time = time; \ } X(x < 0, BACKWARD, x--); X(x > 0, FORWARD, x++); @@ -205,53 +206,51 @@ float PM_dodging_checkpressedkeys() X(y > 0, RIGHT, y++); #undef X - if (dodge_detected == 1) + if (dodge_detected) { - self.last_dodging_time = time; + this.last_dodging_time = time; - self.dodging_action = 1; - self.dodging_single_action = 1; + this.dodging_action = 1; + this.dodging_single_action = 1; - self.dodging_velocity_gain = PHYS_DODGING_HORIZ_SPEED; + this.dodging_velocity_gain = PHYS_DODGING_HORIZ_SPEED; - self.dodging_direction_x = tap_direction_x; - self.dodging_direction_y = tap_direction_y; + this.dodging_direction_x = tap_direction_x; + this.dodging_direction_y = tap_direction_y; // normalize the dodging_direction vector.. (unlike UT99) XD - float length = self.dodging_direction_x * self.dodging_direction_x - + self.dodging_direction_y * self.dodging_direction_y; + float length = this.dodging_direction_x * this.dodging_direction_x + + this.dodging_direction_y * this.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; + this.dodging_direction_x = this.dodging_direction_x * 1.0 / length; + this.dodging_direction_y = this.dodging_direction_y * 1.0 / length; return true; } return false; } -void PM_dodging() -{SELFPARAM(); +void PM_dodging(entity this) +{ if (!PHYS_DODGING) return; -#ifdef SVQC - dodging_UpdateStats(); -#endif + dodging_UpdateStats(this); - if (PHYS_DEAD(self)) + if (PHYS_DEAD(this)) return; // when swimming, no dodging allowed.. - if (self.waterlevel >= WATERLEVEL_SWIMMING) + if (this.waterlevel >= WATERLEVEL_SWIMMING) { - self.dodging_action = 0; - self.dodging_direction_x = 0; - self.dodging_direction_y = 0; + this.dodging_action = 0; + this.dodging_direction_x = 0; + this.dodging_direction_y = 0; return; } // make sure v_up, v_right and v_forward are sane - makevectors(self.angles); + makevectors(this.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 @@ -261,74 +260,97 @@ void PM_dodging() // if ramp time is smaller than frametime we get problems ;D common_factor = min(common_factor, 1); - float horiz_speed = PHYS_FROZEN(self) ? PHYS_DODGING_HORIZ_SPEED_FROZEN : PHYS_DODGING_HORIZ_SPEED; - float new_velocity_gain = self.dodging_velocity_gain - (common_factor * horiz_speed); + float horiz_speed = PHYS_FROZEN(this) ? PHYS_DODGING_HORIZ_SPEED_FROZEN : PHYS_DODGING_HORIZ_SPEED; + float new_velocity_gain = this.dodging_velocity_gain - (common_factor * horiz_speed); new_velocity_gain = max(0, new_velocity_gain); - float velocity_difference = self.dodging_velocity_gain - new_velocity_gain; + float velocity_difference = this.dodging_velocity_gain - new_velocity_gain; // ramp up dodging speed by adding some velocity each frame.. TODO: do it! :D - if (self.dodging_action == 1) + if (this.dodging_action == 1) { //disable jump key during dodge accel phase - if(self.movement_z > 0) { self.movement_z = 0; } + if(this.movement_z > 0) { this.movement_z = 0; } - self.velocity += ((self.dodging_direction_y * velocity_difference) * v_right) - + ((self.dodging_direction_x * velocity_difference) * v_forward); + this.velocity += ((this.dodging_direction_y * velocity_difference) * v_right) + + ((this.dodging_direction_x * velocity_difference) * v_forward); - self.dodging_velocity_gain = self.dodging_velocity_gain - velocity_difference; + this.dodging_velocity_gain = this.dodging_velocity_gain - velocity_difference; } // the up part of the dodge is a single shot action - if (self.dodging_single_action == 1) + if (this.dodging_single_action == 1) { - UNSET_ONGROUND(self); + UNSET_ONGROUND(this); + + this.velocity += PHYS_DODGING_UP_SPEED * v_up; - self.velocity += PHYS_DODGING_UP_SPEED * v_up; + #ifdef CSQC + LOG_INFO("YES?!\n"); + #endif #ifdef SVQC if (autocvar_sv_dodging_sound) PlayerSound(playersound_jump, CH_PLAYER, VOICETYPE_PLAYERSOUND); - animdecide_setaction(self, ANIMACTION_JUMP, true); + animdecide_setaction(this, ANIMACTION_JUMP, true); #endif - self.dodging_single_action = 0; + this.dodging_single_action = 0; } // are we done with the dodging ramp yet? - if((self.dodging_action == 1) && ((time - self.last_dodging_time) > PHYS_DODGING_RAMP_TIME)) + if((this.dodging_action == 1) && ((time - this.last_dodging_time) > PHYS_DODGING_RAMP_TIME)) { // reset state so next dodge can be done correctly - self.dodging_action = 0; - self.dodging_direction_x = 0; - self.dodging_direction_y = 0; + this.dodging_action = 0; + this.dodging_direction_x = 0; + this.dodging_direction_y = 0; } } -#ifdef SVQC - -MUTATOR_HOOKFUNCTION(dodging, GetCvars) +void PM_dodging_GetPressedKeys(entity this) { - GetCvars_handleFloat(get_cvars_s, get_cvars_f, cvar_cl_dodging_timeout, "cl_dodging_timeout"); - return false; +#ifdef CSQC + if(!PHYS_DODGING) { return; } + + PM_dodging_checkpressedkeys(this); + + int keys = this.pressedkeys; + keys = BITSET(keys, KEY_FORWARD, this.movement.x > 0); + keys = BITSET(keys, KEY_BACKWARD, this.movement.x < 0); + keys = BITSET(keys, KEY_RIGHT, this.movement.y > 0); + keys = BITSET(keys, KEY_LEFT, this.movement.y < 0); + + keys = BITSET(keys, KEY_JUMP, PHYS_INPUT_BUTTON_JUMP(this)); + keys = BITSET(keys, KEY_CROUCH, PHYS_INPUT_BUTTON_CROUCH(this)); + keys = BITSET(keys, KEY_ATCK, PHYS_INPUT_BUTTON_ATCK(this)); + keys = BITSET(keys, KEY_ATCK2, PHYS_INPUT_BUTTON_ATCK2(this)); + this.pressedkeys = keys; +#endif } MUTATOR_HOOKFUNCTION(dodging, PlayerPhysics) { // print("dodging_PlayerPhysics\n"); - PM_dodging(); + PM_dodging_GetPressedKeys(self); + PM_dodging(self); + return false; +} + +#ifdef SVQC +MUTATOR_HOOKFUNCTION(dodging, GetCvars) +{ + GetCvars_handleFloat(get_cvars_s, get_cvars_f, cvar_cl_dodging_timeout, "cl_dodging_timeout"); return false; } MUTATOR_HOOKFUNCTION(dodging, GetPressedKeys) { - PM_dodging_checkpressedkeys(); - + PM_dodging_checkpressedkeys(self); return false; } #endif - #endif diff --git a/qcsrc/common/mutators/mutator/dodging/module.inc b/qcsrc/common/mutators/mutator/dodging/module.inc index 6308a2182..60b193fdf 100644 --- a/qcsrc/common/mutators/mutator/dodging/module.inc +++ b/qcsrc/common/mutators/mutator/dodging/module.inc @@ -1,3 +1,3 @@ #ifdef SVQC -#include "dodging.qc" + #include "dodging.qc" #endif diff --git a/qcsrc/common/physics.qc b/qcsrc/common/physics.qc index 9e3a16d55..f42d06ed2 100644 --- a/qcsrc/common/physics.qc +++ b/qcsrc/common/physics.qc @@ -1687,16 +1687,6 @@ void PM_Main(entity this) MUTATOR_CALLHOOK(PlayerPhysics); -// float forcedodge = 1; -// if(forcedodge) { -//#ifdef CSQC -// PM_dodging_checkpressedkeys(); -//#endif -// PM_dodging(); -// PM_ClientMovement_Move(); -// return; -// } - #ifdef SVQC if (!IS_PLAYER(this)) { -- 2.39.2