1405 lines
38 KiB
C++
1405 lines
38 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
//========= Copyright © 1996-2001, Valve LLC, All rights reserved. ============
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
#include "cbase.h"
|
|
#include "gamemovement.h"
|
|
#include "dod_gamerules.h"
|
|
#include "dod_shareddefs.h"
|
|
#include "in_buttons.h"
|
|
#include "movevars_shared.h"
|
|
|
|
#include "weapon_dodsniper.h"
|
|
#include "weapon_dodbaserpg.h"
|
|
#include "weapon_dodsemiauto.h"
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
#include "c_dod_player.h"
|
|
#else
|
|
#include "dod_player.h"
|
|
#endif
|
|
|
|
extern bool g_bMovementOptimizations;
|
|
|
|
class CDODGameMovement : public CGameMovement
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CDODGameMovement, CGameMovement );
|
|
|
|
CDODGameMovement();
|
|
virtual ~CDODGameMovement();
|
|
|
|
void SetPlayerSpeed( void );
|
|
|
|
virtual void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove );
|
|
virtual bool CanAccelerate();
|
|
virtual bool CheckJumpButton( void );
|
|
virtual void ReduceTimers( void );
|
|
virtual void WalkMove( void );
|
|
virtual void AirMove( void );
|
|
virtual void CheckParameters( void );
|
|
virtual void CheckFalling( void );
|
|
|
|
// Ducking
|
|
virtual void Duck( void );
|
|
virtual void FinishUnDuck( void );
|
|
virtual void FinishDuck( void );
|
|
virtual void HandleDuckingSpeedCrop();
|
|
void SetDODDuckedEyeOffset( float duckFraction );
|
|
void SetDeployedEyeOffset( void );
|
|
|
|
// Prone
|
|
void SetProneEyeOffset( float proneFraction );
|
|
void FinishProne( void );
|
|
void FinishUnProne( void );
|
|
bool CanUnprone();
|
|
|
|
virtual Vector GetPlayerMins( void ) const; // uses local player
|
|
virtual Vector GetPlayerMaxs( void ) const; // uses local player
|
|
|
|
// IGameMovement interface
|
|
virtual Vector GetPlayerMins( bool ducked ) const { return BaseClass::GetPlayerMins(ducked); }
|
|
virtual Vector GetPlayerMaxs( bool ducked ) const { return BaseClass::GetPlayerMaxs(ducked); }
|
|
virtual Vector GetPlayerViewOffset( bool ducked ) const { return BaseClass::GetPlayerViewOffset(ducked); }
|
|
|
|
void ViewOffsetAnimation( Vector vecDest, float flTime, ViewAnimationType type );
|
|
|
|
void SetViewOffset( Vector vecViewOffset );
|
|
|
|
virtual unsigned int PlayerSolidMask( bool brushOnly = false );
|
|
|
|
protected:
|
|
virtual void PlayerMove();
|
|
|
|
void CheckForLadders( bool wasOnGround );
|
|
bool ResolveStanding( void );
|
|
void TracePlayerBBoxWithStep( const Vector &vStart, const Vector &vEnd, unsigned int fMask, int collisionGroup, trace_t &trace );
|
|
|
|
public:
|
|
CDODPlayer *m_pDODPlayer;
|
|
bool m_bUnProneToDuck;
|
|
};
|
|
|
|
|
|
// Expose our interface.
|
|
static CDODGameMovement g_GameMovement;
|
|
IGameMovement *g_pGameMovement = ( IGameMovement * )&g_GameMovement;
|
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CGameMovement, IGameMovement,INTERFACENAME_GAMEMOVEMENT, g_GameMovement );
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------- //
|
|
// CDODGameMovement.
|
|
// ---------------------------------------------------------------------------------------- //
|
|
|
|
CDODGameMovement::CDODGameMovement()
|
|
{
|
|
// Don't set any member variables here, or you'll get an access
|
|
// violation exception on LoadLibrary, and will have to stay up til
|
|
// 3 in the morning figuring out where you did bad things.
|
|
|
|
m_bUnProneToDuck = false;
|
|
}
|
|
|
|
CDODGameMovement::~CDODGameMovement()
|
|
{
|
|
}
|
|
|
|
void CDODGameMovement::SetPlayerSpeed( void )
|
|
{
|
|
if( DODGameRules()->State_Get() == STATE_PREROUND )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_FROZEN;
|
|
return;
|
|
}
|
|
|
|
if ( m_pDODPlayer->m_Shared.IsPlanting() ||
|
|
m_pDODPlayer->m_Shared.IsDefusing() )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_FROZEN;
|
|
return;
|
|
}
|
|
|
|
bool bZoomed = ( m_pDODPlayer->GetFOV() < m_pDODPlayer->GetDefaultFOV() );
|
|
bool bBazookaDeployed = false;
|
|
bool bZoomingIn = false;
|
|
|
|
CWeaponDODBase *pWpn = m_pDODPlayer->GetActiveDODWeapon();
|
|
if( pWpn )
|
|
{
|
|
if( pWpn->GetDODWpnData().m_WeaponType == WPN_TYPE_BAZOOKA )
|
|
{
|
|
CDODBaseRocketWeapon *pBazooka = (CDODBaseRocketWeapon *)pWpn;
|
|
bBazookaDeployed = pBazooka->ShouldPlayerBeSlow();
|
|
}
|
|
|
|
if ( pWpn->GetDODWpnData().m_WeaponType == WPN_TYPE_SNIPER )
|
|
{
|
|
CDODSniperWeapon *pSniper = dynamic_cast<CDODSniperWeapon *>( pWpn );
|
|
if ( pSniper )
|
|
{
|
|
bZoomingIn = !bZoomed && pSniper->IsZoomingIn();
|
|
}
|
|
}
|
|
}
|
|
|
|
// are we zooming?
|
|
|
|
if ( m_pDODPlayer->m_Shared.IsInMGDeploy() )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_FROZEN;
|
|
}
|
|
else if ( m_pDODPlayer->m_Shared.IsProne() &&
|
|
!m_pDODPlayer->m_Shared.IsGettingUpFromProne() &&
|
|
m_pDODPlayer->GetGroundEntity() != NULL )
|
|
{
|
|
if ( bZoomed )
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_PRONE_ZOOMED;
|
|
else if ( bBazookaDeployed )
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_PRONE_BAZOOKA_DEPLOYED;
|
|
else
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_PRONE; //Base prone speed
|
|
}
|
|
else //not prone, dead or deployed - standing or crouching and possibly moving
|
|
{
|
|
float stamina = m_pDODPlayer->m_Shared.GetStamina();
|
|
|
|
if ( bZoomed )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_ZOOMED;
|
|
}
|
|
else if ( bBazookaDeployed )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_BAZOOKA_DEPLOYED;
|
|
}
|
|
else if ( mv->m_nButtons & IN_DUCK )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_RUN; //gets cut in fraction later
|
|
}
|
|
// check for slowed from leg hit or firing a machine gun
|
|
else if ( m_pDODPlayer->m_Shared.GetSlowedTime() > gpGlobals->curtime )
|
|
{
|
|
mv->m_flClientMaxSpeed = PLAYER_SPEED_SLOWED;
|
|
}
|
|
else
|
|
{
|
|
float flMaxSpeed;
|
|
|
|
if ( ( mv->m_nButtons & IN_SPEED ) && ( stamina > 0 ) && ( mv->m_nButtons & IN_FORWARD ) && !bZoomingIn )
|
|
{
|
|
flMaxSpeed = PLAYER_SPEED_SPRINT; //sprinting
|
|
}
|
|
else
|
|
{
|
|
flMaxSpeed = PLAYER_SPEED_RUN; //jogging
|
|
}
|
|
|
|
mv->m_flClientMaxSpeed = flMaxSpeed - 100 + stamina;
|
|
}
|
|
}
|
|
|
|
if ( m_pDODPlayer->GetGroundEntity() != NULL )
|
|
{
|
|
if( m_pDODPlayer->m_Shared.IsGoingProne() )
|
|
{
|
|
float pronetime = m_pDODPlayer->m_Shared.m_flGoProneTime - gpGlobals->curtime;
|
|
|
|
//interp to prone speed
|
|
float flProneFraction = SimpleSpline( pronetime / TIME_TO_PRONE );
|
|
|
|
float maxSpeed = mv->m_flClientMaxSpeed;
|
|
|
|
if ( m_bUnProneToDuck )
|
|
maxSpeed *= 0.33;
|
|
|
|
mv->m_flClientMaxSpeed = ( ( 1 - flProneFraction ) * PLAYER_SPEED_PRONE ) + ( flProneFraction * maxSpeed );
|
|
}
|
|
else if( m_pDODPlayer->m_Shared.IsGettingUpFromProne() )
|
|
{
|
|
float pronetime = m_pDODPlayer->m_Shared.m_flUnProneTime - gpGlobals->curtime;
|
|
|
|
//interp to regular speed speed
|
|
float flProneFraction = SimpleSpline( pronetime / TIME_TO_PRONE );
|
|
|
|
float maxSpeed = mv->m_flClientMaxSpeed;
|
|
|
|
if ( m_bUnProneToDuck )
|
|
maxSpeed *= 0.33;
|
|
|
|
mv->m_flClientMaxSpeed = ( flProneFraction * PLAYER_SPEED_PRONE ) + ( ( 1 - flProneFraction ) * maxSpeed );
|
|
}
|
|
}
|
|
}
|
|
|
|
ConVar cl_show_speed( "cl_show_speed", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "spam console with local player speed" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::CheckParameters( void )
|
|
{
|
|
QAngle v_angle;
|
|
|
|
SetPlayerSpeed();
|
|
|
|
if ( player->GetMoveType() != MOVETYPE_ISOMETRIC &&
|
|
player->GetMoveType() != MOVETYPE_NOCLIP &&
|
|
player->GetMoveType() != MOVETYPE_OBSERVER )
|
|
{
|
|
float spd;
|
|
float maxspeed;
|
|
|
|
spd = ( mv->m_flForwardMove * mv->m_flForwardMove ) +
|
|
( mv->m_flSideMove * mv->m_flSideMove ) +
|
|
( mv->m_flUpMove * mv->m_flUpMove );
|
|
|
|
maxspeed = mv->m_flClientMaxSpeed;
|
|
if ( maxspeed != 0.0 )
|
|
{
|
|
mv->m_flMaxSpeed = MIN( maxspeed, mv->m_flMaxSpeed );
|
|
}
|
|
|
|
// Slow down by the speed factor
|
|
float flSpeedFactor = 1.0f;
|
|
if ( player->GetSurfaceData() )
|
|
{
|
|
flSpeedFactor = player->GetSurfaceData()->game.maxSpeedFactor;
|
|
}
|
|
|
|
// If we have a constraint, slow down because of that too.
|
|
float flConstraintSpeedFactor = ComputeConstraintSpeedFactor();
|
|
if (flConstraintSpeedFactor < flSpeedFactor)
|
|
flSpeedFactor = flConstraintSpeedFactor;
|
|
|
|
mv->m_flMaxSpeed *= flSpeedFactor;
|
|
|
|
if ( g_bMovementOptimizations )
|
|
{
|
|
// Same thing but only do the sqrt if we have to.
|
|
if ( ( spd != 0.0 ) && ( spd > mv->m_flMaxSpeed*mv->m_flMaxSpeed ) )
|
|
{
|
|
float fRatio = mv->m_flMaxSpeed / sqrt( spd );
|
|
mv->m_flForwardMove *= fRatio;
|
|
mv->m_flSideMove *= fRatio;
|
|
mv->m_flUpMove *= fRatio;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
spd = sqrt( spd );
|
|
if ( ( spd != 0.0 ) && ( spd > mv->m_flMaxSpeed ) )
|
|
{
|
|
float fRatio = mv->m_flMaxSpeed / spd;
|
|
mv->m_flForwardMove *= fRatio;
|
|
mv->m_flSideMove *= fRatio;
|
|
mv->m_flUpMove *= fRatio;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if ( player->GetFlags() & FL_FROZEN ||
|
|
player->GetFlags() & FL_ONTRAIN ||
|
|
IsDead() )
|
|
{
|
|
mv->m_flForwardMove = 0;
|
|
mv->m_flSideMove = 0;
|
|
mv->m_flUpMove = 0;
|
|
}
|
|
|
|
DecayPunchAngle();
|
|
|
|
// Take angles from command.
|
|
if ( !IsDead() )
|
|
{
|
|
v_angle = mv->m_vecAngles;
|
|
v_angle = v_angle + player->m_Local.m_vecPunchAngle;
|
|
|
|
// Now adjust roll angle
|
|
if ( player->GetMoveType() != MOVETYPE_ISOMETRIC &&
|
|
player->GetMoveType() != MOVETYPE_NOCLIP )
|
|
{
|
|
mv->m_vecAngles[ROLL] = CalcRoll( v_angle, mv->m_vecVelocity, sv_rollangle.GetFloat(), sv_rollspeed.GetFloat() );
|
|
}
|
|
else
|
|
{
|
|
mv->m_vecAngles[ROLL] = 0.0; // v_angle[ ROLL ];
|
|
}
|
|
mv->m_vecAngles[PITCH] = v_angle[PITCH];
|
|
mv->m_vecAngles[YAW] = v_angle[YAW];
|
|
}
|
|
else
|
|
{
|
|
mv->m_vecAngles = mv->m_vecOldAngles;
|
|
}
|
|
|
|
// Set dead player view_offset
|
|
if ( IsDead() )
|
|
{
|
|
SetViewOffset( VEC_DEAD_VIEWHEIGHT_SCALED( player ) );
|
|
}
|
|
|
|
// Adjust client view angles to match values used on server.
|
|
if ( mv->m_vecAngles[YAW] > 180.0f )
|
|
{
|
|
mv->m_vecAngles[YAW] -= 360.0f;
|
|
}
|
|
|
|
if ( cl_show_speed.GetBool() )
|
|
{
|
|
Vector vel = m_pDODPlayer->GetAbsVelocity();
|
|
float actual_speed = sqrt( vel.x * vel.x + vel.y * vel.y );
|
|
Msg( "player speed %.1f\n",actual_speed );
|
|
}
|
|
}
|
|
|
|
void CDODGameMovement::CheckFalling( void )
|
|
{
|
|
// if we landed on the ground
|
|
if ( player->GetGroundEntity() != NULL && !IsDead() )
|
|
{
|
|
if ( player->m_Local.m_flFallVelocity >= 300 )
|
|
{
|
|
CPASFilter filter( player->GetAbsOrigin() );
|
|
filter.UsePredictionRules();
|
|
player->EmitSound( filter, player->entindex(), "Player.JumpLanding" );
|
|
}
|
|
|
|
// turn off the jumping flag if we're on ground after a jump
|
|
if ( m_pDODPlayer->m_Shared.IsJumping() )
|
|
{
|
|
m_pDODPlayer->m_Shared.SetJumping( false );
|
|
|
|
// if we landed from a jump, slow us
|
|
if ( player->m_Local.m_flFallVelocity > 50 )
|
|
m_pDODPlayer->m_Shared.SetSlowedTime( 0.5 );
|
|
}
|
|
}
|
|
|
|
BaseClass::CheckFalling();
|
|
}
|
|
|
|
|
|
void CDODGameMovement::ProcessMovement( CBasePlayer *pBasePlayer, CMoveData *pMove )
|
|
{
|
|
//Store the player pointer
|
|
m_pDODPlayer = ToDODPlayer( pBasePlayer );
|
|
Assert( m_pDODPlayer );
|
|
|
|
m_pDODPlayer->m_Shared.ViewAnimThink();
|
|
|
|
BaseClass::ProcessMovement( pBasePlayer, pMove );
|
|
}
|
|
|
|
bool CDODGameMovement::CanAccelerate()
|
|
{
|
|
// Only allow the player to accelerate when in certain states.
|
|
DODPlayerState curState = m_pDODPlayer->State_Get();
|
|
if ( curState == STATE_ACTIVE )
|
|
{
|
|
return player->GetWaterJumpTime() == 0;
|
|
}
|
|
else if ( player->IsObserver() )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void CDODGameMovement::PlayerMove()
|
|
{
|
|
BaseClass::PlayerMove();
|
|
|
|
if ( player->GetMoveType() != MOVETYPE_ISOMETRIC &&
|
|
player->GetMoveType() != MOVETYPE_NOCLIP &&
|
|
player->GetMoveType() != MOVETYPE_OBSERVER )
|
|
{
|
|
|
|
// Cap actual player speed, fix wall running
|
|
float spd = mv->m_vecVelocity[0] * mv->m_vecVelocity[0] +
|
|
mv->m_vecVelocity[1] * mv->m_vecVelocity[1];
|
|
|
|
if( spd > 0.0 && spd > ( mv->m_flMaxSpeed * mv->m_flMaxSpeed ) )
|
|
{
|
|
float fRatio = mv->m_flMaxSpeed / sqrt( spd );
|
|
mv->m_vecVelocity[0] *= fRatio;
|
|
mv->m_vecVelocity[1] *= fRatio;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CDODGameMovement::WalkMove( void )
|
|
{
|
|
float flSpeed = m_pDODPlayer->GetAbsVelocity().Length2D();
|
|
|
|
bool bSprintButtonPressed = ( mv->m_nButtons & IN_SPEED ) > 0;
|
|
|
|
if( bSprintButtonPressed &&
|
|
( mv->m_nButtons & IN_FORWARD ) &&
|
|
!m_pDODPlayer->m_Shared.IsProne() &&
|
|
!m_pDODPlayer->m_Shared.IsDucking() &&
|
|
flSpeed > 80 )
|
|
{
|
|
m_pDODPlayer->SetSprinting( true );
|
|
}
|
|
else
|
|
{
|
|
m_pDODPlayer->SetSprinting( false );
|
|
}
|
|
|
|
BaseClass::WalkMove();
|
|
|
|
//CheckForLadders( true );
|
|
//ResolveStanding();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Allow bots etc to use slightly different solid masks
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CDODGameMovement::PlayerSolidMask( bool brushOnly )
|
|
{
|
|
int mask = 0;
|
|
|
|
switch ( m_pDODPlayer->GetTeamNumber() )
|
|
{
|
|
case TEAM_ALLIES:
|
|
mask = CONTENTS_TEAM1;
|
|
break;
|
|
|
|
case TEAM_AXIS:
|
|
mask = CONTENTS_TEAM2;
|
|
break;
|
|
}
|
|
|
|
return ( mask | BaseClass::PlayerSolidMask( brushOnly ) );
|
|
}
|
|
|
|
void CDODGameMovement::AirMove( void )
|
|
{
|
|
BaseClass::AirMove();
|
|
|
|
//CheckForLadders( false );
|
|
}
|
|
|
|
void CDODGameMovement::CheckForLadders( bool wasOnGround )
|
|
{
|
|
if ( !wasOnGround || !ResolveStanding() )
|
|
{
|
|
trace_t trace;
|
|
TracePlayerBBox( mv->GetAbsOrigin(), mv->GetAbsOrigin() + Vector( 0, 0, -5), MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
if ( trace.fraction == 1.0f )
|
|
{
|
|
Vector vel = -m_pDODPlayer->m_lastStandingPos + mv->GetAbsOrigin();
|
|
if ( !vel.x && !vel.y )
|
|
{
|
|
return;
|
|
}
|
|
vel.NormalizeInPlace();
|
|
vel *= 5.0f;
|
|
Vector vecStartPos( mv->GetAbsOrigin().x + vel.x, mv->GetAbsOrigin().y + vel.y, mv->GetAbsOrigin().z );
|
|
vel *= 5.0f;
|
|
Vector vecStandPos( mv->GetAbsOrigin().x - vel.x, mv->GetAbsOrigin().y - vel.y, mv->GetAbsOrigin().z - ( player->m_Local.m_flStepSize * 1.0f ) );
|
|
|
|
TracePlayerBBoxWithStep( vecStartPos, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
|
|
if ( trace.fraction != 1.0f && OnLadder( trace ) && trace.plane.normal.z != 1.0f )
|
|
{
|
|
if ( trace.fraction > 0.6 )
|
|
{
|
|
vel.NormalizeInPlace();
|
|
Vector org = mv->GetAbsOrigin();
|
|
org -= vel*5;
|
|
mv->SetAbsOrigin( org );
|
|
}
|
|
player->SetMoveType( MOVETYPE_LADDER );
|
|
player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
|
|
|
|
player->SetLadderNormal( trace.plane.normal );
|
|
mv->m_vecVelocity.Init();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pDODPlayer->m_lastStandingPos = mv->GetAbsOrigin();
|
|
}
|
|
}
|
|
|
|
inline void CDODGameMovement::TracePlayerBBoxWithStep( const Vector &vStart, const Vector &vEnd,
|
|
unsigned int fMask, int collisionGroup, trace_t &trace )
|
|
{
|
|
VPROF( "CDODGameMovement::TracePlayerBBoxWithStep" );
|
|
|
|
Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
|
|
vHullMin.z += player->m_Local.m_flStepSize;
|
|
Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );
|
|
|
|
Ray_t ray;
|
|
ray.Init( vStart, vEnd, vHullMin, vHullMax );
|
|
UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &trace );
|
|
}
|
|
|
|
// Taken from TF2 to prevent bouncing down slopes
|
|
bool CDODGameMovement::ResolveStanding( void )
|
|
{
|
|
VPROF( "CDODGameMovement::ResolveStanding" );
|
|
|
|
//
|
|
// Attempt to move down twice your step height. Anything between 0.5 and 1.0
|
|
// is a valid "stand" value.
|
|
//
|
|
|
|
// Matt - don't move twice your step height, only check a little bit down
|
|
// this will keep us relatively glued to stairs without feeling too snappy
|
|
float flMaxStepDrop = 8.0f;
|
|
|
|
Vector vecStandPos( mv->GetAbsOrigin().x, mv->GetAbsOrigin().y, mv->GetAbsOrigin().z - ( flMaxStepDrop ) );
|
|
|
|
trace_t trace;
|
|
TracePlayerBBoxWithStep( mv->GetAbsOrigin(), vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
|
|
// Anything between 0.5 and 1.0 is a valid stand value
|
|
if ( fabs( trace.fraction - 0.5 ) < 0.0004f )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if ( trace.fraction > 0.5f )
|
|
{
|
|
trace.fraction -= 0.5f;
|
|
Vector vecNewOrigin;
|
|
vecNewOrigin = mv->GetAbsOrigin() + trace.fraction * ( vecStandPos - mv->GetAbsOrigin() );
|
|
mv->SetAbsOrigin( vecNewOrigin );
|
|
return false;
|
|
}
|
|
|
|
// Less than 0.5 mean we need to attempt to push up the difference.
|
|
vecStandPos.z = ( mv->GetAbsOrigin().z + ( ( 0.5f - trace.fraction ) * ( player->m_Local.m_flStepSize * 2.0f ) ) );
|
|
TracePlayerBBoxWithStep( mv->GetAbsOrigin(), vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
|
|
// A fraction of 1.0 means we stood up fine - done.
|
|
if ( trace.fraction == 1.0f )
|
|
{
|
|
mv->SetAbsOrigin( trace.endpos );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Recover stamina
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::ReduceTimers( void )
|
|
{
|
|
Vector vecPlayerVelocity = m_pDODPlayer->GetAbsVelocity();
|
|
float flStamina = m_pDODPlayer->m_Shared.GetStamina();
|
|
float fl2DVelocitySquared = vecPlayerVelocity.x * vecPlayerVelocity.x +
|
|
vecPlayerVelocity.y * vecPlayerVelocity.y;
|
|
|
|
if ( !( mv->m_nButtons & IN_SPEED ) )
|
|
{
|
|
m_pDODPlayer->m_Shared.ResetSprintPenalty();
|
|
}
|
|
|
|
// Can only sprint in forward direction.
|
|
bool bSprinting = ( (mv->m_nButtons & IN_SPEED) && ( mv->m_nButtons & IN_FORWARD ) );
|
|
|
|
// If we're holding the sprint key and also actually moving, remove some stamina
|
|
Vector vel = m_pDODPlayer->GetAbsVelocity();
|
|
if ( bSprinting && fl2DVelocitySquared > 10000 ) //speed > 100
|
|
{
|
|
//flStamina -= 30 * gpGlobals->frametime; //reduction for sprinting
|
|
//flStamina += 10 * gpGlobals->frametime; //addition for recovering
|
|
|
|
flStamina -= 20 * gpGlobals->frametime;
|
|
|
|
m_pDODPlayer->m_Shared.SetStamina( flStamina );
|
|
}
|
|
else
|
|
{
|
|
//gain some back
|
|
if ( fl2DVelocitySquared <= 0 )
|
|
{
|
|
flStamina += 60 * gpGlobals->frametime;
|
|
}
|
|
else if ( ( m_pDODPlayer->GetFlags() & FL_ONGROUND ) &&
|
|
( mv->m_nButtons & IN_DUCK ) &&
|
|
( m_pDODPlayer->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
flStamina += 50 * gpGlobals->frametime;
|
|
}
|
|
else
|
|
{
|
|
flStamina += 10 * gpGlobals->frametime;
|
|
}
|
|
|
|
m_pDODPlayer->m_Shared.SetStamina( flStamina );
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( bSprinting && flStamina < 25 )
|
|
{
|
|
m_pDODPlayer->HintMessage( HINT_LOW_STAMINA );
|
|
}
|
|
#endif
|
|
|
|
BaseClass::ReduceTimers();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CDODGameMovement::CheckJumpButton( void )
|
|
{
|
|
if (m_pDODPlayer->pl.deadflag)
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP ; // don't jump again until released
|
|
return false;
|
|
}
|
|
|
|
if( m_pDODPlayer->m_Shared.IsProne() ||
|
|
m_pDODPlayer->m_Shared.IsGettingUpFromProne() ||
|
|
m_pDODPlayer->m_Shared.IsGoingProne() )
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP;
|
|
return false;
|
|
}
|
|
|
|
// See if we are waterjumping. If so, decrement count and return.
|
|
float flWaterJumpTime = player->GetWaterJumpTime();
|
|
|
|
if ( flWaterJumpTime > 0 )
|
|
{
|
|
flWaterJumpTime -= gpGlobals->frametime;
|
|
if (flWaterJumpTime < 0)
|
|
flWaterJumpTime = 0;
|
|
|
|
player->SetWaterJumpTime( flWaterJumpTime );
|
|
|
|
return false;
|
|
}
|
|
|
|
// If we are in the water most of the way...
|
|
if ( m_pDODPlayer->GetWaterLevel() >= 2 )
|
|
{
|
|
// swimming, not jumping
|
|
SetGroundEntity( NULL );
|
|
|
|
if(m_pDODPlayer->GetWaterType() == CONTENTS_WATER) // We move up a certain amount
|
|
mv->m_vecVelocity[2] = 100;
|
|
else if (m_pDODPlayer->GetWaterType() == CONTENTS_SLIME)
|
|
mv->m_vecVelocity[2] = 80;
|
|
|
|
// play swiming sound
|
|
if ( player->GetSwimSoundTime() <= 0 )
|
|
{
|
|
// Don't play sound again for 1 second
|
|
player->SetSwimSoundTime( 1000 );
|
|
PlaySwimSound();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// No more effect
|
|
if (m_pDODPlayer->GetGroundEntity() == NULL)
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP;
|
|
return false; // in air, so no effect
|
|
}
|
|
|
|
if ( mv->m_nOldButtons & IN_JUMP )
|
|
return false; // don't pogo stick
|
|
|
|
if( m_pDODPlayer->m_Shared.IsInMGDeploy() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// In the air now.
|
|
SetGroundEntity( NULL );
|
|
|
|
m_pDODPlayer->PlayStepSound( (Vector &)mv->GetAbsOrigin(), player->GetSurfaceData(), 1.0, true );
|
|
|
|
m_pDODPlayer->DoAnimationEvent( PLAYERANIMEVENT_JUMP );
|
|
|
|
// make the jump sound
|
|
CPASFilter filter( m_pDODPlayer->GetAbsOrigin() );
|
|
filter.UsePredictionRules();
|
|
m_pDODPlayer->EmitSound( filter, m_pDODPlayer->entindex(), "Player.Jump" );
|
|
|
|
float flGroundFactor = 1.0f;
|
|
if ( player->GetSurfaceData() )
|
|
{
|
|
flGroundFactor = player->GetSurfaceData()->game.jumpFactor;
|
|
}
|
|
|
|
/*
|
|
// old and busted
|
|
|
|
float flStamina = m_pDODPlayer->m_Shared.GetStamina();
|
|
|
|
//15.0 is the base height. the player will always jump this high
|
|
//regardless of stamina. Also the player will be able to jump max height
|
|
//until he is below 60 stamina. Then the height will decrease proportionately
|
|
|
|
float flJumpSpeed = 15.0; //base jump height
|
|
|
|
if( flStamina >= 60.0f )
|
|
{
|
|
flJumpSpeed += 30.0;
|
|
}
|
|
else
|
|
{
|
|
flJumpSpeed += (30.0 * ( flStamina / 60.0f ) );
|
|
}
|
|
|
|
//Remove stamina for a successful jump
|
|
m_pDODPlayer->m_Shared.SetStamina( flStamina - 40 );
|
|
|
|
*/
|
|
|
|
// new hotness - constant jumpspeed of 45
|
|
//m_pDODPlayer->m_Shared.SetSlowedTime( 1.0f );
|
|
|
|
Assert( GetCurrentGravity() == 800.0f );
|
|
|
|
// Accelerate upward
|
|
// If we are ducking...
|
|
float startz = mv->m_vecVelocity[2];
|
|
if ( ( m_pDODPlayer->m_Local.m_bDucking ) || ( m_pDODPlayer->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
// d = 0.5 * g * t^2 - distance traveled with linear accel
|
|
// t = sqrt(2.0 * 45 / g) - how long to fall 45 units
|
|
// v = g * t - velocity at the end (just invert it to jump up that high)
|
|
// v = g * sqrt(2.0 * 45 / g )
|
|
// v^2 = g * g * 2.0 * 45 / g
|
|
// v = sqrt( g * 2.0 * 45 )
|
|
|
|
mv->m_vecVelocity[2] = flGroundFactor * 268.3281572999747f; // flJumpSpeed of 45
|
|
//mv->m_vecVelocity[2] = flGroundFactor * sqrt(2 * 800 * flJumpSpeed); // 2 * gravity * height
|
|
}
|
|
else
|
|
{
|
|
mv->m_vecVelocity[2] += flGroundFactor * 268.3281572999747f; // flJumpSpeed of 45
|
|
//mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * flJumpSpeed); // 2 * gravity * height
|
|
}
|
|
|
|
FinishGravity();
|
|
|
|
mv->m_outWishVel.z += mv->m_vecVelocity[2] - startz;
|
|
mv->m_outStepHeight += 0.1f;
|
|
|
|
// Flag that we jumped.
|
|
mv->m_nOldButtons |= IN_JUMP; // don't jump again until released
|
|
|
|
m_pDODPlayer->m_Shared.SetJumping( true );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Limit speed if we are ducking
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::HandleDuckingSpeedCrop()
|
|
{
|
|
if ( !( m_iSpeedCropped & SPEED_CROPPED_DUCK ) )
|
|
{
|
|
if ( ( mv->m_nButtons & IN_DUCK ) || ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
float frac = 0.33333333f;
|
|
mv->m_flForwardMove *= frac;
|
|
mv->m_flSideMove *= frac;
|
|
mv->m_flUpMove *= frac;
|
|
m_iSpeedCropped |= SPEED_CROPPED_DUCK;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CDODGameMovement::CanUnprone()
|
|
{
|
|
int i;
|
|
trace_t trace;
|
|
Vector newOrigin;
|
|
|
|
VectorCopy( mv->GetAbsOrigin(), newOrigin );
|
|
|
|
Vector vecMins, vecMaxs;
|
|
|
|
if ( mv->m_nButtons & IN_DUCK )
|
|
{
|
|
vecMins = VEC_DUCK_HULL_MIN_SCALED( player );
|
|
vecMaxs = VEC_DUCK_HULL_MAX_SCALED( player );
|
|
}
|
|
else
|
|
{
|
|
vecMins = VEC_HULL_MIN_SCALED( player );
|
|
vecMaxs = VEC_HULL_MAX_SCALED( player );
|
|
}
|
|
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
for ( i = 0; i < 3; i++ )
|
|
{
|
|
newOrigin[i] += ( VEC_PRONE_HULL_MIN_SCALED( player )[i] - vecMins[i] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If in air an letting go of crouch, make sure we can offset origin to make
|
|
// up for uncrouching
|
|
|
|
Vector hullSizeNormal = vecMaxs - vecMins;
|
|
Vector hullSizeProne = VEC_PRONE_HULL_MAX_SCALED( player ) - VEC_PRONE_HULL_MIN_SCALED( player );
|
|
|
|
Vector viewDelta = -0.5f * ( hullSizeNormal - hullSizeProne );
|
|
|
|
VectorAdd( newOrigin, viewDelta, newOrigin );
|
|
}
|
|
|
|
bool saveprone = m_pDODPlayer->m_Shared.IsProne();
|
|
bool saveducked = player->m_Local.m_bDucked;
|
|
|
|
// pretend we're not prone
|
|
m_pDODPlayer->m_Shared.SetProne( false );
|
|
if ( mv->m_nButtons & IN_DUCK )
|
|
player->m_Local.m_bDucked = true;
|
|
|
|
TracePlayerBBox( mv->GetAbsOrigin(), newOrigin, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
|
|
// revert to reality
|
|
m_pDODPlayer->m_Shared.SetProne( saveprone );
|
|
player->m_Local.m_bDucked = saveducked;
|
|
|
|
if ( trace.startsolid || ( trace.fraction != 1.0f ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Stop ducking
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::FinishUnDuck( void )
|
|
{
|
|
int i;
|
|
trace_t trace;
|
|
Vector newOrigin;
|
|
|
|
VectorCopy( mv->GetAbsOrigin(), newOrigin );
|
|
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
for ( i = 0; i < 3; i++ )
|
|
{
|
|
newOrigin[i] += ( VEC_DUCK_HULL_MIN_SCALED( player )[i] - VEC_HULL_MIN_SCALED( player )[i] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If in air an letting go of crouch, make sure we can offset origin to make
|
|
// up for uncrouching
|
|
// orange box patch - made this match the check in CanUnduck()
|
|
Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
|
|
Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
|
|
Vector viewDelta = ( hullSizeNormal - hullSizeCrouch );
|
|
viewDelta.Negate();
|
|
VectorAdd( newOrigin, viewDelta, newOrigin );
|
|
}
|
|
|
|
player->m_Local.m_bDucked = false;
|
|
player->RemoveFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucking = false;
|
|
SetViewOffset( GetPlayerViewOffset( false ) );
|
|
player->m_Local.m_flDucktime = 0;
|
|
|
|
mv->SetAbsOrigin( newOrigin );
|
|
|
|
// Recategorize position since ducking can change origin
|
|
CategorizePosition();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finish ducking
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::FinishDuck( void )
|
|
{
|
|
Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
|
|
Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
|
|
|
|
Vector viewDelta = 0.5f * ( hullSizeNormal - hullSizeCrouch );
|
|
|
|
SetViewOffset( GetPlayerViewOffset( true ) );
|
|
player->AddFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucking = false;
|
|
|
|
if ( !player->m_Local.m_bDucked )
|
|
{
|
|
Vector org = mv->GetAbsOrigin();
|
|
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
org -= VEC_DUCK_HULL_MIN_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
|
|
}
|
|
else
|
|
{
|
|
VectorAdd( org, viewDelta, org );
|
|
}
|
|
mv->SetAbsOrigin( org );
|
|
|
|
player->m_Local.m_bDucked = true;
|
|
}
|
|
|
|
// See if we are stuck?
|
|
FixPlayerCrouchStuck( true );
|
|
|
|
// Recategorize position since ducking can change origin
|
|
CategorizePosition();
|
|
}
|
|
|
|
// Being deployed or undeploying totally stomps the duck view offset
|
|
void CDODGameMovement::SetDeployedEyeOffset( void )
|
|
{
|
|
if ( m_pDODPlayer->m_Shared.IsProne() || m_pDODPlayer->m_Shared.IsGettingUpFromProne() )
|
|
return;
|
|
|
|
if ( !m_pDODPlayer->IsAlive() )
|
|
return;
|
|
|
|
float flTimeSinceDeployChange = gpGlobals->curtime - m_pDODPlayer->m_Shared.m_flDeployChangeTime;
|
|
|
|
if ( m_pDODPlayer->m_Shared.IsInMGDeploy() || flTimeSinceDeployChange < TIME_TO_DEPLOY )
|
|
{
|
|
if ( m_pDODPlayer->m_Shared.IsInMGDeploy() )
|
|
{
|
|
// anim to deployed
|
|
if ( m_pDODPlayer->m_Shared.GetLastViewAnimTime() < m_pDODPlayer->m_Shared.m_flDeployChangeTime.m_Value )
|
|
{
|
|
// Deployed height
|
|
float flViewOffset = clamp( m_pDODPlayer->m_Shared.GetDeployedHeight(),
|
|
CROUCHING_DEPLOY_HEIGHT,
|
|
STANDING_DEPLOY_HEIGHT );
|
|
|
|
Vector vecView = player->GetViewOffset();
|
|
vecView.z = flViewOffset;
|
|
|
|
ViewOffsetAnimation( vecView, TIME_TO_DEPLOY, VIEW_ANIM_LINEAR_Z_ONLY );
|
|
m_pDODPlayer->m_Shared.SetLastViewAnimTime( gpGlobals->curtime );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// anim to undeployed
|
|
if ( m_pDODPlayer->m_Shared.GetLastViewAnimTime() < m_pDODPlayer->m_Shared.m_flDeployChangeTime.m_Value )
|
|
{
|
|
ViewOffsetAnimation( GetPlayerViewOffset( player->m_Local.m_bDucked ), TIME_TO_DEPLOY, VIEW_ANIM_LINEAR_Z_ONLY );
|
|
m_pDODPlayer->m_Shared.SetLastViewAnimTime( gpGlobals->curtime );
|
|
}
|
|
}
|
|
|
|
if ( flTimeSinceDeployChange >= TIME_TO_DEPLOY )
|
|
{
|
|
player->m_Local.m_bDucked = false;
|
|
player->RemoveFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucking = false;
|
|
player->m_Local.m_flDucktime = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : duckFraction -
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::SetDODDuckedEyeOffset( float duckFraction )
|
|
{
|
|
// Different from CGameMovement in that
|
|
Vector vDuckHullMin = GetPlayerMins( true );
|
|
Vector vStandHullMin = GetPlayerMins( false );
|
|
|
|
float fMore = ( vDuckHullMin.z - vStandHullMin.z );
|
|
|
|
Vector vecStandViewOffset = GetPlayerViewOffset( false );
|
|
|
|
Vector vecDuckViewOffset = GetPlayerViewOffset( true );
|
|
Vector temp = player->GetViewOffset();
|
|
temp.z = ( ( vecDuckViewOffset.z - fMore ) * duckFraction ) +
|
|
( vecStandViewOffset.z * ( 1 - duckFraction ) );
|
|
SetViewOffset( temp );
|
|
}
|
|
|
|
void CDODGameMovement::SetProneEyeOffset( float proneFraction )
|
|
{
|
|
Vector vecPropViewOffset = VEC_PRONE_VIEW;
|
|
Vector vecStandViewOffset = GetPlayerViewOffset( player->m_Local.m_bDucked );
|
|
|
|
Vector temp = player->GetViewOffset();
|
|
temp.z = SimpleSplineRemapVal( proneFraction, 1.0, 0.0, vecPropViewOffset.z, vecStandViewOffset.z );
|
|
|
|
SetViewOffset( temp );
|
|
}
|
|
|
|
void CDODGameMovement::FinishUnProne( void )
|
|
{
|
|
m_pDODPlayer->m_Shared.m_flUnProneTime = 0.0f;
|
|
|
|
SetProneEyeOffset( 0.0 );
|
|
|
|
Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
|
|
Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );
|
|
|
|
if ( m_bUnProneToDuck )
|
|
{
|
|
FinishDuck();
|
|
}
|
|
else
|
|
{
|
|
CategorizePosition();
|
|
|
|
if ( mv->m_nButtons & IN_DUCK && !( player->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
// Use 1 second so super long jump will work
|
|
player->m_Local.m_flDucktime = 1000;
|
|
player->m_Local.m_bDucking = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDODGameMovement::FinishProne( void )
|
|
{
|
|
m_pDODPlayer->m_Shared.SetProne( true );
|
|
m_pDODPlayer->m_Shared.m_flGoProneTime = 0.0f;
|
|
|
|
#ifndef CLIENT_DLL
|
|
m_pDODPlayer->HintMessage( HINT_PRONE );
|
|
#endif
|
|
|
|
FinishUnDuck(); // clear ducking
|
|
|
|
SetProneEyeOffset( 1.0 );
|
|
|
|
FixPlayerCrouchStuck(true);
|
|
|
|
CategorizePosition();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: See if duck button is pressed and do the appropriate things
|
|
//-----------------------------------------------------------------------------
|
|
void CDODGameMovement::Duck( void )
|
|
{
|
|
int buttonsChanged = ( mv->m_nOldButtons ^ mv->m_nButtons ); // These buttons have changed this frame
|
|
int buttonsPressed = buttonsChanged & mv->m_nButtons; // The changed ones still down are "pressed"
|
|
int buttonsReleased = buttonsChanged & mv->m_nOldButtons; // The changed ones which were previously down are "released"
|
|
|
|
if ( mv->m_nButtons & IN_DUCK )
|
|
{
|
|
mv->m_nOldButtons |= IN_DUCK;
|
|
}
|
|
else
|
|
{
|
|
mv->m_nOldButtons &= ~IN_DUCK;
|
|
}
|
|
|
|
if ( !player->IsAlive() )
|
|
{
|
|
if( m_pDODPlayer->m_Shared.IsProne() )
|
|
{
|
|
FinishUnProne();
|
|
}
|
|
|
|
// Unduck
|
|
if ( player->m_Local.m_bDucking || player->m_Local.m_bDucked )
|
|
{
|
|
FinishUnDuck();
|
|
}
|
|
return;
|
|
}
|
|
|
|
static int iState = 0;
|
|
|
|
// Prone / UnProne - we don't duck or deploy if this is happening
|
|
if( m_pDODPlayer->m_Shared.m_flUnProneTime > 0.0f )
|
|
{
|
|
float pronetime = m_pDODPlayer->m_Shared.m_flUnProneTime - gpGlobals->curtime;
|
|
|
|
if( pronetime < 0 )
|
|
{
|
|
FinishUnProne();
|
|
|
|
if ( !m_bUnProneToDuck && ( mv->m_nButtons & IN_DUCK ) )
|
|
{
|
|
buttonsPressed |= IN_DUCK;
|
|
mv->m_nOldButtons &= ~IN_DUCK;
|
|
}
|
|
}
|
|
|
|
// Set these, so that as soon as we stop unproning, we don't pop to standing
|
|
// the information that we let go of the duck key has been lost by now.
|
|
if ( m_bUnProneToDuck )
|
|
{
|
|
player->m_Local.m_flDucktime = 1000;
|
|
player->m_Local.m_bDucking = true;
|
|
}
|
|
|
|
//don't deal with ducking while we're proning
|
|
return;
|
|
}
|
|
else if( m_pDODPlayer->m_Shared.m_flGoProneTime > 0.0f )
|
|
{
|
|
float pronetime = m_pDODPlayer->m_Shared.m_flGoProneTime - gpGlobals->curtime;
|
|
|
|
if( pronetime < 0 )
|
|
{
|
|
FinishProne();
|
|
}
|
|
|
|
//don't deal with ducking while we're proning
|
|
return;
|
|
}
|
|
|
|
if ( gpGlobals->curtime > m_pDODPlayer->m_Shared.m_flNextProneCheck )
|
|
{
|
|
if ( buttonsPressed & IN_ALT1 && m_pDODPlayer->m_Shared.CanChangePosition() )
|
|
{
|
|
if( m_pDODPlayer->m_Shared.IsProne() == false &&
|
|
m_pDODPlayer->m_Shared.IsGettingUpFromProne() == false )
|
|
{
|
|
m_pDODPlayer->m_Shared.StartGoingProne();
|
|
|
|
// do unprone anim
|
|
ViewOffsetAnimation( VEC_PRONE_VIEW, TIME_TO_PRONE, VIEW_ANIM_EXPONENTIAL_Z_ONLY );
|
|
}
|
|
else if( CanUnprone() )
|
|
{
|
|
m_pDODPlayer->m_Shared.SetProne( false );
|
|
m_pDODPlayer->m_Shared.StandUpFromProne();
|
|
|
|
// do unprone anim
|
|
ViewOffsetAnimation( GetPlayerViewOffset( m_bUnProneToDuck ),
|
|
TIME_TO_PRONE,
|
|
VIEW_ANIM_EXPONENTIAL_Z_ONLY );
|
|
|
|
m_bUnProneToDuck = ( mv->m_nButtons & IN_DUCK ) > 0;
|
|
}
|
|
|
|
m_pDODPlayer->m_Shared.m_flNextProneCheck = gpGlobals->curtime + 1.0f;
|
|
return;
|
|
}
|
|
}
|
|
|
|
SetDeployedEyeOffset();
|
|
|
|
if ( m_pDODPlayer->m_Shared.IsProne() &&
|
|
m_pDODPlayer->m_Shared.CanChangePosition() &&
|
|
!m_pDODPlayer->m_Shared.IsGettingUpFromProne() &&
|
|
( buttonsPressed & IN_DUCK ) &&
|
|
CanUnprone() ) // BUGBUG - even calling this will unzoom snipers.
|
|
{
|
|
// If the player presses duck while prone,
|
|
// unprone them to the duck position
|
|
m_pDODPlayer->m_Shared.SetProne( false );
|
|
m_pDODPlayer->m_Shared.StandUpFromProne();
|
|
|
|
m_bUnProneToDuck = true;
|
|
|
|
// do unprone anim
|
|
ViewOffsetAnimation( GetPlayerViewOffset( m_bUnProneToDuck ),
|
|
TIME_TO_PRONE,
|
|
VIEW_ANIM_EXPONENTIAL_Z_ONLY );
|
|
|
|
// simulate a duck that was pressed while we were prone
|
|
player->AddFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucked = true;
|
|
player->m_Local.m_flDucktime = 1000;
|
|
player->m_Local.m_bDucking = true;
|
|
}
|
|
|
|
// no ducking or unducking while deployed or prone
|
|
if( m_pDODPlayer->m_Shared.IsProne() ||
|
|
m_pDODPlayer->m_Shared.IsGettingUpFromProne() ||
|
|
!m_pDODPlayer->m_Shared.CanChangePosition() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
HandleDuckingSpeedCrop();
|
|
|
|
if ( !( player->GetFlags() & FL_DUCKING ) && ( player->m_Local.m_bDucked ) )
|
|
{
|
|
player->m_Local.m_bDucked = false;
|
|
}
|
|
|
|
/*
|
|
Msg( "duck button %s ducking %s ducked %s duck flags %s\n",
|
|
( mv->m_nButtons & IN_DUCK ) ? "down" : "up",
|
|
( player->m_Local.m_bDucking ) ? "yes" : "no",
|
|
( player->m_Local.m_bDucked ) ? "yes" : "no",
|
|
( player->GetFlags() & FL_DUCKING ) ? "set" : "not set" );*/
|
|
|
|
// Holding duck, in process of ducking or fully ducked?
|
|
if ( ( mv->m_nButtons & IN_DUCK ) || ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
if ( mv->m_nButtons & IN_DUCK )
|
|
{
|
|
bool alreadyDucked = ( player->GetFlags() & FL_DUCKING ) ? true : false;
|
|
|
|
if ( (buttonsPressed & IN_DUCK ) && !( player->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
// Use 1 second so super long jump will work
|
|
player->m_Local.m_flDucktime = 1000;
|
|
player->m_Local.m_bDucking = true;
|
|
}
|
|
|
|
float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
|
|
float duckseconds = duckmilliseconds / 1000.0f;
|
|
|
|
//time = MAX( 0.0, ( 1.0 - (float)player->m_Local.m_flDucktime / 1000.0 ) );
|
|
|
|
if ( player->m_Local.m_bDucking )
|
|
{
|
|
// Finish ducking immediately if duck time is over or not on ground
|
|
if ( ( duckseconds > TIME_TO_DUCK ) ||
|
|
( player->GetGroundEntity() == NULL ) ||
|
|
alreadyDucked)
|
|
{
|
|
FinishDuck();
|
|
}
|
|
else
|
|
{
|
|
// Calc parametric time
|
|
float flDuckFraction = SimpleSpline( duckseconds / TIME_TO_DUCK );
|
|
SetDODDuckedEyeOffset( flDuckFraction );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Try to unduck unless automovement is not allowed
|
|
// NOTE: When not onground, you can always unduck
|
|
if ( player->m_Local.m_bAllowAutoMovement || player->GetGroundEntity() == NULL )
|
|
{
|
|
if ( (buttonsReleased & IN_DUCK ) && ( player->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
// Use 1 second so super long jump will work
|
|
player->m_Local.m_flDucktime = 1000;
|
|
player->m_Local.m_bDucking = true; // or unducking
|
|
}
|
|
|
|
float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
|
|
float duckseconds = duckmilliseconds / 1000.0f;
|
|
|
|
if ( CanUnduck() )
|
|
{
|
|
if ( player->m_Local.m_bDucking ||
|
|
player->m_Local.m_bDucked ) // or unducking
|
|
{
|
|
// Finish ducking immediately if duck time is over or not on ground
|
|
if ( ( duckseconds > TIME_TO_UNDUCK ) ||
|
|
( player->GetGroundEntity() == NULL ) )
|
|
{
|
|
FinishUnDuck();
|
|
}
|
|
else
|
|
{
|
|
// Calc parametric time
|
|
float duckFraction = SimpleSpline( 1.0f - ( duckseconds / TIME_TO_UNDUCK ) );
|
|
SetDODDuckedEyeOffset( duckFraction );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Still under something where we can't unduck, so make sure we reset this timer so
|
|
// that we'll unduck once we exit the tunnel, etc.
|
|
player->m_Local.m_flDucktime = 1000;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CDODGameMovement::GetPlayerMins( void ) const
|
|
{
|
|
if ( !player )
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
|
|
if ( player->IsObserver() )
|
|
{
|
|
return VEC_OBS_HULL_MIN_SCALED( player );
|
|
}
|
|
else
|
|
{
|
|
if ( player->m_Local.m_bDucked )
|
|
return VEC_DUCK_HULL_MIN_SCALED( player );
|
|
else if ( m_pDODPlayer->m_Shared.IsProne() )
|
|
return VEC_PRONE_HULL_MIN_SCALED( player );
|
|
else
|
|
return VEC_HULL_MIN_SCALED( player );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CDODGameMovement::GetPlayerMaxs( void ) const
|
|
{
|
|
if ( !player )
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
if ( player->IsObserver() )
|
|
{
|
|
return VEC_OBS_HULL_MAX_SCALED( player );
|
|
}
|
|
else
|
|
{
|
|
if ( player->m_Local.m_bDucked )
|
|
return VEC_DUCK_HULL_MAX_SCALED( player );
|
|
else if ( m_pDODPlayer->m_Shared.IsProne() )
|
|
return VEC_PRONE_HULL_MAX_SCALED( player );
|
|
else
|
|
return VEC_HULL_MAX_SCALED( player );
|
|
}
|
|
}
|
|
|
|
void CDODGameMovement::SetViewOffset( Vector vecViewOffset )
|
|
{
|
|
// call this instead of player->SetViewOffset directly, so we can cancel any
|
|
// animation in progress
|
|
|
|
m_pDODPlayer->m_Shared.ResetViewOffsetAnimation();
|
|
|
|
player->SetViewOffset( vecViewOffset );
|
|
}
|
|
|
|
void CDODGameMovement::ViewOffsetAnimation( Vector vecDest, float flTime, ViewAnimationType type )
|
|
{
|
|
m_pDODPlayer->m_Shared.ViewOffsetAnimation( vecDest, flTime, type );
|
|
} |