X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fphysics.qc;h=60ca3b101a7c7c7c09b6f303786875d8137f340f;hb=924ba9b521119651b5667c0280868df9f95ca488;hp=19d6692daf236ebf5c963df841182248f7fefce8;hpb=6cd2df9ec40fdc51dc462d93f440dc225beb37ba;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/common/physics.qc b/qcsrc/common/physics.qc index 19d6692da..60ca3b101 100644 --- a/qcsrc/common/physics.qc +++ b/qcsrc/common/physics.qc @@ -1,170 +1,193 @@ -.float race_penalty; -.float restart_jump; - -.float ladder_time; -.entity ladder_entity; -.float gravity; -.float swamp_slowdown; -.float lastflags; -.float lastground; -.float wasFlying; -.float spectatorspeed; - -.vector movement_old; -.float buttons_old; -.vector v_angle_old; -.string lastclassname; - -.float() PlayerPhysplug; - -// Client/server mappings -#ifdef CSQC -.float watertype; - - #define PHYS_INPUT_ANGLES(s) input_angles - #define PHYS_INPUT_BUTTONS(s) input_buttons - - #define PHYS_INPUT_TIMELENGTH input_timelength - - #define PHYS_INPUT_MOVEVALUES(s) input_movevalues - - #define GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE - #define GAMEPLAYFIX_NOGRAVITYONGROUND moveflags & MOVEFLAG_NOGRAVITYONGROUND - #define GAMEPLAYFIX_Q2AIRACCELERATE moveflags & MOVEFLAG_Q2AIRACCELERATE - - #define IS_DUCKED(s) (s.pmove_flags & PMF_DUCKED) - #define SET_DUCKED(s) s.pmove_flags |= PMF_DUCKED - #define UNSET_DUCKED(s) s.pmove_flags &= ~PMF_DUCKED - - #define IS_JUMP_HELD(s) (s.pmove_flags & PMF_JUMP_HELD) - #define SET_JUMP_HELD(s) s.pmove_flags |= PMF_JUMP_HELD - #define UNSET_JUMP_HELD(s) s.pmove_flags &= ~PMF_JUMP_HELD - - #define IS_ONGROUND(s) (s.pmove_flags & PMF_ONGROUND) - #define SET_ONGROUND(s) s.pmove_flags |= PMF_ONGROUND - #define UNSET_ONGROUND(s) s.pmove_flags &= ~PMF_ONGROUND - - #define ITEMS(s) getstati(STAT_ITEMS, 0, 24) - #define PHYS_AMMO_FUEL(s) getstatf(STAT_FUEL) - #define PHYS_FROZEN(s) getstati(STAT_FROZEN) - - #define PHYS_ACCELERATE getstatf(STAT_MOVEVARS_ACCELERATE) - #define PHYS_AIRACCEL_QW(s) getstatf(STAT_MOVEVARS_AIRACCEL_QW) - #define PHYS_AIRACCEL_QW_STRETCHFACTOR(s) getstatf(STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR) - #define PHYS_AIRACCEL_SIDEWAYS_FRICTION getstatf(STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION) - #define PHYS_AIRACCELERATE getstatf(STAT_MOVEVARS_AIRACCELERATE) - #define PHYS_AIRCONTROL getstatf(STAT_MOVEVARS_AIRCONTROL) - #define PHYS_AIRCONTROL_PENALTY getstatf(STAT_MOVEVARS_AIRCONTROL_PENALTY) - #define PHYS_AIRCONTROL_POWER getstatf(STAT_MOVEVARS_AIRCONTROL_POWER) - #define PHYS_AIRSPEEDLIMIT_NONQW(s) getstatf(STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW) - #define PHYS_AIRSTOPACCELERATE getstatf(STAT_MOVEVARS_AIRSTOPACCELERATE) - #define PHYS_AIRSTRAFEACCEL_QW(s) getstatf(STAT_MOVEVARS_AIRSTRAFEACCEL_QW) - #define PHYS_AIRSTRAFEACCELERATE getstatf(STAT_MOVEVARS_AIRSTRAFEACCELERATE) - #define PHYS_ENTGRAVITY(s) getstatf(STAT_MOVEVARS_ENTGRAVITY) - #define PHYS_FRICTION getstatf(STAT_MOVEVARS_FRICTION) - #define PHYS_GRAVITY getstatf(STAT_MOVEVARS_GRAVITY) - #define PHYS_HIGHSPEED getstatf(STAT_MOVEVARS_HIGHSPEED) - #define PHYS_JUMPVELOCITY getstatf(STAT_MOVEVARS_JUMPVELOCITY) - #define PHYS_MAXAIRSPEED getstatf(STAT_MOVEVARS_MAXAIRSPEED) - #define PHYS_MAXAIRSTRAFESPEED getstatf(STAT_MOVEVARS_MAXAIRSTRAFESPEED) - #define PHYS_MAXSPEED(s) getstatf(STAT_MOVEVARS_MAXSPEED) - #define PHYS_STEPHEIGHT getstatf(STAT_MOVEVARS_STEPHEIGHT) - #define PHYS_STOPSPEED getstatf(STAT_MOVEVARS_STOPSPEED) - #define PHYS_WARSOWBUNNY_ACCEL getstatf(STAT_MOVEVARS_WARSOWBUNNY_ACCEL) - #define PHYS_WARSOWBUNNY_BACKTOSIDERATIO getstatf(STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO) - #define PHYS_WARSOWBUNNY_AIRFORWARDACCEL getstatf(STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL) - #define PHYS_WARSOWBUNNY_TOPSPEED getstatf(STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED) - #define PHYS_WARSOWBUNNY_TURNACCEL getstatf(STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL) - - #define PHYS_JETPACK_ACCEL_UP getstatf(STAT_JETPACK_ACCEL_UP) - #define PHYS_JETPACK_ACCEL_SIDE getstatf(STAT_JETPACK_ACCEL_SIDE) - #define PHYS_JETPACK_ANTIGRAVITY getstatf(STAT_JETPACK_ANTIGRAVITY) - #define PHYS_JETPACK_FUEL getstatf(STAT_JETPACK_FUEL) - #define PHYS_JETPACK_MAXSPEED_UP getstatf(STAT_JETPACK_MAXSPEED_UP) - #define PHYS_JETPACK_MAXSPEED_SIDE getstatf(STAT_JETPACK_MAXSPEED_SIDE) - - #define PHYS_BUTTON_HOOK(s) (input_buttons & 32) - - #define PHYS_DODGING_FROZEN getstati(STAT_DODGING_FROZEN) - -#elif defined(SVQC) - - #define PHYS_INPUT_ANGLES(s) s.v_angle - // TODO: cache - #define PHYS_INPUT_BUTTONS(s) (s.BUTTON_ATCK + 2 * s.BUTTON_JUMP + 4 * s.BUTTON_ATCK2 + 8 * s.BUTTON_ZOOM + 16 * s.BUTTON_CROUCH + 32 * s.BUTTON_HOOK + 64 * s.BUTTON_USE + 128 * (s.movement_x < 0) + 256 * (s.movement_x > 0) + 512 * (s.movement_y < 0) + 1024 * (s.movement_y > 0)) - - #define PHYS_INPUT_TIMELENGTH frametime - - #define PHYS_INPUT_MOVEVALUES(s) s.movement - - #define GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE autocvar_sv_gameplayfix_gravityunaffectedbyticrate - #define GAMEPLAYFIX_NOGRAVITYONGROUND cvar("sv_gameplayfix_nogravityonground") - #define GAMEPLAYFIX_Q2AIRACCELERATE autocvar_sv_gameplayfix_q2airaccelerate - - #define IS_DUCKED(s) s.crouch - #define SET_DUCKED(s) s.crouch = TRUE - #define UNSET_DUCKED(s) s.crouch = FALSE - - #define IS_JUMP_HELD(s) (s.flags & FL_JUMPRELEASED == 0) - #define SET_JUMP_HELD(s) s.flags &= ~FL_JUMPRELEASED - #define UNSET_JUMP_HELD(s) s.flags |= FL_JUMPRELEASED - - #define IS_ONGROUND(s) (s.flags & FL_ONGROUND) - #define SET_ONGROUND(s) s.flags |= FL_ONGROUND - #define UNSET_ONGROUND(s) s.flags &= ~FL_ONGROUND - - #define ITEMS(s) s.items - #define PHYS_AMMO_FUEL(s) s.ammo_fuel - #define PHYS_FROZEN(s) s.frozen - - #define PHYS_ACCELERATE autocvar_sv_accelerate - #define PHYS_AIRACCEL_QW(s) s.stat_sv_airaccel_qw - #define PHYS_AIRACCEL_QW_STRETCHFACTOR(s) autocvar_sv_airaccel_qw_stretchfactor - #define PHYS_AIRACCEL_SIDEWAYS_FRICTION autocvar_sv_airaccel_sideways_friction - #define PHYS_AIRACCELERATE autocvar_sv_airaccelerate - #define PHYS_AIRCONTROL autocvar_sv_aircontrol - #define PHYS_AIRCONTROL_PENALTY autocvar_sv_aircontrol_penalty - #define PHYS_AIRCONTROL_POWER autocvar_sv_aircontrol_power - #define PHYS_AIRSPEEDLIMIT_NONQW(s) s.stat_sv_airspeedlimit_nonqw - #define PHYS_AIRSTOPACCELERATE autocvar_sv_airstopaccelerate - #define PHYS_AIRSTRAFEACCEL_QW(s) s.stat_sv_airstrafeaccel_qw - #define PHYS_AIRSTRAFEACCELERATE autocvar_sv_airstrafeaccelerate - #define PHYS_ENTGRAVITY(s) s.gravity - #define PHYS_FRICTION autocvar_sv_friction - #define PHYS_GRAVITY autocvar_sv_gravity - #define PHYS_HIGHSPEED autocvar_g_movement_highspeed - #define PHYS_JUMPVELOCITY autocvar_sv_jumpvelocity - #define PHYS_MAXAIRSPEED autocvar_sv_maxairspeed - #define PHYS_MAXAIRSTRAFESPEED autocvar_sv_maxairstrafespeed - #define PHYS_MAXSPEED(s) s.stat_sv_maxspeed - #define PHYS_STEPHEIGHT autocvar_sv_stepheight - #define PHYS_STOPSPEED autocvar_sv_stopspeed - #define PHYS_WARSOWBUNNY_ACCEL autocvar_sv_warsowbunny_accel - #define PHYS_WARSOWBUNNY_BACKTOSIDERATIO autocvar_sv_warsowbunny_backtosideratio - #define PHYS_WARSOWBUNNY_AIRFORWARDACCEL autocvar_sv_warsowbunny_airforwardaccel - #define PHYS_WARSOWBUNNY_TOPSPEED autocvar_sv_warsowbunny_topspeed - #define PHYS_WARSOWBUNNY_TURNACCEL autocvar_sv_warsowbunny_turnaccel - - #define PHYS_JETPACK_ACCEL_UP autocvar_g_jetpack_acceleration_up - #define PHYS_JETPACK_ACCEL_SIDE autocvar_g_jetpack_acceleration_side - #define PHYS_JETPACK_ANTIGRAVITY autocvar_g_jetpack_antigravity - #define PHYS_JETPACK_FUEL autocvar_g_jetpack_fuel - #define PHYS_JETPACK_MAXSPEED_UP autocvar_g_jetpack_maxspeed_up - #define PHYS_JETPACK_MAXSPEED_SIDE autocvar_g_jetpack_maxspeed_side - - #define PHYS_BUTTON_HOOK(s) s.BUTTON_HOOK - - #define PHYS_DODGING_FROZEN autocvar_sv_dodging_frozen +#include "physics.qh" +#include "triggers/trigger/swamp.qh" +#include "triggers/trigger/jumppads.qh" + +#ifdef SVQC + +#include "../server/miscfunctions.qh" + +// client side physics +bool Physics_Valid(string thecvar) +{ + if(!autocvar_g_physics_clientselect) { return false; } + + string l = strcat(" ", autocvar_g_physics_clientselect_options, " "); + + if(strstrofs(l, strcat(" ", thecvar, " "), 0) >= 0) + return true; + + return false; +} + +float Physics_ClientOption(entity pl, string option) +{ + if(Physics_Valid(pl.cvar_cl_physics)) + { + string var = sprintf("g_physics_%s_%s", pl.cvar_cl_physics, option); + if(cvar_type(var) & CVAR_TYPEFLAG_EXISTS) + return cvar(var); + } + if(autocvar_g_physics_clientselect && autocvar_g_physics_clientselect_default) + { + string var = sprintf("g_physics_%s_%s", autocvar_g_physics_clientselect_default, option); + if(cvar_type(var) & CVAR_TYPEFLAG_EXISTS) + return cvar(var); + } + return cvar(strcat("sv_", option)); +} + +void Physics_AddStats() +{ + // static view offset and hitbox vectors + // networked for all you bandwidth pigs out there + addstat(STAT_PL_VIEW_OFS1, AS_FLOAT, stat_pl_view_ofs_x); + addstat(STAT_PL_VIEW_OFS2, AS_FLOAT, stat_pl_view_ofs_y); + addstat(STAT_PL_VIEW_OFS3, AS_FLOAT, stat_pl_view_ofs_z); + addstat(STAT_PL_CROUCH_VIEW_OFS1, AS_FLOAT, stat_pl_crouch_view_ofs_x); + addstat(STAT_PL_CROUCH_VIEW_OFS2, AS_FLOAT, stat_pl_crouch_view_ofs_y); + addstat(STAT_PL_CROUCH_VIEW_OFS3, AS_FLOAT, stat_pl_crouch_view_ofs_z); + + addstat(STAT_PL_MIN1, AS_FLOAT, stat_pl_min_x); + addstat(STAT_PL_MIN2, AS_FLOAT, stat_pl_min_y); + addstat(STAT_PL_MIN3, AS_FLOAT, stat_pl_min_z); + addstat(STAT_PL_MAX1, AS_FLOAT, stat_pl_max_x); + addstat(STAT_PL_MAX2, AS_FLOAT, stat_pl_max_y); + addstat(STAT_PL_MAX3, AS_FLOAT, stat_pl_max_z); + addstat(STAT_PL_CROUCH_MIN1, AS_FLOAT, stat_pl_crouch_min_x); + addstat(STAT_PL_CROUCH_MIN2, AS_FLOAT, stat_pl_crouch_min_y); + addstat(STAT_PL_CROUCH_MIN3, AS_FLOAT, stat_pl_crouch_min_z); + addstat(STAT_PL_CROUCH_MAX1, AS_FLOAT, stat_pl_crouch_max_x); + addstat(STAT_PL_CROUCH_MAX2, AS_FLOAT, stat_pl_crouch_max_y); + addstat(STAT_PL_CROUCH_MAX3, AS_FLOAT, stat_pl_crouch_max_z); + + // g_movementspeed hack + addstat(STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW, AS_FLOAT, stat_sv_airspeedlimit_nonqw); + addstat(STAT_MOVEVARS_MAXSPEED, AS_FLOAT, stat_sv_maxspeed); + addstat(STAT_MOVEVARS_AIRACCEL_QW, AS_FLOAT, stat_sv_airaccel_qw); + addstat(STAT_MOVEVARS_AIRSTRAFEACCEL_QW, AS_FLOAT, stat_sv_airstrafeaccel_qw); + addstat(STAT_MOVEVARS_HIGHSPEED, AS_FLOAT, stat_movement_highspeed); + + // jet pack + addstat(STAT_JETPACK_ACCEL_SIDE, AS_FLOAT, stat_jetpack_accel_side); + addstat(STAT_JETPACK_ACCEL_UP, AS_FLOAT, stat_jetpack_accel_up); + addstat(STAT_JETPACK_ANTIGRAVITY, AS_FLOAT, stat_jetpack_antigravity); + addstat(STAT_JETPACK_FUEL, AS_FLOAT, stat_jetpack_fuel); + addstat(STAT_JETPACK_MAXSPEED_UP, AS_FLOAT, stat_jetpack_maxspeed_up); + addstat(STAT_JETPACK_MAXSPEED_SIDE, AS_FLOAT, stat_jetpack_maxspeed_side); + + // hack to fix track_canjump + addstat(STAT_MOVEVARS_TRACK_CANJUMP, AS_INT, cvar_cl_movement_track_canjump); + + // double jump + addstat(STAT_DOUBLEJUMP, AS_INT, stat_doublejump); + + // jump speed caps + addstat(STAT_MOVEVARS_JUMPSPEEDCAP_MIN, AS_FLOAT, stat_jumpspeedcap_min); + addstat(STAT_MOVEVARS_JUMPSPEEDCAP_MIN, AS_FLOAT, stat_jumpspeedcap_min); + addstat(STAT_MOVEVARS_JUMPSPEEDCAP_DISABLE_ONRAMPS, AS_INT, stat_jumpspeedcap_disable_onramps); + + // hacks + addstat(STAT_MOVEVARS_FRICTION_ONLAND, AS_FLOAT, stat_sv_friction_on_land); + addstat(STAT_MOVEVARS_FRICTION_SLICK, AS_FLOAT, stat_sv_friction_slick); + addstat(STAT_GAMEPLAYFIX_EASIERWATERJUMP, AS_INT, stat_gameplayfix_easierwaterjump); + + // new properties + addstat(STAT_MOVEVARS_JUMPVELOCITY, AS_FLOAT, stat_sv_jumpvelocity); + addstat(STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR, AS_FLOAT, stat_sv_airaccel_qw_stretchfactor); + addstat(STAT_MOVEVARS_MAXAIRSTRAFESPEED, AS_FLOAT, stat_sv_maxairstrafespeed); + addstat(STAT_MOVEVARS_MAXAIRSPEED, AS_FLOAT, stat_sv_maxairspeed); + addstat(STAT_MOVEVARS_AIRSTRAFEACCELERATE, AS_FLOAT, stat_sv_airstrafeaccelerate); + addstat(STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL, AS_FLOAT, stat_sv_warsowbunny_turnaccel); + addstat(STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION, AS_FLOAT, stat_sv_airaccel_sideways_friction); + addstat(STAT_MOVEVARS_AIRCONTROL, AS_FLOAT, stat_sv_aircontrol); + addstat(STAT_MOVEVARS_AIRCONTROL_POWER, AS_FLOAT, stat_sv_aircontrol_power); + addstat(STAT_MOVEVARS_AIRCONTROL_PENALTY, AS_FLOAT, stat_sv_aircontrol_penalty); + addstat(STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL, AS_FLOAT, stat_sv_warsowbunny_airforwardaccel); + addstat(STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED, AS_FLOAT, stat_sv_warsowbunny_topspeed); + addstat(STAT_MOVEVARS_WARSOWBUNNY_ACCEL, AS_FLOAT, stat_sv_warsowbunny_accel); + addstat(STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO, AS_FLOAT, stat_sv_warsowbunny_backtosideratio); + addstat(STAT_MOVEVARS_FRICTION, AS_FLOAT, stat_sv_friction); + addstat(STAT_MOVEVARS_ACCELERATE, AS_FLOAT, stat_sv_accelerate); + addstat(STAT_MOVEVARS_STOPSPEED, AS_FLOAT, stat_sv_stopspeed); + addstat(STAT_MOVEVARS_AIRACCELERATE, AS_FLOAT, stat_sv_airaccelerate); + addstat(STAT_MOVEVARS_AIRSTOPACCELERATE, AS_FLOAT, stat_sv_airstopaccelerate); + + addstat(STAT_GAMEPLAYFIX_UPVELOCITYCLEARSONGROUND, AS_INT, stat_gameplayfix_upvelocityclearsonground); +} + +void Physics_UpdateStats(float maxspd_mod) +{ + // blah + self.stat_pl_view_ofs = PL_VIEW_OFS; + self.stat_pl_crouch_view_ofs = PL_CROUCH_VIEW_OFS; + + self.stat_pl_min = PL_MIN; + self.stat_pl_max = PL_MAX; + self.stat_pl_crouch_min = PL_CROUCH_MIN; + self.stat_pl_crouch_max = PL_CROUCH_MAX; + + self.stat_sv_airaccel_qw = AdjustAirAccelQW(Physics_ClientOption(self, "airaccel_qw"), maxspd_mod); + if(Physics_ClientOption(self, "airstrafeaccel_qw")) + self.stat_sv_airstrafeaccel_qw = AdjustAirAccelQW(Physics_ClientOption(self, "airstrafeaccel_qw"), maxspd_mod); + else + self.stat_sv_airstrafeaccel_qw = 0; + self.stat_sv_airspeedlimit_nonqw = Physics_ClientOption(self, "airspeedlimit_nonqw") * maxspd_mod; + self.stat_sv_maxspeed = Physics_ClientOption(self, "maxspeed") * maxspd_mod; // also slow walking + self.stat_movement_highspeed = PHYS_HIGHSPEED; // TODO: remove this! + + self.stat_doublejump = PHYS_DOUBLEJUMP; + + self.stat_jetpack_antigravity = PHYS_JETPACK_ANTIGRAVITY; + self.stat_jetpack_accel_up = PHYS_JETPACK_ACCEL_UP; + self.stat_jetpack_accel_side = PHYS_JETPACK_ACCEL_SIDE; + self.stat_jetpack_maxspeed_side = PHYS_JETPACK_MAXSPEED_SIDE; + self.stat_jetpack_maxspeed_up = PHYS_JETPACK_MAXSPEED_UP; + self.stat_jetpack_fuel = PHYS_JETPACK_FUEL; + + self.stat_jumpspeedcap_min = PHYS_JUMPSPEEDCAP_MIN; + self.stat_jumpspeedcap_max = PHYS_JUMPSPEEDCAP_MAX; + self.stat_jumpspeedcap_disable_onramps = PHYS_JUMPSPEEDCAP_DISABLE_ONRAMPS; + + self.stat_sv_friction_on_land = PHYS_FRICTION_ONLAND; + self.stat_sv_friction_slick = PHYS_FRICTION_SLICK; + + self.stat_gameplayfix_easierwaterjump = GAMEPLAYFIX_EASIERWATERJUMP; + + + // old stats + // fix some new settings + self.stat_sv_airaccel_qw_stretchfactor = Physics_ClientOption(self, "airaccel_qw_stretchfactor"); + self.stat_sv_maxairstrafespeed = Physics_ClientOption(self, "maxairstrafespeed"); + self.stat_sv_maxairspeed = Physics_ClientOption(self, "maxairspeed"); + self.stat_sv_airstrafeaccelerate = Physics_ClientOption(self, "airstrafeaccelerate"); + self.stat_sv_warsowbunny_turnaccel = Physics_ClientOption(self, "warsowbunny_turnaccel"); + self.stat_sv_airaccel_sideways_friction = Physics_ClientOption(self, "airaccel_sideways_friction"); + self.stat_sv_aircontrol = Physics_ClientOption(self, "aircontrol"); + self.stat_sv_aircontrol_power = Physics_ClientOption(self, "aircontrol_power"); + self.stat_sv_aircontrol_penalty = Physics_ClientOption(self, "aircontrol_penalty"); + self.stat_sv_warsowbunny_airforwardaccel = Physics_ClientOption(self, "warsowbunny_airforwardaccel"); + self.stat_sv_warsowbunny_topspeed = Physics_ClientOption(self, "warsowbunny_topspeed"); + self.stat_sv_warsowbunny_accel = Physics_ClientOption(self, "warsowbunny_accel"); + self.stat_sv_warsowbunny_backtosideratio = Physics_ClientOption(self, "warsowbunny_backtosideratio"); + self.stat_sv_friction = Physics_ClientOption(self, "friction"); + self.stat_sv_accelerate = Physics_ClientOption(self, "accelerate"); + self.stat_sv_stopspeed = Physics_ClientOption(self, "stopspeed"); + self.stat_sv_airaccelerate = Physics_ClientOption(self, "airaccelerate"); + self.stat_sv_airstopaccelerate = Physics_ClientOption(self, "airstopaccelerate"); + self.stat_sv_jumpvelocity = Physics_ClientOption(self, "jumpvelocity"); + + self.stat_gameplayfix_upvelocityclearsonground = UPWARD_VELOCITY_CLEARS_ONGROUND; +} #endif -float IsMoveInDirection(vector mv, float angle) // key mix factor +float IsMoveInDirection(vector mv, float ang) // key mix factor { if (mv_x == 0 && mv_y == 0) return 0; // avoid division by zero - angle -= RAD2DEG * atan2(mv_y, mv_x); - angle = remainder(angle, 360) / 45; - return angle > 1 ? 0 : angle < -1 ? 0 : 1 - fabs(angle); + ang -= RAD2DEG * atan2(mv_y, mv_x); + ang = remainder(ang, 360) / 45; + return ang > 1 ? 0 : ang < -1 ? 0 : 1 - fabs(ang); } float GeomLerp(float a, float lerp, float b) @@ -174,9 +197,7 @@ float GeomLerp(float a, float lerp, float b) : a * pow(fabs(b / a), lerp); } -#ifdef CSQC -float pmove_waterjumptime; // weird engine flag we shouldn't really use but have to for now -#endif +noref float pmove_waterjumptime; const float unstick_count = 27; vector unstick_offsets[unstick_count] = @@ -202,7 +223,7 @@ vector unstick_offsets[unstick_count] = '-0.125 0.125 -0.125', '0.125 0.125 -0.125', }; -void CSQC_ClientMovement_Unstick() +void PM_ClientMovement_Unstick() { float i; for (i = 0; i < unstick_count; i++) @@ -211,20 +232,19 @@ void CSQC_ClientMovement_Unstick() tracebox(neworigin, PL_CROUCH_MIN, PL_CROUCH_MAX, neworigin, MOVE_NORMAL, self); if (!trace_startsolid) { - self.origin = neworigin; + setorigin(self, neworigin); return;// true; } } } -#ifdef CSQC -void CSQC_ClientMovement_UpdateStatus() +void PM_ClientMovement_UpdateStatus(bool ground) { // make sure player is not stuck - CSQC_ClientMovement_Unstick(); + PM_ClientMovement_Unstick(); // set crouched - if (PHYS_INPUT_BUTTONS(self) & 16) + if (PHYS_INPUT_BUTTON_CROUCH(self)) { // wants to crouch, this always works.. if (!IS_DUCKED(self)) @@ -246,35 +266,41 @@ void CSQC_ClientMovement_UpdateStatus() vector origin1 = self.origin + '0 0 1'; vector origin2 = self.origin - '0 0 1'; - tracebox(origin1, self.mins, self.maxs, origin2, MOVE_NORMAL, self); - if (trace_fraction < 1 && trace_plane_normal_z > 0.7) + if(ground) { - SET_ONGROUND(self); + tracebox(origin1, self.mins, self.maxs, origin2, MOVE_NORMAL, self); + if (trace_fraction < 1.0 && trace_plane_normal_z > 0.7) + { + SET_ONGROUND(self); - // this code actually "predicts" an impact; so let's clip velocity first - float f = dotproduct(self.velocity, trace_plane_normal); - if (f < 0) // only if moving downwards actually + // this code actually "predicts" an impact; so let's clip velocity first + float f = self.velocity * trace_plane_normal; self.velocity -= f * trace_plane_normal; + } + else + UNSET_ONGROUND(self); } - else - UNSET_ONGROUND(self); // set watertype/waterlevel origin1 = self.origin; origin1_z += self.mins_z + 1; self.waterlevel = WATERLEVEL_NONE; - self.watertype = (pointcontents(origin1) == CONTENT_WATER); + int thepoint = pointcontents(origin1); + + self.watertype = (thepoint == CONTENT_WATER || thepoint == CONTENT_LAVA || thepoint == CONTENT_SLIME); if(self.watertype) { self.waterlevel = WATERLEVEL_WETFEET; origin1_z = self.origin_z + (self.mins_z + self.maxs_z) * 0.5; - if(pointcontents(origin1) == CONTENT_WATER) + thepoint = pointcontents(origin1); + if(thepoint == CONTENT_WATER || thepoint == CONTENT_LAVA || thepoint == CONTENT_SLIME) { self.waterlevel = WATERLEVEL_SWIMMING; origin1_z = self.origin_z + 22; - if(pointcontents(origin1) == CONTENT_WATER) + thepoint = pointcontents(origin1); + if(thepoint == CONTENT_WATER || thepoint == CONTENT_LAVA || thepoint == CONTENT_SLIME) self.waterlevel = WATERLEVEL_SUBMERGED; } } @@ -283,94 +309,102 @@ void CSQC_ClientMovement_UpdateStatus() pmove_waterjumptime = 0; } -void CSQC_ClientMovement_Move() +void PM_ClientMovement_Move() { - float t = PHYS_INPUT_TIMELENGTH; - vector primalvelocity = self.velocity; - CSQC_ClientMovement_UpdateStatus(); - float bump = 0; - for (bump = 0; bump < 8 && self.velocity * self.velocity > 0; bump++) +#ifdef CSQC + int bump; + float t; + float f; + vector neworigin; + vector currentorigin2; + vector neworigin2; + vector primalvelocity; + + vector trace1_endpos = '0 0 0'; + vector trace2_endpos = '0 0 0'; + vector trace3_endpos = '0 0 0'; + float trace1_fraction = 0; + float trace2_fraction = 0; + float trace3_fraction = 0; + vector trace1_plane_normal = '0 0 0'; + vector trace2_plane_normal = '0 0 0'; + vector trace3_plane_normal = '0 0 0'; + + + PM_ClientMovement_UpdateStatus(false); + primalvelocity = self.velocity; + for(bump = 0, t = PHYS_INPUT_TIMELENGTH; bump < 8 && (self.velocity * self.velocity) > 0; bump++) { - vector neworigin = self.origin + t * self.velocity; + neworigin = self.origin + t * self.velocity; tracebox(self.origin, self.mins, self.maxs, neworigin, MOVE_NORMAL, self); - float old_trace1_fraction = trace_fraction; - vector old_trace1_endpos = trace_endpos; - vector old_trace1_plane_normal = trace_plane_normal; - if (trace_fraction < 1 && trace_plane_normal_z == 0) + trace1_endpos = trace_endpos; + trace1_fraction = trace_fraction; + trace1_plane_normal = trace_plane_normal; + if(trace1_fraction < 1 && trace1_plane_normal_z == 0) { // may be a step or wall, try stepping up // first move forward at a higher level - vector currentorigin2 = self.origin; + currentorigin2 = self.origin; currentorigin2_z += PHYS_STEPHEIGHT; - vector neworigin2 = neworigin; - neworigin2_z = self.origin_z + PHYS_STEPHEIGHT; + neworigin2 = neworigin; + neworigin2_z += PHYS_STEPHEIGHT; tracebox(currentorigin2, self.mins, self.maxs, neworigin2, MOVE_NORMAL, self); - if (!trace_startsolid) + trace2_endpos = trace_endpos; + trace2_fraction = trace_fraction; + trace2_plane_normal = trace_plane_normal; + if(!trace_startsolid) { // then move down from there - currentorigin2 = trace_endpos; - neworigin2 = trace_endpos; + currentorigin2 = trace2_endpos; + neworigin2 = trace2_endpos; neworigin2_z = self.origin_z; - float old_trace2_fraction = trace_fraction; - vector old_trace2_plane_normal = trace_plane_normal; tracebox(currentorigin2, self.mins, self.maxs, neworigin2, MOVE_NORMAL, self); - //Con_Printf("%f %f %f %f : %f %f %f %f : %f %f %f %f\n", trace.fraction, trace.endpos[0], trace.endpos[1], trace.endpos[2], trace2.fraction, trace2.endpos[0], trace2.endpos[1], trace2.endpos[2], trace3.fraction, trace3.endpos[0], trace3.endpos[1], trace3.endpos[2]); + trace3_endpos = trace_endpos; + trace3_fraction = trace_fraction; + trace3_plane_normal = trace_plane_normal; // accept the new trace if it made some progress - if (fabs(trace_endpos_x - old_trace1_endpos_x) >= 0.03125 || fabs(trace_endpos_y - old_trace1_endpos_y) >= 0.03125) + if(fabs(trace3_endpos_x - trace1_endpos_x) >= 0.03125 || fabs(trace3_endpos_y - trace1_endpos_y) >= 0.03125) { - trace_fraction = old_trace2_fraction; - trace_endpos = trace_endpos; - trace_plane_normal = old_trace2_plane_normal; - } - else - { - trace_fraction = old_trace1_fraction; - trace_endpos = old_trace1_endpos; - trace_plane_normal = old_trace1_plane_normal; + trace1_endpos = trace2_endpos; + trace1_fraction = trace2_fraction; + trace1_plane_normal = trace2_plane_normal; + trace1_endpos = trace3_endpos; } } } // check if it moved at all - if (trace_fraction >= 0.001) - self.origin = trace_endpos; + if(trace1_fraction >= 0.001) + setorigin(self, trace1_endpos); // check if it moved all the way - if (trace_fraction == 1) + if(trace1_fraction == 1) break; // this is only really needed for nogravityonground combined with gravityunaffectedbyticrate // I'm pretty sure I commented it out solely because it seemed redundant // this got commented out in a change that supposedly makes the code match QW better - // so if this is broken, maybe put it in an if (cls.protocol != PROTOCOL_QUAKEWORLD) block - if (trace_plane_normal_z > 0.7) + // so if this is broken, maybe put it in an if(cls.protocol != PROTOCOL_QUAKEWORLD) block + if(trace1_plane_normal_z > 0.7) SET_ONGROUND(self); - t -= t * trace_fraction; + t -= t * trace1_fraction; - float f = dotproduct(self.velocity, trace_plane_normal); - self.velocity -= f * trace_plane_normal; + f = (self.velocity * trace1_plane_normal); + self.velocity = self.velocity + -f * trace1_plane_normal; } - if (pmove_waterjumptime > 0) + if(pmove_waterjumptime > 0) self.velocity = primalvelocity; -} #endif +} void CPM_PM_Aircontrol(vector wishdir, float wishspeed) { - float k; -#if 0 - // this doesn't play well with analog input - if (PHYS_INPUT_MOVEVALUES(self).x == 0 || PHYS_INPUT_MOVEVALUES(self).y != 0) - return; // can't control movement if not moving forward or backward - k = 32; -#else - k = 32 * (2 * IsMoveInDirection(PHYS_INPUT_MOVEVALUES(self), 0) - 1); + float k = 32 * (2 * IsMoveInDirection(self.movement, 0) - 1); if (k <= 0) return; -#endif - k *= bound(0, wishspeed / PHYS_MAXAIRSPEED, 1); + k *= bound(0, wishspeed / PHYS_MAXAIRSPEED(self), 1); float zspeed = self.velocity_z; self.velocity_z = 0; @@ -381,7 +415,7 @@ void CPM_PM_Aircontrol(vector wishdir, float wishspeed) if (dot > 0) // we can't change direction while slowing down { - k *= pow(dot, PHYS_AIRCONTROL_POWER)*PHYS_INPUT_TIMELENGTH; + k *= pow(dot, PHYS_AIRCONTROL_POWER) * PHYS_INPUT_TIMELENGTH; xyspeed = max(0, xyspeed - PHYS_AIRCONTROL_PENALTY * sqrt(max(0, 1 - dot*dot)) * k/32); k *= PHYS_AIRCONTROL; self.velocity = normalize(self.velocity * xyspeed + wishdir * k); @@ -505,34 +539,40 @@ void PM_AirAccelerate(vector wishdir, float wishspeed) PlayerJump When you press the jump key +returns true if handled ============= */ -void PlayerJump (void) +bool PlayerJump (void) { -#ifdef SVQC if (PHYS_FROZEN(self)) - return; // no jumping in freezetag when frozen + return true; // no jumping in freezetag when frozen +#ifdef SVQC if (self.player_blocked) - return; // no jumping while blocked + return true; // no jumping while blocked +#endif - float doublejump = FALSE; - float mjumpheight = autocvar_sv_jumpvelocity; + bool doublejump = false; + float mjumpheight = PHYS_JUMPVELOCITY; player_multijump = doublejump; player_jumpheight = mjumpheight; +#ifdef SVQC if (MUTATOR_CALLHOOK(PlayerJump)) - return; +#elif defined(CSQC) + if(PM_multijump_checkjump()) +#endif + return true; doublejump = player_multijump; mjumpheight = player_jumpheight; - if (autocvar_sv_doublejump) + if (PHYS_DOUBLEJUMP) { tracebox(self.origin + '0 0 0.01', self.mins, self.maxs, self.origin - '0 0 0.01', MOVE_NORMAL, self); if (trace_fraction < 1 && trace_plane_normal_z > 0.7) { - doublejump = TRUE; + doublejump = true; // we MUST clip velocity here! float f; @@ -544,110 +584,157 @@ void PlayerJump (void) if (self.waterlevel >= WATERLEVEL_SWIMMING) { - self.velocity_z = self.stat_sv_maxspeed * 0.7; - return; + self.velocity_z = PHYS_MAXSPEED(self) * 0.7; + return true; } if (!doublejump) - if (!(self.flags & FL_ONGROUND)) - return; + if (!IS_ONGROUND(self)) + return IS_JUMP_HELD(self); - if (self.cvar_cl_movement_track_canjump) - if (!(self.flags & FL_JUMPRELEASED)) - return; + if (PHYS_TRACK_CANJUMP(self)) + if (IS_JUMP_HELD(self)) + return true; // sv_jumpspeedcap_min/sv_jumpspeedcap_max act as baseline // velocity bounds. Final velocity is bound between (jumpheight * // min + jumpheight) and (jumpheight * max + jumpheight); - if (autocvar_sv_jumpspeedcap_min != "") + if(PHYS_JUMPSPEEDCAP_MIN) { - float minjumpspeed = mjumpheight * stof(autocvar_sv_jumpspeedcap_min); + float minjumpspeed = mjumpheight * PHYS_JUMPSPEEDCAP_MIN; if (self.velocity_z < minjumpspeed) mjumpheight += minjumpspeed - self.velocity_z; } - if (autocvar_sv_jumpspeedcap_max != "") + if(PHYS_JUMPSPEEDCAP_MAX) { // don't do jump speedcaps on ramps to preserve old xonotic ramjump style tracebox(self.origin + '0 0 0.01', self.mins, self.maxs, self.origin - '0 0 0.01', MOVE_NORMAL, self); - if (!(trace_fraction < 1 && trace_plane_normal_z < 0.98 && autocvar_sv_jumpspeedcap_max_disable_on_ramps)) + if (!(trace_fraction < 1 && trace_plane_normal_z < 0.98 && PHYS_JUMPSPEEDCAP_DISABLE_ONRAMPS)) { - float maxjumpspeed = mjumpheight * stof(autocvar_sv_jumpspeedcap_max); + float maxjumpspeed = mjumpheight * PHYS_JUMPSPEEDCAP_MAX; if (self.velocity_z > maxjumpspeed) mjumpheight -= self.velocity_z - maxjumpspeed; } } - if (!(self.lastflags & FL_ONGROUND)) + if (!WAS_ONGROUND(self)) { - if (autocvar_speedmeter) +#ifdef SVQC + if(autocvar_speedmeter) dprint(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n")); - if (self.lastground < time - 0.3) +#endif + if(self.lastground < time - 0.3) { - self.velocity_x *= (1 - autocvar_sv_friction_on_land); - self.velocity_y *= (1 - autocvar_sv_friction_on_land); + self.velocity_x *= (1 - PHYS_FRICTION_ONLAND); + self.velocity_y *= (1 - PHYS_FRICTION_ONLAND); } - if (self.jumppadcount > 1) +#ifdef SVQC + if(self.jumppadcount > 1) dprint(strcat(ftos(self.jumppadcount), "x jumppad combo\n")); self.jumppadcount = 0; +#endif } - self.oldvelocity_z = self.velocity_z += mjumpheight; + self.velocity_z += mjumpheight; + + UNSET_ONGROUND(self); + SET_JUMP_HELD(self); + +#ifdef SVQC - self.flags &= ~FL_ONGROUND; - self.flags &= ~FL_JUMPRELEASED; + self.oldvelocity_z = self.velocity_z; - animdecide_setaction(self, ANIMACTION_JUMP, TRUE); + animdecide_setaction(self, ANIMACTION_JUMP, true); if (autocvar_g_jump_grunt) PlayerSound(playersound_jump, CH_PLAYER, VOICETYPE_PLAYERSOUND); - - self.restart_jump = -1; // restart jump anim next time - // value -1 is used to not use the teleport bit (workaround for tiny hitch when re-jumping) #endif + return true; } void CheckWaterJump() { // check for a jump-out-of-water - makevectors(PHYS_INPUT_ANGLES(self)); + makevectors(self.v_angle); vector start = self.origin; start_z += 8; v_forward_z = 0; normalize(v_forward); vector end = start + v_forward*24; - traceline (start, end, TRUE, self); + traceline (start, end, true, self); if (trace_fraction < 1) { // solid at waist start_z = start_z + self.maxs_z - 8; end = start + v_forward*24; self.movedir = trace_plane_normal * -50; - traceline(start, end, TRUE, self); + traceline(start, end, true, self); if (trace_fraction == 1) { // open at eye level self.velocity_z = 225; -#ifdef SVQC self.flags |= FL_WATERJUMP; - self.flags &= ~FL_JUMPRELEASED; + SET_JUMP_HELD(self); +#ifdef SVQC self.teleport_time = time + 2; // safety net +#elif defined(CSQC) + pmove_waterjumptime = time + 2; #endif } } } + +#ifdef SVQC + #define JETPACK_JUMP(s) s.cvar_cl_jetpack_jump +#elif defined(CSQC) + float autocvar_cl_jetpack_jump; + #define JETPACK_JUMP(s) autocvar_cl_jetpack_jump +#endif +.float jetpack_stopped; +// Hack: shouldn't need to know about this +.float multijump_count; void CheckPlayerJump() { #ifdef SVQC - if (self.BUTTON_JUMP) - PlayerJump(); - else - self.flags |= FL_JUMPRELEASED; + float was_flying = ITEMS_STAT(self) & IT_USING_JETPACK; +#endif + if (JETPACK_JUMP(self) < 2) + ITEMS_STAT(self) &= ~IT_USING_JETPACK; + + if(PHYS_INPUT_BUTTON_JUMP(self) || PHYS_INPUT_BUTTON_JETPACK(self)) + { + float air_jump = !PlayerJump() || self.multijump_count > 0; // PlayerJump() has important side effects + float activate = JETPACK_JUMP(self) && air_jump && PHYS_INPUT_BUTTON_JUMP(self) || PHYS_INPUT_BUTTON_JETPACK(self); + float has_fuel = !PHYS_JETPACK_FUEL || PHYS_AMMO_FUEL(self) || ITEMS_STAT(self) & IT_UNLIMITED_WEAPON_AMMO; + if (!(ITEMS_STAT(self) & IT_JETPACK)) { } + else if (self.jetpack_stopped) { } + else if (!has_fuel) + { +#ifdef SVQC + if (was_flying) // TODO: ran out of fuel message + Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL); + else if (activate) + Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_JETPACK_NOFUEL); #endif + self.jetpack_stopped = true; + ITEMS_STAT(self) &= ~IT_USING_JETPACK; + } + else if (activate && !PHYS_FROZEN(self)) + ITEMS_STAT(self) |= IT_USING_JETPACK; + } + else + { + self.jetpack_stopped = false; + ITEMS_STAT(self) &= ~IT_USING_JETPACK; + } + if (!PHYS_INPUT_BUTTON_JUMP(self)) + UNSET_JUMP_HELD(self); + if (self.waterlevel == WATERLEVEL_SWIMMING) CheckWaterJump(); } @@ -679,8 +766,8 @@ void RaceCarPhysics() vector rigvel; vector angles_save = self.angles; - float accel = bound(-1, PHYS_INPUT_MOVEVALUES(self).x / self.stat_sv_maxspeed, 1); - float steer = bound(-1, PHYS_INPUT_MOVEVALUES(self).y / self.stat_sv_maxspeed, 1); + 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) { @@ -699,7 +786,7 @@ void RaceCarPhysics() self.angles_z = 0; makevectors(self.angles); // new forward direction! - if (self.flags & FL_ONGROUND || g_bugrigs_air_steering) + if (IS_ONGROUND(self) || g_bugrigs_air_steering) { float myspeed = self.velocity * v_forward; float upspeed = self.velocity * v_up; @@ -816,12 +903,12 @@ void RaceCarPhysics() + '0 0 1' * -(v_forward_x * trace_plane_normal_x + v_forward_y * trace_plane_normal_y) ); - self.flags |= FL_ONGROUND; + SET_ONGROUND(self); } else { // now set angles_x so that the car points forward, but is tilted in velocity direction - self.flags &= ~FL_ONGROUND; + UNSET_ONGROUND(self); } self.velocity = (neworigin - self.origin) * (1.0 / PHYS_INPUT_TIMELENGTH); @@ -890,40 +977,6 @@ void SpecialCommand() #endif } -#ifdef SVQC -float speedaward_speed; -string speedaward_holder; -string speedaward_uid; -#endif -void race_send_speedaward(float msg) -{ -#ifdef SVQC - // send the best speed of the round - WriteByte(msg, SVC_TEMPENTITY); - WriteByte(msg, TE_CSQC_RACE); - WriteByte(msg, RACE_NET_SPEED_AWARD); - WriteInt24_t(msg, floor(speedaward_speed+0.5)); - WriteString(msg, speedaward_holder); -#endif -} - -#ifdef SVQC -float speedaward_alltimebest; -string speedaward_alltimebest_holder; -string speedaward_alltimebest_uid; -#endif -void race_send_speedaward_alltimebest(float msg) -{ -#ifdef SVQC - // send the best speed - WriteByte(msg, SVC_TEMPENTITY); - WriteByte(msg, TE_CSQC_RACE); - WriteByte(msg, RACE_NET_SPEED_AWARD_BEST); - WriteInt24_t(msg, floor(speedaward_alltimebest+0.5)); - WriteString(msg, speedaward_alltimebest_holder); -#endif -} - float PM_check_keepaway(void) { #ifdef SVQC @@ -972,13 +1025,13 @@ float PM_check_specialcommand(float buttons) { self.specialcommand_pos = 0; SpecialCommand(); - return TRUE; + return true; } } else if (self.specialcommand_pos && (c != substring(specialcommand, self.specialcommand_pos - 1, 1))) self.specialcommand_pos = 0; #endif - return FALSE; + return false; } void PM_check_nickspam(void) @@ -989,15 +1042,15 @@ void PM_check_nickspam(void) if (self.nickspamcount >= autocvar_g_nick_flood_penalty_yellow) { // slight annoyance for nick change scripts - PHYS_INPUT_MOVEVALUES(self) = -1 * PHYS_INPUT_MOVEVALUES(self); + self.movement = -1 * self.movement; self.BUTTON_ATCK = self.BUTTON_JUMP = self.BUTTON_ATCK2 = self.BUTTON_ZOOM = self.BUTTON_CROUCH = self.BUTTON_HOOK = self.BUTTON_USE = 0; if (self.nickspamcount >= autocvar_g_nick_flood_penalty_red) // if you are persistent and the slight annoyance above does not stop you, I'll show you! { - PHYS_INPUT_ANGLES(self)_x = random() * 360; - PHYS_INPUT_ANGLES(self)_y = random() * 360; + self.v_angle_x = random() * 360; + self.v_angle_y = random() * 360; // at least I'm not forcing retardedview by also assigning to angles_z - self.fixangle = TRUE; + self.fixangle = true; } } #endif @@ -1031,8 +1084,10 @@ void PM_check_spider(void) #ifdef SVQC if (time >= self.spider_slowness) return; - self.stat_sv_maxspeed *= 0.5; // half speed while slow from spider - self.stat_sv_airspeedlimit_nonqw *= 0.5; + PHYS_MAXSPEED(self) *= 0.5; // half speed while slow from spider + PHYS_MAXAIRSPEED(self) *= 0.5; + PHYS_AIRSPEEDLIMIT_NONQW(self) *= 0.5; + PHYS_AIRSTRAFEACCELERATE(self) *= 0.5; #endif } @@ -1047,12 +1102,12 @@ void PM_check_frozen(void) #endif ) { - PHYS_INPUT_MOVEVALUES(self)_x = bound(-5, PHYS_INPUT_MOVEVALUES(self).x, 5); - PHYS_INPUT_MOVEVALUES(self)_y = bound(-5, PHYS_INPUT_MOVEVALUES(self).y, 5); - PHYS_INPUT_MOVEVALUES(self)_z = bound(-5, PHYS_INPUT_MOVEVALUES(self).z, 5); + self.movement_x = bound(-5, self.movement.x, 5); + self.movement_y = bound(-5, self.movement.y, 5); + self.movement_z = bound(-5, self.movement.z, 5); } else - PHYS_INPUT_MOVEVALUES(self) = '0 0 0'; + self.movement = '0 0 0'; vector midpoint = ((self.absmin + self.absmax) * 0.5); if (pointcontents(midpoint) == CONTENT_WATER) @@ -1064,12 +1119,39 @@ void PM_check_frozen(void) } } +void PM_check_hitground() +{ +#ifdef SVQC + if (IS_ONGROUND(self)) + if (IS_PLAYER(self)) // no fall sounds for observers thank you very much + if (self.wasFlying) + { + self.wasFlying = 0; + if (self.waterlevel < WATERLEVEL_SWIMMING) + if (time >= self.ladder_time) + if (!self.hook) + { + self.nextstep = time + 0.3 + random() * 0.1; + trace_dphitq3surfaceflags = 0; + tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 1', MOVE_NOMONSTERS, self); + if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOSTEPS)) + { + if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_METALSTEPS) + GlobalSound(globalsound_metalfall, CH_PLAYER, VOICETYPE_PLAYERSOUND); + else + GlobalSound(globalsound_fall, CH_PLAYER, VOICETYPE_PLAYERSOUND); + } + } + } +#endif +} + void PM_check_blocked(void) { #ifdef SVQC if (!self.player_blocked) return; - PHYS_INPUT_MOVEVALUES(self) = '0 0 0'; + self.movement = '0 0 0'; self.disableclientprediction = 1; #endif } @@ -1077,12 +1159,11 @@ void PM_check_blocked(void) #ifdef SVQC float speedaward_lastsent; float speedaward_lastupdate; -string GetMapname(void); #endif void PM_check_race(void) { #ifdef SVQC - if not(g_cts || g_race) + if(!(g_cts || g_race)) return; if (vlen(self.velocity - self.velocity_z * '0 0 1') > speedaward_speed) { @@ -1112,14 +1193,15 @@ void PM_check_race(void) void PM_check_vortex(void) { #ifdef SVQC + // WEAPONTODO float xyspeed = vlen(vec2(self.velocity)); - if (self.weapon == WEP_NEX && autocvar_g_balance_nex_charge && autocvar_g_balance_nex_charge_velocity_rate && xyspeed > autocvar_g_balance_nex_charge_minspeed) + if (self.weapon == WEP_VORTEX && WEP_CVAR(vortex, charge) && WEP_CVAR(vortex, charge_velocity_rate) && xyspeed > WEP_CVAR(vortex, charge_minspeed)) { // add a maximum of charge_velocity_rate when going fast (f = 1), gradually increasing from minspeed (f = 0) to maxspeed - xyspeed = min(xyspeed, autocvar_g_balance_nex_charge_maxspeed); - float f = (xyspeed - autocvar_g_balance_nex_charge_minspeed) / (autocvar_g_balance_nex_charge_maxspeed - autocvar_g_balance_nex_charge_minspeed); + xyspeed = min(xyspeed, WEP_CVAR(vortex, charge_maxspeed)); + float f = (xyspeed - WEP_CVAR(vortex, charge_minspeed)) / (WEP_CVAR(vortex, charge_maxspeed) - WEP_CVAR(vortex, charge_minspeed)); // add the extra charge - self.nex_charge = min(1, self.nex_charge + autocvar_g_balance_nex_charge_velocity_rate * f * PHYS_INPUT_TIMELENGTH); + self.vortex_charge = min(1, self.vortex_charge + WEP_CVAR(vortex, charge_velocity_rate) * f * PHYS_INPUT_TIMELENGTH); } #endif } @@ -1127,21 +1209,22 @@ void PM_check_vortex(void) void PM_fly(float maxspd_mod) { // noclipping or flying - self.flags &= ~FL_ONGROUND; + UNSET_ONGROUND(self); self.velocity = self.velocity * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION); - makevectors(PHYS_INPUT_ANGLES(self)); - //wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x + v_right * PHYS_INPUT_MOVEVALUES(self).y + v_up * PHYS_INPUT_MOVEVALUES(self).z; - vector wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x - + v_right * PHYS_INPUT_MOVEVALUES(self).y - + '0 0 1' * PHYS_INPUT_MOVEVALUES(self).z; + makevectors(self.v_angle); + //wishvel = v_forward * self.movement.x + v_right * self.movement.y + v_up * self.movement.z; + vector wishvel = v_forward * self.movement.x + + v_right * self.movement.y + + '0 0 1' * self.movement.z; // acceleration vector wishdir = normalize(wishvel); - float wishspeed = vlen(wishvel); - if (wishspeed > PHYS_MAXSPEED(self) * maxspd_mod) - wishspeed = PHYS_MAXSPEED(self) * maxspd_mod; + float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod); +#ifdef SVQC if (time >= self.teleport_time) +#endif PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE * maxspd_mod, 1, 0, 0, 0); + PM_ClientMovement_Move(); } void PM_swim(float maxspd_mod) @@ -1149,49 +1232,88 @@ void PM_swim(float maxspd_mod) // swimming UNSET_ONGROUND(self); - makevectors(PHYS_INPUT_ANGLES(self)); - //wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x + v_right * PHYS_INPUT_MOVEVALUES(self).y + v_up * PHYS_INPUT_MOVEVALUES(self).z; - vector wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x - + v_right * PHYS_INPUT_MOVEVALUES(self).y - + '0 0 1' * PHYS_INPUT_MOVEVALUES(self).z; + float jump = PHYS_INPUT_BUTTON_JUMP(self); + // water jump only in certain situations + // this mimics quakeworld code + if (jump && self.waterlevel == WATERLEVEL_SWIMMING && self.velocity_z >= -180) + { + vector yawangles = '0 1 0' * self.v_angle.y; + makevectors(yawangles); + vector forward = v_forward; + vector spot = self.origin + 24 * forward; + spot_z += 8; + traceline(spot, spot, MOVE_NOMONSTERS, self); + if (trace_startsolid) + { + spot_z += 24; + traceline(spot, spot, MOVE_NOMONSTERS, self); + if (!trace_startsolid) + { + self.velocity = forward * 50; + self.velocity_z = 310; + pmove_waterjumptime = 2; + UNSET_ONGROUND(self); + SET_JUMP_HELD(self); + } + } + } + makevectors(self.v_angle); + //wishvel = v_forward * self.movement.x + v_right * self.movement.y + v_up * self.movement.z; + vector wishvel = v_forward * self.movement.x + + v_right * self.movement.y + + '0 0 1' * self.movement.z; if (wishvel == '0 0 0') wishvel = '0 0 -60'; // drift towards bottom vector wishdir = normalize(wishvel); - float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod); - wishspeed = wishspeed * 0.7; + float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod) * 0.7; - // water friction - self.velocity *= (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION); + if (IS_DUCKED(self)) + wishspeed *= 0.5; -#ifdef CSQC - float addspeed = wishspeed - dotproduct(self.velocity, wishdir); - if (addspeed > 0) - { - float accelspeed = min(PHYS_ACCELERATE * PHYS_INPUT_TIMELENGTH * wishspeed, addspeed); - self.velocity += accelspeed * wishdir; - } - float g = PHYS_GRAVITY * PHYS_ENTGRAVITY(self) * PHYS_INPUT_TIMELENGTH; - if (!(GAMEPLAYFIX_NOGRAVITYONGROUND)) - self.velocity_z -= g * (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE ? 0.5 : 1); - if (self.velocity * self.velocity) - CSQC_ClientMovement_Move(); - if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE) - if (!IS_ONGROUND(self) || !(GAMEPLAYFIX_NOGRAVITYONGROUND)) - self.velocity_z -= g * 0.5; -#endif +// if (pmove_waterjumptime <= 0) // TODO: use + { + // water friction + float f = 1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION; + f = min(max(0, f), 1); + self.velocity *= f; -#ifdef SVQC + f = wishspeed - self.velocity * wishdir; + if (f > 0) + { + float accelspeed = min(PHYS_ACCELERATE * PHYS_INPUT_TIMELENGTH * wishspeed, f); + self.velocity += accelspeed * wishdir; + } + + // holding jump button swims upward slowly + if (jump) + { +#if 0 + if (self.watertype & CONTENT_LAVA) + self.velocity_z = 50; + else if (self.watertype & CONTENT_SLIME) + self.velocity_z = 80; + else + { + if (IS_NEXUIZ_DERIVED(gamemode)) +#endif + self.velocity_z = 200; +#if 0 + else + self.velocity_z = 100; + } +#endif + } + } // water acceleration PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE * maxspd_mod, 1, 0, 0, 0); -#endif + PM_ClientMovement_Move(); } void PM_ladder(float maxspd_mod) { -#ifdef SVQC // on a spawnfunc_func_ladder or swimming in spawnfunc_func_water - self.flags &= ~FL_ONGROUND; + UNSET_ONGROUND(self); float g; g = PHYS_GRAVITY * PHYS_INPUT_TIMELENGTH; @@ -1204,11 +1326,11 @@ void PM_ladder(float maxspd_mod) } self.velocity = self.velocity * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION); - makevectors(PHYS_INPUT_ANGLES(self)); - //wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x + v_right * PHYS_INPUT_MOVEVALUES(self).y + v_up * PHYS_INPUT_MOVEVALUES(self).z; - vector wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x - + v_right * PHYS_INPUT_MOVEVALUES(self).y - + '0 0 1' * PHYS_INPUT_MOVEVALUES(self).z; + makevectors(self.v_angle); + //wishvel = v_forward * self.movement.x + v_right * self.movement.y + v_up * self.movement.z; + vector wishvel = v_forward * self.movement_x + + v_right * self.movement_y + + '0 0 1' * self.movement_z; self.velocity_z += g; if (self.ladder_entity.classname == "func_water") { @@ -1232,21 +1354,23 @@ void PM_ladder(float maxspd_mod) } // acceleration vector wishdir = normalize(wishvel); - float wishspeed = min(vlen(wishvel), self.stat_sv_maxspeed * maxspd_mod); + float wishspeed = min(vlen(wishvel), PHYS_MAXSPEED(self) * maxspd_mod); +#ifdef SVQC if (time >= self.teleport_time) +#endif // water acceleration PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE*maxspd_mod, 1, 0, 0, 0); -#endif + PM_ClientMovement_Move(); } void PM_jetpack(float maxspd_mod) { - //makevectors(PHYS_INPUT_ANGLES(self).y * '0 1 0'); - makevectors(PHYS_INPUT_ANGLES(self)); - vector wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x - + v_right * PHYS_INPUT_MOVEVALUES(self).y; + //makevectors(self.v_angle.y * '0 1 0'); + makevectors(self.v_angle); + vector wishvel = v_forward * self.movement_x + + v_right * self.movement_y; // add remaining speed as Z component - float maxairspd = PHYS_MAXAIRSPEED * max(1, maxspd_mod); + float maxairspd = PHYS_MAXAIRSPEED(self) * max(1, maxspd_mod); // fix speedhacks :P wishvel = normalize(wishvel) * min(1, vlen(wishvel) / maxairspd); // add the unused velocity as up component @@ -1319,7 +1443,7 @@ void PM_jetpack(float maxspd_mod) wishvel_z = (wishvel_z - PHYS_GRAVITY) * fz + PHYS_GRAVITY; fvel = min(1, vlen(wishvel) / best); - if (PHYS_JETPACK_FUEL && !(ITEMS(self) & IT_UNLIMITED_WEAPON_AMMO)) + if (PHYS_JETPACK_FUEL && !(ITEMS_STAT(self) & IT_UNLIMITED_WEAPON_AMMO)) f = min(1, PHYS_AMMO_FUEL(self) / (PHYS_JETPACK_FUEL * PHYS_INPUT_TIMELENGTH * fvel)); else f = 1; @@ -1332,48 +1456,73 @@ void PM_jetpack(float maxspd_mod) UNSET_ONGROUND(self); #ifdef SVQC - if (!(ITEMS(self) & IT_UNLIMITED_WEAPON_AMMO)) + if (!(ITEMS_STAT(self) & IT_UNLIMITED_WEAPON_AMMO)) self.ammo_fuel -= PHYS_JETPACK_FUEL * PHYS_INPUT_TIMELENGTH * fvel * f; - - self.items |= IT_USING_JETPACK; + + ITEMS_STAT(self) |= IT_USING_JETPACK; // jetpack also inhibits health regeneration, but only for 1 second self.pauseregen_finished = max(self.pauseregen_finished, time + autocvar_g_balance_pause_fuel_regen); #endif } + +#ifdef CSQC + float g = PHYS_GRAVITY * PHYS_ENTGRAVITY(self) * PHYS_INPUT_TIMELENGTH; + if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE) + self.velocity_z -= g * 0.5; + else + self.velocity_z -= g; + PM_ClientMovement_Move(); + if (!IS_ONGROUND(self) || !(GAMEPLAYFIX_NOGRAVITYONGROUND)) + if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE) + self.velocity_z -= g * 0.5; +#endif } void PM_walk(float buttons_prev, float maxspd_mod) { -#ifdef SVQC - // we get here if we ran out of ammo - if ((ITEMS(self) & IT_JETPACK) && self.BUTTON_HOOK && !(buttons_prev & 32) && self.ammo_fuel < 0.01) - sprint(self, "You don't have any fuel for the ^2Jetpack\n"); -#endif - // walking - makevectors(PHYS_INPUT_ANGLES(self).y * '0 1 0'); - vector wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x - + v_right * PHYS_INPUT_MOVEVALUES(self).y; - -#ifdef SVQC - if (!(self.lastflags & FL_ONGROUND)) + if (!WAS_ONGROUND(self)) { +#ifdef SVQC if (autocvar_speedmeter) dprint(strcat("landing velocity: ", vtos(self.velocity), " (abs: ", ftos(vlen(self.velocity)), ")\n")); +#endif if (self.lastground < time - 0.3) - self.velocity *= (1 - autocvar_sv_friction_on_land); + self.velocity *= (1 - PHYS_FRICTION_ONLAND); +#ifdef SVQC if (self.jumppadcount > 1) dprint(strcat(ftos(self.jumppadcount), "x jumppad combo\n")); self.jumppadcount = 0; - } #endif + } + + // walking + makevectors(self.v_angle.y * '0 1 0'); + vector wishvel = v_forward * self.movement.x + + v_right * self.movement.y; + // acceleration + vector wishdir = normalize(wishvel); + float wishspeed = vlen(wishvel); - vector v = self.velocity; - v_z = 0; - float f = vlen(v); + wishspeed = min(wishspeed, PHYS_MAXSPEED(self) * maxspd_mod); + if (IS_DUCKED(self)) + wishspeed *= 0.5; + + // apply edge friction + float f = vlen(vec2(self.velocity)); if (f > 0) { - f = 1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION * ((f < PHYS_STOPSPEED) ? (PHYS_STOPSPEED / f) : 1); + float realfriction; + trace_dphitq3surfaceflags = 0; + tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 1', MOVE_NOMONSTERS, self); + // TODO: apply edge friction + // apply ground friction + if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SLICK) + realfriction = PHYS_FRICTION_SLICK; + else + realfriction = PHYS_FRICTION; + + f = 1 - PHYS_INPUT_TIMELENGTH * realfriction * ((f < PHYS_STOPSPEED) ? (PHYS_STOPSPEED / f) : 1); f = max(0, f); self.velocity *= f; /* @@ -1399,20 +1548,7 @@ void PM_walk(float buttons_prev, float maxspd_mod) v >= PHYS_STOPSPEED * (1 - PHYS_INPUT_TIMELENGTH * PHYS_FRICTION) */ } - - // acceleration - vector wishdir = normalize(wishvel); - float wishspeed = vlen(wishvel); - wishspeed = min(wishspeed, PHYS_MAXSPEED(self) * maxspd_mod); - if (IS_DUCKED(self)) - wishspeed *= 0.5; -#ifdef SVQC - if (time >= self.teleport_time) - PM_Accelerate(wishdir, wishspeed, wishspeed, PHYS_ACCELERATE * maxspd_mod, 1, 0, 0, 0); -#endif - -#ifdef CSQC - float addspeed = wishspeed - dotproduct(self.velocity, wishdir); + float addspeed = wishspeed - self.velocity * wishdir; if (addspeed > 0) { float accelspeed = min(PHYS_ACCELERATE * PHYS_INPUT_TIMELENGTH * wishspeed, addspeed); @@ -1422,45 +1558,41 @@ void PM_walk(float buttons_prev, float maxspd_mod) if (!(GAMEPLAYFIX_NOGRAVITYONGROUND)) self.velocity_z -= g * (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE ? 0.5 : 1); if (self.velocity * self.velocity) - CSQC_ClientMovement_Move(); + PM_ClientMovement_Move(); if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE) - if (!IS_ONGROUND(self) || !(GAMEPLAYFIX_NOGRAVITYONGROUND)) + if (!IS_ONGROUND(self) || !GAMEPLAYFIX_NOGRAVITYONGROUND) self.velocity_z -= g * 0.5; -#endif } void PM_air(float buttons_prev, float maxspd_mod) { -#ifdef SVQC - // we get here if we ran out of ammo - if ((ITEMS(self) & IT_JETPACK) && self.BUTTON_HOOK && !(buttons_prev & 32) && PHYS_AMMO_FUEL(self) < 0.01) - sprint(self, "You don't have any fuel for the ^2Jetpack\n"); -#endif - float maxairspd, airaccel; - maxairspd = PHYS_MAXAIRSPEED * min(maxspd_mod, 1); - airaccel = PHYS_AIRACCELERATE * min(maxspd_mod, 1); - // airborn - makevectors(PHYS_INPUT_ANGLES(self).y * '0 1 0'); - vector wishvel = v_forward * PHYS_INPUT_MOVEVALUES(self).x - + v_right * PHYS_INPUT_MOVEVALUES(self).y; + makevectors(self.v_angle.y * '0 1 0'); + vector wishvel = v_forward * self.movement.x + + v_right * self.movement.y; // acceleration vector wishdir = normalize(wishvel); float wishspeed = vlen(wishvel); - float wishspeed0 = min(wishspeed, PHYS_MAXSPEED(self) * maxspd_mod); - wishspeed = min(wishspeed, maxairspd); - if (IS_DUCKED(self)) - wishspeed *= 0.5; + #ifdef SVQC if (time >= self.teleport_time) #else if (pmove_waterjumptime <= 0) #endif { + float maxairspd = PHYS_MAXAIRSPEED(self) * min(maxspd_mod, 1); + + // apply air speed limit float airaccelqw = PHYS_AIRACCEL_QW(self); + float wishspeed0 = wishspeed; + wishspeed = min(wishspeed, maxairspd); + if (IS_DUCKED(self)) + wishspeed *= 0.5; + float airaccel = PHYS_AIRACCELERATE * min(maxspd_mod, 1); + float accelerating = (self.velocity * wishdir > 0); float wishspeed2 = wishspeed; - // CPM + // CPM: air control if (PHYS_AIRSTOPACCELERATE) { vector curdir = normalize(vec2(self.velocity)); @@ -1474,56 +1606,71 @@ void PM_air(float buttons_prev, float maxspd_mod) // dv/dt = accel * maxspeed * (1 - accelqw) (when fast) // log dv/dt = logaccel + logmaxspeed (when slow) // log dv/dt = logaccel + logmaxspeed + log(1 - accelqw) (when fast) - float strafity = IsMoveInDirection(PHYS_INPUT_MOVEVALUES(self), -90) + IsMoveInDirection(PHYS_INPUT_MOVEVALUES(self), +90); // if one is nonzero, other is always zero + float strafity = IsMoveInDirection(self.movement, -90) + IsMoveInDirection(self.movement, +90); // if one is nonzero, other is always zero if (PHYS_MAXAIRSTRAFESPEED) - wishspeed = min(wishspeed, GeomLerp(PHYS_MAXAIRSPEED*maxspd_mod, strafity, PHYS_MAXAIRSTRAFESPEED*maxspd_mod)); - if (PHYS_AIRSTRAFEACCELERATE) - airaccel = GeomLerp(airaccel, strafity, PHYS_AIRSTRAFEACCELERATE*maxspd_mod); + wishspeed = min(wishspeed, GeomLerp(PHYS_MAXAIRSPEED(self)*maxspd_mod, strafity, PHYS_MAXAIRSTRAFESPEED*maxspd_mod)); + if (PHYS_AIRSTRAFEACCELERATE(self)) + airaccel = GeomLerp(airaccel, strafity, PHYS_AIRSTRAFEACCELERATE(self)*maxspd_mod); if (PHYS_AIRSTRAFEACCEL_QW(self)) - airaccelqw = copysign(1-GeomLerp(1-fabs(PHYS_AIRACCEL_QW(self)), strafity, 1-fabs(PHYS_AIRSTRAFEACCEL_QW(self))), ((strafity > 0.5) ? PHYS_AIRSTRAFEACCEL_QW(self) : PHYS_AIRACCEL_QW(self))); + airaccelqw = + (((strafity > 0.5 ? PHYS_AIRSTRAFEACCEL_QW(self) : PHYS_AIRACCEL_QW(self)) >= 0) ? +1 : -1) + * + (1 - GeomLerp(1 - fabs(PHYS_AIRACCEL_QW(self)), strafity, 1 - fabs(PHYS_AIRSTRAFEACCEL_QW(self)))); // !CPM - if (PHYS_WARSOWBUNNY_TURNACCEL && accelerating && PHYS_INPUT_MOVEVALUES(self).y == 0 && PHYS_INPUT_MOVEVALUES(self).x != 0) - PM_AirAccelerate(wishdir, wishspeed); + if (PHYS_WARSOWBUNNY_TURNACCEL && accelerating && self.movement.y == 0 && self.movement.x != 0) + PM_AirAccelerate(wishdir, wishspeed2); else PM_Accelerate(wishdir, wishspeed, wishspeed0, airaccel, airaccelqw, PHYS_AIRACCEL_QW_STRETCHFACTOR(self), PHYS_AIRACCEL_SIDEWAYS_FRICTION / maxairspd, PHYS_AIRSPEEDLIMIT_NONQW(self)); if (PHYS_AIRCONTROL) CPM_PM_Aircontrol(wishdir, wishspeed2); } -#ifdef CSQC float g = PHYS_GRAVITY * PHYS_ENTGRAVITY(self) * PHYS_INPUT_TIMELENGTH; if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE) self.velocity_z -= g * 0.5; else self.velocity_z -= g; - CSQC_ClientMovement_Move(); + PM_ClientMovement_Move(); if (!IS_ONGROUND(self) || !(GAMEPLAYFIX_NOGRAVITYONGROUND)) if (GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE) self.velocity_z -= g * 0.5; -#endif } // used for calculating airshots -float PM_is_flying() +bool IsFlying(entity a) { - if (IS_ONGROUND(self)) - return 0; - if (self.waterlevel >= WATERLEVEL_SWIMMING) - return 0; - traceline(self.origin, self.origin - '0 0 48', MOVE_NORMAL, self); - return trace_fraction >= 1; + if(IS_ONGROUND(a)) + return false; + if(a.waterlevel >= WATERLEVEL_SWIMMING) + return false; + traceline(a.origin, a.origin - '0 0 48', MOVE_NORMAL, a); + if(trace_fraction < 1) + return false; + return true; } void PM_Main() { + int buttons = PHYS_INPUT_BUTTON_MASK(self); #ifdef CSQC - //Con_Printf(" %f", PHYS_INPUT_TIMELENGTH); - if (!(PHYS_INPUT_BUTTONS(self) & 2)) // !jump + self.items = getstati(STAT_ITEMS, 0, 24); + + self.movement = PHYS_INPUT_MOVEVALUES(self); + + vector oldv_angle = self.v_angle; + vector oldangles = self.angles; // we need to save these, as they're abused by other code + self.v_angle = PHYS_INPUT_ANGLES(self); + self.angles = PHYS_WORLD_ANGLES(self); + + self.team = myteam + 1; // is this correct? + if (!(PHYS_INPUT_BUTTON_JUMP(self))) // !jump UNSET_JUMP_HELD(self); // canjump = true pmove_waterjumptime -= PHYS_INPUT_TIMELENGTH; - CSQC_ClientMovement_UpdateStatus(); + + PM_ClientMovement_UpdateStatus(true); #endif + #ifdef SVQC WarpZone_PlayerPhysics_FixVAngle(); @@ -1532,26 +1679,9 @@ void PM_Main() maxspeed_mod *= PM_check_keepaway(); maxspeed_mod *= PHYS_HIGHSPEED; - // fix physics stats for g_movement_highspeed - // TODO maybe rather use maxairspeed? needs testing -#ifdef SVQC - self.stat_sv_airaccel_qw = AdjustAirAccelQW(autocvar_sv_airaccel_qw, maxspeed_mod); - if (autocvar_sv_airstrafeaccel_qw) - self.stat_sv_airstrafeaccel_qw = AdjustAirAccelQW(autocvar_sv_airstrafeaccel_qw, maxspeed_mod); - else - self.stat_sv_airstrafeaccel_qw = 0; - self.stat_sv_airspeedlimit_nonqw = autocvar_sv_airspeedlimit_nonqw * maxspeed_mod; - self.stat_sv_maxspeed = autocvar_sv_maxspeed * maxspeed_mod; // also slow walking - self.stat_movement_highspeed = autocvar_g_movement_highspeed; // TODO: remove this! - - self.stat_jetpack_antigravity = autocvar_g_jetpack_antigravity; - self.stat_jetpack_accel_up = autocvar_g_jetpack_acceleration_up; - self.stat_jetpack_accel_side = autocvar_g_jetpack_acceleration_side; - self.stat_jetpack_maxspeed_side = autocvar_g_jetpack_maxspeed_side; - self.stat_jetpack_maxspeed_up = autocvar_g_jetpack_maxspeed_up; - self.stat_jetpack_fuel = autocvar_g_jetpack_fuel; -#endif #ifdef SVQC + Physics_UpdateStats(maxspeed_mod); + if (self.PlayerPhysplug) if (self.PlayerPhysplug()) return; @@ -1561,21 +1691,20 @@ void PM_Main() #ifdef SVQC anticheat_physics(); #endif - float buttons = PHYS_INPUT_BUTTONS(self); if (PM_check_specialcommand(buttons)) return; #ifdef SVQC if (sv_maxidle > 0) { - if (buttons != self.buttons_old || PHYS_INPUT_MOVEVALUES(self) != self.movement_old || PHYS_INPUT_ANGLES(self) != self.v_angle_old) + if (buttons != self.buttons_old || self.movement != self.movement_old || self.v_angle != self.v_angle_old) self.parm_idlesince = time; } #endif - float buttons_prev = self.buttons_old; + int buttons_prev = self.buttons_old; self.buttons_old = buttons; - self.movement_old = PHYS_INPUT_MOVEVALUES(self); - self.v_angle_old = PHYS_INPUT_ANGLES(self); + self.movement_old = self.movement; + self.v_angle_old = self.v_angle; PM_check_nickspam(); @@ -1588,8 +1717,6 @@ void PM_Main() bot_think(); } - self.items &= ~IT_USING_JETPACK; - if (IS_PLAYER(self)) #endif { @@ -1599,15 +1726,14 @@ void PM_Main() self.race_penalty = 0; #endif - float not_allowed_to_move = 0; + bool not_allowed_to_move = false; #ifdef SVQC if (self.race_penalty) - not_allowed_to_move = 1; + not_allowed_to_move = true; #endif #ifdef SVQC - if (!autocvar_sv_ready_restart_after_countdown) - if (time < game_starttime) - not_allowed_to_move = 1; + if (time < game_starttime) + not_allowed_to_move = true; #endif if (not_allowed_to_move) @@ -1631,43 +1757,47 @@ void PM_Main() #ifdef SVQC if (self.movetype == MOVETYPE_NONE) return; -#endif -#ifdef SVQC // when we get here, disableclientprediction cannot be 2 self.disableclientprediction = 0; - if (time < self.ladder_time) - self.disableclientprediction = 1; #endif PM_check_spider(); PM_check_frozen(); -#ifdef SVQC - MUTATOR_CALLHOOK(PlayerPhysics); -#endif - PM_check_blocked(); maxspeed_mod = 1; -#ifdef SVQC - if (self.in_swamp) { + if (self.in_swamp) maxspeed_mod *= self.swamp_slowdown; //cvar("g_balance_swamp_moverate"); - } -#endif -#ifdef SVQC // conveyors: first fix velocity if (self.conveyor.state) self.velocity -= self.conveyor.movedir; + +#ifdef SVQC + MUTATOR_CALLHOOK(PlayerPhysics); #endif +#ifdef CSQC + PM_multijump(); +#endif + +// float forcedodge = 1; +// if(forcedodge) { +//#ifdef CSQC +// PM_dodging_checkpressedkeys(); +//#endif +// PM_dodging(); +// PM_ClientMovement_Move(); +// return; +// } #ifdef SVQC if (!IS_PLAYER(self)) { - maxspeed_mod *= autocvar_sv_spectator_speed_multiplier; + maxspeed_mod = autocvar_sv_spectator_speed_multiplier; if (!self.spectatorspeed) self.spectatorspeed = maxspeed_mod; if (self.impulse && self.impulse <= 19 || (self.impulse >= 200 && self.impulse <= 209) || (self.impulse >= 220 && self.impulse <= 229)) @@ -1685,62 +1815,56 @@ void PM_Main() } // otherwise just clear self.impulse = 0; } - maxspeed_mod *= self.spectatorspeed; + maxspeed_mod = self.spectatorspeed; } -#endif - -#ifdef SVQC - // if dead, behave differently - // in CSQC, physics don't handle dead player - if (self.deadflag) - goto end; -#endif -#ifdef SVQC - if (!self.fixangle && !g_bugrigs) - self.angles = '0 1 0' * PHYS_INPUT_ANGLES(self).y; + float spd = max(PHYS_MAXSPEED(self), PHYS_MAXAIRSPEED(self)) * maxspeed_mod; + if(self.speed != spd) + { + self.speed = spd; + string temps = ftos(spd); + stuffcmd(self, strcat("cl_forwardspeed ", temps, "\n")); + stuffcmd(self, strcat("cl_backspeed ", temps, "\n")); + stuffcmd(self, strcat("cl_sidespeed ", temps, "\n")); + stuffcmd(self, strcat("cl_upspeed ", temps, "\n")); + } #endif -#ifdef SVQC - if (self.flags & FL_ONGROUND) - if (IS_PLAYER(self)) // no fall sounds for observers thank you very much - if (self.wasFlying) + if(PHYS_DEAD(self)) { - self.wasFlying = 0; - if (self.waterlevel < WATERLEVEL_SWIMMING) - if (time >= self.ladder_time) - if (!self.hook) + // handle water here + vector midpoint = ((self.absmin + self.absmax) * 0.5); + if(pointcontents(midpoint) == CONTENT_WATER) { - self.nextstep = time + 0.3 + random() * 0.1; - trace_dphitq3surfaceflags = 0; - tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 1', MOVE_NOMONSTERS, self); - if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOSTEPS)) - { - if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_METALSTEPS) - GlobalSound(globalsound_metalfall, CH_PLAYER, VOICETYPE_PLAYERSOUND); - else - GlobalSound(globalsound_fall, CH_PLAYER, VOICETYPE_PLAYERSOUND); - } + self.velocity = self.velocity * 0.5; + + // do we want this? + //if(pointcontents(midpoint + '0 0 2') == CONTENT_WATER) + //{ self.velocity_z = 70; } } + goto end; } + +#ifdef SVQC + if (!self.fixangle && !g_bugrigs) + self.angles = '0 1 0' * self.v_angle.y; #endif - if (PM_is_flying()) + PM_check_hitground(); + + if(IsFlying(self)) self.wasFlying = 1; -#ifdef SVQC if (IS_PLAYER(self)) -#endif CheckPlayerJump(); - - if (self.flags & /* FL_WATERJUMP */ 2048) + if (self.flags & FL_WATERJUMP) { self.velocity_x = self.movedir_x; self.velocity_y = self.movedir_y; if (time > self.teleport_time || self.waterlevel == WATERLEVEL_NONE) { - self.flags &= ~/* FL_WATERJUMP */ 2048; + self.flags &= ~FL_WATERJUMP; self.teleport_time = 0; } } @@ -1750,7 +1874,7 @@ void PM_Main() RaceCarPhysics(); #endif - else if (self.movetype == MOVETYPE_NOCLIP || self.movetype == MOVETYPE_FLY || self.movetype == MOVETYPE_FLY_WORLDONLY) + else if (self.movetype == MOVETYPE_NOCLIP || self.movetype == MOVETYPE_FLY || self.movetype == MOVETYPE_FLY_WORLDONLY || (BUFFS(self) & BUFF_FLIGHT)) PM_fly(maxspeed_mod); else if (self.waterlevel >= WATERLEVEL_SWIMMING) @@ -1759,31 +1883,14 @@ void PM_Main() else if (time < self.ladder_time) PM_ladder(maxspeed_mod); - else if ((ITEMS(self) & IT_JETPACK) && PHYS_BUTTON_HOOK(self) && (!PHYS_JETPACK_FUEL || PHYS_AMMO_FUEL(self) >= 0.01 || (ITEMS(self) & IT_UNLIMITED_WEAPON_AMMO)) && !PHYS_FROZEN(self)) + else if (ITEMS_STAT(self) & IT_USING_JETPACK) PM_jetpack(maxspeed_mod); + else if (IS_ONGROUND(self)) + PM_walk(buttons_prev, maxspeed_mod); + else - { -#ifdef CSQC - // jump if on ground with jump button pressed but only if it has been - // released at least once since the last jump - if (PHYS_INPUT_BUTTONS(self) & 2) - { - if (IS_ONGROUND(self) && (!IS_JUMP_HELD(self) || !cvar("cl_movement_track_canjump"))) - { - self.velocity_z += PHYS_JUMPVELOCITY; - UNSET_ONGROUND(self); - SET_JUMP_HELD(self); // canjump = false - } - } - else - UNSET_JUMP_HELD(self); // canjump = true -#endif - if (IS_ONGROUND(self)) - PM_walk(buttons_prev, maxspeed_mod); - else - PM_air(buttons_prev, maxspeed_mod); - } + PM_air(buttons_prev, maxspeed_mod); #ifdef SVQC if (!IS_OBSERVER(self)) @@ -1792,94 +1899,35 @@ void PM_Main() PM_check_vortex(); :end - if (self.flags & FL_ONGROUND) + if (IS_ONGROUND(self)) self.lastground = time; -#ifdef SVQC // conveyors: then break velocity again - if (self.conveyor.state) + if(self.conveyor.state) self.velocity += self.conveyor.movedir; -#endif self.lastflags = self.flags; + self.lastclassname = self.classname; -} -void CSQC_ClientMovement_PlayerMove_Frame() -{ - // if a move is more than 50ms, do it as two moves (matching qwsv) - //Con_Printf("%i ", self.cmd.msec); - if (PHYS_INPUT_TIMELENGTH > 0.0005) - { - if (PHYS_INPUT_TIMELENGTH > 0.05) - { - PHYS_INPUT_TIMELENGTH /= 2; - PM_Main(); - } - PM_Main(); - } - else - // we REALLY need this handling to happen, even if the move is not executed - if (!(PHYS_INPUT_BUTTONS(self) & 2)) // !jump - UNSET_JUMP_HELD(self); // canjump = true +#ifdef CSQC + self.v_angle = oldv_angle; + self.angles = oldangles; +#endif } -#undef PHYS_INPUT_ANGLES -#undef PHYS_INPUT_BUTTONS - -#undef PHYS_INPUT_TIMELENGTH - -#undef PHYS_INPUT_MOVEVALUES - -#undef GAMEPLAYFIX_GRAVITYUNAFFECTEDBYTICRATE -#undef GAMEPLAYFIX_NOGRAVITYONGROUND -#undef GAMEPLAYFIX_Q2AIRACCELERATE - -#undef IS_DUCKED -#undef SET_DUCKED -#undef UNSET_DUCKED - -#undef IS_JUMP_HELD -#undef SET_JUMP_HELD -#undef UNSET_JUMP_HELD - -#undef IS_ONGROUND -#undef SET_ONGROUND -#undef UNSET_ONGROUND - -#undef PHYS_ACCELERATE -#undef PHYS_AIRACCEL_QW -#undef PHYS_AIRACCEL_QW_STRETCHFACTOR -#undef PHYS_AIRACCEL_SIDEWAYS_FRICTION -#undef PHYS_AIRACCELERATE -#undef PHYS_AIRCONTROL -#undef PHYS_AIRCONTROL_PENALTY -#undef PHYS_AIRCONTROL_POWER -#undef PHYS_AIRSPEEDLIMIT_NONQW -#undef PHYS_AIRSTOPACCELERATE -#undef PHYS_AIRSTRAFEACCEL_QW -#undef PHYS_AIRSTRAFEACCELERATE -#undef PHYS_EDGEFRICTION -#undef PHYS_ENTGRAVITY -#undef PHYS_FRICTION -#undef PHYS_GRAVITY -#undef PHYS_HIGHSPEED -#undef PHYS_JUMPVELOCITY -#undef PHYS_MAXAIRSPEED -#undef PHYS_MAXAIRSTRAFESPEED -#undef PHYS_MAXSPEED -#undef PHYS_STEPHEIGHT -#undef PHYS_STOPSPEED -#undef PHYS_WARSOWBUNNY_ACCEL -#undef PHYS_WARSOWBUNNY_BACKTOSIDERATIO -#undef PHYS_WARSOWBUNNY_AIRFORWARDACCEL -#undef PHYS_WARSOWBUNNY_TOPSPEED -#undef PHYS_WARSOWBUNNY_TURNACCEL - #ifdef SVQC -// Entry point void SV_PlayerPhysics(void) +#elif defined(CSQC) +void CSQC_ClientMovement_PlayerMove_Frame(void) +#endif { PM_Main(); + +#ifdef CSQC + self.pmove_flags = + ((self.flags & FL_DUCKED) ? PMF_DUCKED : 0) | + (!(self.flags & FL_JUMPRELEASED) ? 0 : PMF_JUMP_HELD) | + ((self.flags & FL_ONGROUND) ? PMF_ONGROUND : 0); +#endif } -#endif \ No newline at end of file