mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
4929 lines
135 KiB
C++
4929 lines
135 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "gamemovement.h"
|
|
#include "in_buttons.h"
|
|
#include <stdarg.h>
|
|
#include "movevars_shared.h"
|
|
#include "engine/IEngineTrace.h"
|
|
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
|
#include "decals.h"
|
|
#include "coordsize.h"
|
|
#include "rumble_shared.h"
|
|
|
|
#if defined(HL2_DLL) || defined(HL2_CLIENT_DLL)
|
|
#include "hl_movedata.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define STOP_EPSILON 0.1
|
|
#define MAX_CLIP_PLANES 5
|
|
|
|
#include "filesystem.h"
|
|
#include <stdarg.h>
|
|
|
|
extern IFileSystem *filesystem;
|
|
|
|
#ifndef CLIENT_DLL
|
|
#include "env_player_surface_trigger.h"
|
|
static ConVar dispcoll_drawplane( "dispcoll_drawplane", "0" );
|
|
#endif
|
|
|
|
|
|
// tickcount currently isn't set during prediction, although gpGlobals->curtime and
|
|
// gpGlobals->frametime are. We should probably set tickcount (to player->m_nTickBase),
|
|
// but we're REALLY close to shipping, so we can change that later and people can use
|
|
// player->CurrentCommandNumber() in the meantime.
|
|
#define tickcount USE_PLAYER_CURRENT_COMMAND_NUMBER__INSTEAD_OF_TICKCOUNT
|
|
|
|
#if defined( HL2_DLL )
|
|
ConVar xc_uncrouch_on_jump( "xc_uncrouch_on_jump", "1", FCVAR_ARCHIVE, "Uncrouch when jump occurs" );
|
|
#endif
|
|
|
|
#if defined( HL2_DLL ) || defined( HL2_CLIENT_DLL )
|
|
ConVar player_limit_jump_speed( "player_limit_jump_speed", "1", FCVAR_REPLICATED );
|
|
#endif
|
|
|
|
// option_duck_method is a carrier convar. Its sole purpose is to serve an easy-to-flip
|
|
// convar which is ONLY set by the X360 controller menu to tell us which way to bind the
|
|
// duck controls. Its value is meaningless anytime we don't have the options window open.
|
|
ConVar option_duck_method("option_duck_method", "1", FCVAR_REPLICATED|FCVAR_ARCHIVE );// 0 = HOLD to duck, 1 = Duck is a toggle
|
|
|
|
#ifdef STAGING_ONLY
|
|
#ifdef CLIENT_DLL
|
|
ConVar debug_latch_reset_onduck( "debug_latch_reset_onduck", "1", FCVAR_CHEAT );
|
|
#endif
|
|
#endif
|
|
|
|
// [MD] I'll remove this eventually. For now, I want the ability to A/B the optimizations.
|
|
bool g_bMovementOptimizations = true;
|
|
|
|
// Roughly how often we want to update the info about the ground surface we're on.
|
|
// We don't need to do this very often.
|
|
#define CATEGORIZE_GROUND_SURFACE_INTERVAL 0.3f
|
|
#define CATEGORIZE_GROUND_SURFACE_TICK_INTERVAL ( (int)( CATEGORIZE_GROUND_SURFACE_INTERVAL / TICK_INTERVAL ) )
|
|
|
|
#define CHECK_STUCK_INTERVAL 1.0f
|
|
#define CHECK_STUCK_TICK_INTERVAL ( (int)( CHECK_STUCK_INTERVAL / TICK_INTERVAL ) )
|
|
|
|
#define CHECK_STUCK_INTERVAL_SP 0.2f
|
|
#define CHECK_STUCK_TICK_INTERVAL_SP ( (int)( CHECK_STUCK_INTERVAL_SP / TICK_INTERVAL ) )
|
|
|
|
#define CHECK_LADDER_INTERVAL 0.2f
|
|
#define CHECK_LADDER_TICK_INTERVAL ( (int)( CHECK_LADDER_INTERVAL / TICK_INTERVAL ) )
|
|
|
|
#define NUM_CROUCH_HINTS 3
|
|
|
|
extern IGameMovement *g_pGameMovement;
|
|
|
|
#if defined( PLAYER_GETTING_STUCK_TESTING )
|
|
|
|
// If you ever get stuck walking around, then you can run this code to find the code which would leave the player in a bad spot
|
|
void CMoveData::SetAbsOrigin( const Vector &vec )
|
|
{
|
|
CGameMovement *gm = dynamic_cast< CGameMovement * >( g_pGameMovement );
|
|
if ( gm && gm->GetMoveData() &&
|
|
gm->player &&
|
|
gm->player->entindex() == 1 &&
|
|
gm->player->GetMoveType() == MOVETYPE_WALK )
|
|
{
|
|
trace_t pm;
|
|
gm->TracePlayerBBox( vec, vec, gm->PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
if ( pm.startsolid || pm.allsolid || pm.fraction != 1.0f )
|
|
{
|
|
Msg( "Player will become stuck at %f %f %f\n", VectorExpand( vec ) );
|
|
}
|
|
}
|
|
|
|
m_vecAbsOrigin = vec;
|
|
}
|
|
|
|
#endif
|
|
|
|
// See shareddefs.h
|
|
#if PREDICTION_ERROR_CHECK_LEVEL > 0
|
|
|
|
static ConVar diffcheck( "diffcheck", "0", FCVAR_REPLICATED );
|
|
|
|
class IDiffMgr
|
|
{
|
|
public:
|
|
virtual void StartCommand( bool bServer, int nCommandNumber ) = 0;
|
|
virtual void AddToDiff( bool bServer, int nCommandNumber, char const *string ) = 0;
|
|
virtual void Validate( bool bServer, int nCommandNumber ) = 0;
|
|
};
|
|
|
|
static IDiffMgr *g_pDiffMgr = NULL;
|
|
|
|
class CDiffStr
|
|
{
|
|
public:
|
|
CDiffStr()
|
|
{
|
|
m_str[ 0 ] = 0;
|
|
}
|
|
|
|
CDiffStr( char const *str )
|
|
{
|
|
Q_strncpy( m_str, str, sizeof( m_str ) );
|
|
}
|
|
|
|
CDiffStr( const CDiffStr &src )
|
|
{
|
|
Q_strncpy( m_str, src.m_str, sizeof( m_str ) );
|
|
}
|
|
|
|
char const *String()
|
|
{
|
|
return m_str;
|
|
}
|
|
private:
|
|
|
|
char m_str[ 128 ];
|
|
};
|
|
|
|
// Per tick data
|
|
class CDiffInfo
|
|
{
|
|
public:
|
|
CDiffInfo() : m_nCommandNumber( 0 ) {}
|
|
CDiffInfo( const CDiffInfo& src )
|
|
{
|
|
m_nCommandNumber = src.m_nCommandNumber;
|
|
for ( int i = 0; i < src.m_Lines.Count(); ++i )
|
|
{
|
|
m_Lines.AddToTail( src.m_Lines[ i ] );
|
|
}
|
|
}
|
|
|
|
static bool Less( const CDiffInfo& lhs, const CDiffInfo& rhs )
|
|
{
|
|
return lhs.m_nCommandNumber < rhs.m_nCommandNumber;
|
|
}
|
|
int m_nCommandNumber;
|
|
CUtlVector< CDiffStr > m_Lines;
|
|
bool m_bChecked;
|
|
};
|
|
|
|
class CDiffManager : public IDiffMgr
|
|
{
|
|
public:
|
|
CDiffManager() :
|
|
m_Client( 0, 0, CDiffInfo::Less ),
|
|
m_Server( 0, 0, CDiffInfo::Less ),
|
|
m_flLastSpew( -1.0f )
|
|
{
|
|
g_pDiffMgr = this;
|
|
}
|
|
|
|
virtual void StartCommand( bool bServer, int nCommandNumber )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
|
|
if ( !diffcheck.GetInt() )
|
|
return;
|
|
|
|
g_pDiffMgr = reinterpret_cast< IDiffMgr * >( diffcheck.GetInt() );
|
|
g_pDiffMgr->StartCommand( bServer, nCommandNumber );
|
|
return;
|
|
#endif
|
|
|
|
// Msg( "%s Startcommand %d\n", bServer ? "sv" : "cl", nCommandNumber );
|
|
|
|
diffcheck.SetValue( reinterpret_cast< int >( this ) );
|
|
|
|
Assert( CBaseEntity::IsServer() );
|
|
|
|
CUtlRBTree< CDiffInfo, int >& rb = bServer ? m_Server : m_Client;
|
|
|
|
CDiffInfo search;
|
|
search.m_nCommandNumber = nCommandNumber;
|
|
int idx = rb.Find( search );
|
|
if ( idx == rb.InvalidIndex() )
|
|
{
|
|
idx = rb.Insert( search );
|
|
}
|
|
|
|
CDiffInfo *slot = &rb[ idx ];
|
|
slot->m_Lines.RemoveAll();
|
|
}
|
|
|
|
virtual void AddToDiff( bool bServer, int nCommandNumber, char const *string )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
|
|
if ( !diffcheck.GetInt() )
|
|
return;
|
|
|
|
g_pDiffMgr = reinterpret_cast< IDiffMgr * >( diffcheck.GetInt() );
|
|
g_pDiffMgr->AddToDiff( bServer, nCommandNumber, string );
|
|
return;
|
|
#endif
|
|
Assert( CBaseEntity::IsServer() );
|
|
|
|
// Msg( "%s Add %d %s\n", bServer ? "sv" : "cl", nCommandNumber, string );
|
|
|
|
CUtlRBTree< CDiffInfo, int >& rb = bServer ? m_Server : m_Client;
|
|
|
|
CDiffInfo search;
|
|
search.m_nCommandNumber = nCommandNumber;
|
|
int idx = rb.Find( search );
|
|
if ( idx == rb.InvalidIndex() )
|
|
{
|
|
Assert( 0 );
|
|
idx = rb.Insert( search );
|
|
}
|
|
|
|
CDiffInfo *slot = &rb[ idx ];
|
|
CDiffStr line( string );
|
|
slot->m_Lines.AddToTail( line );
|
|
}
|
|
|
|
enum EMismatched
|
|
{
|
|
DIFFCHECK_NOTREADY = 0,
|
|
DIFFCHECK_MATCHED,
|
|
DIFFCHECK_DIFFERS
|
|
};
|
|
|
|
bool ClientRecordExists( int cmd )
|
|
{
|
|
CDiffInfo clsearch;
|
|
clsearch.m_nCommandNumber = cmd;
|
|
int clidx = m_Client.Find( clsearch );
|
|
return m_Client.IsValidIndex( clidx );
|
|
}
|
|
|
|
EMismatched IsMismatched( int svidx )
|
|
{
|
|
CDiffInfo *serverslot = &m_Server[ svidx ];
|
|
|
|
// Now find the client version of this one
|
|
CDiffInfo clsearch;
|
|
clsearch.m_nCommandNumber = serverslot->m_nCommandNumber;
|
|
int clidx = m_Client.Find( clsearch );
|
|
if ( clidx == m_Client.InvalidIndex() )
|
|
return DIFFCHECK_NOTREADY;
|
|
|
|
// Now compare them
|
|
CDiffInfo *clientslot = &m_Client[ clidx ];
|
|
|
|
bool bSpew = false;
|
|
if ( serverslot->m_Lines.Count() !=
|
|
clientslot->m_Lines.Count() )
|
|
{
|
|
return DIFFCHECK_DIFFERS;
|
|
}
|
|
|
|
int maxSlot = MAX( serverslot->m_Lines.Count(), clientslot->m_Lines.Count() );
|
|
if ( !bSpew )
|
|
{
|
|
for ( int i = 0; i < maxSlot; ++i )
|
|
{
|
|
CDiffStr *sv = NULL;
|
|
CDiffStr *cl = NULL;
|
|
if ( i < serverslot->m_Lines.Count() )
|
|
{
|
|
sv = &serverslot->m_Lines[ i ];
|
|
}
|
|
if ( i < clientslot->m_Lines.Count() )
|
|
{
|
|
cl = &clientslot->m_Lines[ i ];
|
|
}
|
|
|
|
if ( Q_stricmp( sv ? sv->String() : "(missing)", cl ? cl->String() : "(missing)" ) )
|
|
{
|
|
return DIFFCHECK_DIFFERS;
|
|
}
|
|
}
|
|
}
|
|
|
|
return DIFFCHECK_MATCHED;
|
|
}
|
|
|
|
virtual void Validate( bool bServer, int nCommandNumber )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
|
|
if ( !diffcheck.GetInt() )
|
|
return;
|
|
|
|
g_pDiffMgr = reinterpret_cast< IDiffMgr * >( diffcheck.GetInt() );
|
|
g_pDiffMgr->Validate( bServer, nCommandNumber );
|
|
return;
|
|
#endif
|
|
Assert( CBaseEntity::IsServer() );
|
|
|
|
// Only do this on the client
|
|
if ( !bServer )
|
|
return;
|
|
|
|
// Find the last server command number
|
|
if ( m_Server.Count() <= 0 )
|
|
return;
|
|
|
|
int svidx = m_Server.LastInorder();
|
|
EMismatched eMisMatched = IsMismatched( svidx );
|
|
if ( eMisMatched == DIFFCHECK_NOTREADY )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( eMisMatched == DIFFCHECK_DIFFERS )
|
|
{
|
|
CUtlVector< int > vecPrev;
|
|
|
|
int nCur = svidx;
|
|
do
|
|
{
|
|
int prev = m_Server.PrevInorder( nCur );
|
|
if ( m_Server.IsValidIndex( prev ) &&
|
|
ClientRecordExists( m_Server[ prev ].m_nCommandNumber ) )
|
|
{
|
|
//SpewRecords( "prev", prev );
|
|
vecPrev.AddToHead( prev );
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
nCur = prev;
|
|
} while ( vecPrev.Count() < 10 );
|
|
|
|
Msg( "-----\n" );
|
|
|
|
for ( int p = 0; p < vecPrev.Count(); ++p )
|
|
{
|
|
SpewRecords( "prev", vecPrev[ p ] );
|
|
}
|
|
|
|
SpewRecords( "bad ", svidx );
|
|
}
|
|
}
|
|
|
|
void SpewRecords( char const *prefix, int svidx )
|
|
{
|
|
CDiffInfo *serverslot = &m_Server[ svidx ];
|
|
|
|
// Now find the client version of this one
|
|
CDiffInfo clsearch;
|
|
clsearch.m_nCommandNumber = serverslot->m_nCommandNumber;
|
|
int clidx = m_Client.Find( clsearch );
|
|
if ( clidx == m_Client.InvalidIndex() )
|
|
return;
|
|
|
|
// Now compare them
|
|
CDiffInfo *clientslot = &m_Client[ clidx ];
|
|
|
|
int maxSlot = MAX( serverslot->m_Lines.Count(), clientslot->m_Lines.Count() );
|
|
|
|
for ( int i = 0; i < maxSlot; ++i )
|
|
{
|
|
char const *sv = "(missing)";
|
|
char const *cl = "(missing)";
|
|
|
|
if ( i < serverslot->m_Lines.Count() )
|
|
{
|
|
sv = serverslot->m_Lines[ i ].String();
|
|
}
|
|
if ( i < clientslot->m_Lines.Count() )
|
|
{
|
|
cl = clientslot->m_Lines[ i ].String();
|
|
}
|
|
|
|
bool bDiffers = Q_stricmp( sv, cl ) ? true : false;
|
|
|
|
Msg( "%s%s%d: sv[%50.50s] cl[%50.50s]\n",
|
|
prefix,
|
|
bDiffers ? "+++" : " ",
|
|
serverslot->m_nCommandNumber,
|
|
sv,
|
|
cl );
|
|
}
|
|
}
|
|
private:
|
|
|
|
CUtlRBTree< CDiffInfo, int > m_Server;
|
|
CUtlRBTree< CDiffInfo, int > m_Client;
|
|
float m_flLastSpew;
|
|
};
|
|
|
|
static CDiffManager g_DiffMgr;
|
|
|
|
void DiffPrint( bool bServer, int nCommandNumber, char const *fmt, ... )
|
|
{
|
|
// Only track stuff for local player
|
|
CBasePlayer *pPlayer = CBaseEntity::GetPredictionPlayer();
|
|
if ( pPlayer && pPlayer->entindex() != 1 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
va_list argptr;
|
|
char string[1024];
|
|
va_start (argptr,fmt);
|
|
int len = Q_vsnprintf(string, sizeof( string ), fmt,argptr);
|
|
va_end (argptr);
|
|
|
|
if ( g_pDiffMgr )
|
|
{
|
|
// Strip any \n at the end that the user accidently put int
|
|
if ( len > 0 && string[ len -1 ] == '\n' )
|
|
{
|
|
string[ len - 1 ] = 0;
|
|
}
|
|
|
|
g_pDiffMgr->AddToDiff( bServer, nCommandNumber, string );
|
|
}
|
|
}
|
|
|
|
void _CheckV( int tick, char const *ctx, const Vector &vel )
|
|
{
|
|
DiffPrint( CBaseEntity::IsServer(), tick, "%20.20s %f %f %f", ctx, vel.x, vel.y, vel.z );
|
|
}
|
|
|
|
#define CheckV( tick, ctx, vel ) _CheckV( tick, ctx, vel );
|
|
|
|
static void StartCommand( bool bServer, int nCommandNumber )
|
|
{
|
|
// Only track stuff for local player
|
|
CBasePlayer *pPlayer = CBaseEntity::GetPredictionPlayer();
|
|
if ( pPlayer && pPlayer->entindex() != 1 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( g_pDiffMgr )
|
|
{
|
|
g_pDiffMgr->StartCommand( bServer, nCommandNumber );
|
|
}
|
|
}
|
|
|
|
static void Validate( bool bServer, int nCommandNumber )
|
|
{
|
|
// Only track stuff for local player
|
|
CBasePlayer *pPlayer = CBaseEntity::GetPredictionPlayer();
|
|
if ( pPlayer && pPlayer->entindex() != 1 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
if ( g_pDiffMgr )
|
|
{
|
|
g_pDiffMgr->Validate( bServer, nCommandNumber );
|
|
}
|
|
}
|
|
|
|
void CGameMovement::DiffPrint( char const *fmt, ... )
|
|
{
|
|
if ( !player )
|
|
return;
|
|
|
|
va_list argptr;
|
|
char string[1024];
|
|
va_start (argptr,fmt);
|
|
Q_vsnprintf(string, sizeof( string ), fmt,argptr);
|
|
va_end (argptr);
|
|
|
|
::DiffPrint( CBaseEntity::IsServer(), player->CurrentCommandNumber(), "%s", string );
|
|
}
|
|
|
|
#else
|
|
static void DiffPrint( bool bServer, int nCommandNumber, char const *fmt, ... )
|
|
{
|
|
// Nothing
|
|
}
|
|
static void StartCommand( bool bServer, int nCommandNumber )
|
|
{
|
|
}
|
|
|
|
static void Validate( bool bServer, int nCommandNumber )
|
|
{
|
|
}
|
|
|
|
#define CheckV( tick, ctx, vel )
|
|
|
|
void CGameMovement::DiffPrint( char const *fmt, ... )
|
|
{
|
|
}
|
|
|
|
#endif // !PREDICTION_ERROR_CHECK_LEVEL
|
|
|
|
#ifndef _XBOX
|
|
void COM_Log( char *pszFile, const char *fmt, ...)
|
|
{
|
|
va_list argptr;
|
|
char string[1024];
|
|
FileHandle_t fp;
|
|
const char *pfilename;
|
|
|
|
if ( !pszFile )
|
|
{
|
|
pfilename = "hllog.txt";
|
|
}
|
|
else
|
|
{
|
|
pfilename = pszFile;
|
|
}
|
|
va_start (argptr,fmt);
|
|
Q_vsnprintf(string, sizeof( string ), fmt,argptr);
|
|
va_end (argptr);
|
|
|
|
fp = filesystem->Open( pfilename, "a+t");
|
|
if (fp)
|
|
{
|
|
filesystem->FPrintf(fp, "%s", string);
|
|
filesystem->Close(fp);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifndef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Debug - draw the displacement collision plane.
|
|
//-----------------------------------------------------------------------------
|
|
void DrawDispCollPlane( CBaseTrace *pTrace )
|
|
{
|
|
float flLength = 30.0f;
|
|
|
|
// Create a basis, based on the impact normal.
|
|
int nMajorAxis = 0;
|
|
Vector vecBasisU, vecBasisV, vecNormal;
|
|
vecNormal = pTrace->plane.normal;
|
|
float flAxisValue = vecNormal[0];
|
|
if ( fabs( vecNormal[1] ) > fabs( flAxisValue ) ) { nMajorAxis = 1; flAxisValue = vecNormal[1]; }
|
|
if ( fabs( vecNormal[2] ) > fabs( flAxisValue ) ) { nMajorAxis = 2; }
|
|
if ( ( nMajorAxis == 1 ) || ( nMajorAxis == 2 ) )
|
|
{
|
|
vecBasisU.Init( 1.0f, 0.0f, 0.0f );
|
|
}
|
|
else
|
|
{
|
|
vecBasisU.Init( 0.0f, 1.0f, 0.0f );
|
|
}
|
|
|
|
vecBasisV = vecNormal.Cross( vecBasisU );
|
|
VectorNormalize( vecBasisV );
|
|
|
|
vecBasisU = vecBasisV.Cross( vecNormal );
|
|
VectorNormalize( vecBasisU );
|
|
|
|
// Create the impact point. Push off the surface a bit.
|
|
Vector vecImpactPoint = pTrace->startpos + pTrace->fraction * ( pTrace->endpos - pTrace->startpos );
|
|
vecImpactPoint += vecNormal;
|
|
|
|
// Generate a quad to represent the plane.
|
|
Vector vecPlanePoints[4];
|
|
vecPlanePoints[0] = vecImpactPoint + ( vecBasisU * -flLength ) + ( vecBasisV * -flLength );
|
|
vecPlanePoints[1] = vecImpactPoint + ( vecBasisU * -flLength ) + ( vecBasisV * flLength );
|
|
vecPlanePoints[2] = vecImpactPoint + ( vecBasisU * flLength ) + ( vecBasisV * flLength );
|
|
vecPlanePoints[3] = vecImpactPoint + ( vecBasisU * flLength ) + ( vecBasisV * -flLength );
|
|
|
|
#if 0
|
|
// Test facing.
|
|
Vector vecEdges[2];
|
|
vecEdges[0] = vecPlanePoints[1] - vecPlanePoints[0];
|
|
vecEdges[1] = vecPlanePoints[2] - vecPlanePoints[0];
|
|
Vector vecCross = vecEdges[0].Cross( vecEdges[1] );
|
|
if ( vecCross.Dot( vecNormal ) < 0.0f )
|
|
{
|
|
// Reverse winding.
|
|
}
|
|
#endif
|
|
|
|
// Draw the plane.
|
|
NDebugOverlay::Triangle( vecPlanePoints[0], vecPlanePoints[1], vecPlanePoints[2], 125, 125, 125, 125, false, 5.0f );
|
|
NDebugOverlay::Triangle( vecPlanePoints[0], vecPlanePoints[2], vecPlanePoints[3], 125, 125, 125, 125, false, 5.0f );
|
|
|
|
NDebugOverlay::Line( vecPlanePoints[0], vecPlanePoints[1], 255, 255, 255, false, 5.0f );
|
|
NDebugOverlay::Line( vecPlanePoints[1], vecPlanePoints[2], 255, 255, 255, false, 5.0f );
|
|
NDebugOverlay::Line( vecPlanePoints[2], vecPlanePoints[3], 255, 255, 255, false, 5.0f );
|
|
NDebugOverlay::Line( vecPlanePoints[3], vecPlanePoints[0], 255, 255, 255, false, 5.0f );
|
|
|
|
// Draw the normal.
|
|
NDebugOverlay::Line( vecImpactPoint, vecImpactPoint + ( vecNormal * flLength ), 255, 0, 0, false, 5.0f );
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructs GameMovement interface
|
|
//-----------------------------------------------------------------------------
|
|
CGameMovement::CGameMovement( void )
|
|
{
|
|
m_nOldWaterLevel = WL_NotInWater;
|
|
m_flWaterEntryTime = 0;
|
|
m_nOnLadder = 0;
|
|
|
|
mv = NULL;
|
|
|
|
memset( m_flStuckCheckTime, 0, sizeof(m_flStuckCheckTime) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CGameMovement::~CGameMovement( void )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Allow bots etc to use slightly different solid masks
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CGameMovement::PlayerSolidMask( bool brushOnly )
|
|
{
|
|
return ( brushOnly ) ? MASK_PLAYERSOLID_BRUSHONLY : MASK_PLAYERSOLID;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : type -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CGameMovement::GetCheckInterval( IntervalType_t type )
|
|
{
|
|
int tickInterval = 1;
|
|
switch ( type )
|
|
{
|
|
default:
|
|
tickInterval = 1;
|
|
break;
|
|
case GROUND:
|
|
tickInterval = CATEGORIZE_GROUND_SURFACE_TICK_INTERVAL;
|
|
break;
|
|
case STUCK:
|
|
// If we are in the process of being "stuck", then try a new position every command tick until m_StuckLast gets reset back down to zero
|
|
if ( player->m_StuckLast != 0 )
|
|
{
|
|
tickInterval = 1;
|
|
}
|
|
else
|
|
{
|
|
if ( gpGlobals->maxClients == 1 )
|
|
{
|
|
tickInterval = CHECK_STUCK_TICK_INTERVAL_SP;
|
|
}
|
|
else
|
|
{
|
|
tickInterval = CHECK_STUCK_TICK_INTERVAL;
|
|
}
|
|
}
|
|
break;
|
|
case LADDER:
|
|
tickInterval = CHECK_LADDER_TICK_INTERVAL;
|
|
break;
|
|
}
|
|
return tickInterval;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : type -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameMovement::CheckInterval( IntervalType_t type )
|
|
{
|
|
int tickInterval = GetCheckInterval( type );
|
|
|
|
if ( g_bMovementOptimizations )
|
|
{
|
|
return (player->CurrentCommandNumber() + player->entindex()) % tickInterval == 0;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : ducked -
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CGameMovement::GetPlayerMins( bool ducked ) const
|
|
{
|
|
return ducked ? VEC_DUCK_HULL_MIN_SCALED( player ) : VEC_HULL_MIN_SCALED( player );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : ducked -
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CGameMovement::GetPlayerMaxs( bool ducked ) const
|
|
{
|
|
return ducked ? VEC_DUCK_HULL_MAX_SCALED( player ) : VEC_HULL_MAX_SCALED( player );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CGameMovement::GetPlayerMins( void ) const
|
|
{
|
|
if ( player->IsObserver() )
|
|
{
|
|
return VEC_OBS_HULL_MIN_SCALED( player );
|
|
}
|
|
else
|
|
{
|
|
return player->m_Local.m_bDucked ? VEC_DUCK_HULL_MIN_SCALED( player ) : VEC_HULL_MIN_SCALED( player );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CGameMovement::GetPlayerMaxs( void ) const
|
|
{
|
|
if ( player->IsObserver() )
|
|
{
|
|
return VEC_OBS_HULL_MAX_SCALED( player );
|
|
}
|
|
else
|
|
{
|
|
return player->m_Local.m_bDucked ? VEC_DUCK_HULL_MAX_SCALED( player ) : VEC_HULL_MAX_SCALED( player );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : ducked -
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CGameMovement::GetPlayerViewOffset( bool ducked ) const
|
|
{
|
|
return ducked ? VEC_DUCK_VIEW_SCALED( player ) : VEC_VIEW_SCALED( player );
|
|
}
|
|
|
|
#if 0
|
|
//-----------------------------------------------------------------------------
|
|
// Traces player movement + position
|
|
//-----------------------------------------------------------------------------
|
|
inline void CGameMovement::TracePlayerBBox( const Vector& start, const Vector& end, unsigned int fMask, int collisionGroup, trace_t& pm )
|
|
{
|
|
VPROF( "CGameMovement::TracePlayerBBox" );
|
|
|
|
Ray_t ray;
|
|
ray.Init( start, end, GetPlayerMins(), GetPlayerMaxs() );
|
|
UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &pm );
|
|
}
|
|
#endif
|
|
|
|
CBaseHandle CGameMovement::TestPlayerPosition( const Vector& pos, int collisionGroup, trace_t& pm )
|
|
{
|
|
Ray_t ray;
|
|
ray.Init( pos, pos, GetPlayerMins(), GetPlayerMaxs() );
|
|
UTIL_TraceRay( ray, PlayerSolidMask(), mv->m_nPlayerHandle.Get(), collisionGroup, &pm );
|
|
if ( (pm.contents & PlayerSolidMask()) && pm.m_pEnt )
|
|
{
|
|
return pm.m_pEnt->GetRefEHandle();
|
|
}
|
|
else
|
|
{
|
|
return INVALID_EHANDLE_INDEX;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
// FIXME FIXME: Does this need to be hooked up?
|
|
bool CGameMovement::IsWet() const
|
|
{
|
|
return ((pev->flags & FL_INRAIN) != 0) || (m_WetTime >= gpGlobals->time);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Plants player footprint decals
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define PLAYER_HALFWIDTH 12
|
|
void CGameMovement::PlantFootprint( surfacedata_t *psurface )
|
|
{
|
|
// Can't plant footprints on fake materials (ladders, wading)
|
|
if ( psurface->gameMaterial != 'X' )
|
|
{
|
|
int footprintDecal = -1;
|
|
|
|
// Figure out which footprint type to plant...
|
|
// Use the wet footprint if we're wet...
|
|
if (IsWet())
|
|
{
|
|
footprintDecal = DECAL_FOOTPRINT_WET;
|
|
}
|
|
else
|
|
{
|
|
// FIXME: Activate this once we decide to pull the trigger on it.
|
|
// NOTE: We could add in snow, mud, others here
|
|
// switch(psurface->gameMaterial)
|
|
// {
|
|
// case 'D':
|
|
// footprintDecal = DECAL_FOOTPRINT_DIRT;
|
|
// break;
|
|
// }
|
|
}
|
|
|
|
if (footprintDecal != -1)
|
|
{
|
|
Vector right;
|
|
AngleVectors( pev->angles, 0, &right, 0 );
|
|
|
|
// Figure out where the top of the stepping leg is
|
|
trace_t tr;
|
|
Vector hipOrigin;
|
|
VectorMA( pev->origin,
|
|
m_IsFootprintOnLeft ? -PLAYER_HALFWIDTH : PLAYER_HALFWIDTH,
|
|
right, hipOrigin );
|
|
|
|
// Find where that leg hits the ground
|
|
UTIL_TraceLine( hipOrigin, hipOrigin + Vector(0, 0, -COORD_EXTENT * 1.74),
|
|
MASK_SOLID_BRUSHONLY, edict(), COLLISION_GROUP_NONE, &tr);
|
|
|
|
unsigned char mType = TEXTURETYPE_Find( &tr );
|
|
|
|
// Splat a decal
|
|
CPVSFilter filter( tr.endpos );
|
|
te->FootprintDecal( filter, 0.0f, &tr.endpos, &right, ENTINDEX(tr.u.ent),
|
|
gDecals[footprintDecal].index, mType );
|
|
|
|
}
|
|
}
|
|
|
|
// Switch feet for next time
|
|
m_IsFootprintOnLeft = !m_IsFootprintOnLeft;
|
|
}
|
|
|
|
#define WET_TIME 5.f // how many seconds till we're completely wet/dry
|
|
#define DRY_TIME 20.f // how many seconds till we're completely wet/dry
|
|
|
|
void CBasePlayer::UpdateWetness()
|
|
{
|
|
// BRJ 1/7/01
|
|
// Check for whether we're in a rainy area....
|
|
// Do this by tracing a line straight down with a size guaranteed to
|
|
// be larger than the map
|
|
// Update wetness based on whether we're in rain or not...
|
|
|
|
trace_t tr;
|
|
UTIL_TraceLine( pev->origin, pev->origin + Vector(0, 0, -COORD_EXTENT * 1.74),
|
|
MASK_SOLID_BRUSHONLY, edict(), COLLISION_GROUP_NONE, &tr);
|
|
if (tr.surface.flags & SURF_WET)
|
|
{
|
|
if (! (pev->flags & FL_INRAIN) )
|
|
{
|
|
// Transition...
|
|
// Figure out how wet we are now (we were drying off...)
|
|
float wetness = (m_WetTime - gpGlobals->time) / DRY_TIME;
|
|
if (wetness < 0.0f)
|
|
wetness = 0.0f;
|
|
|
|
// Here, wet time represents the time at which we get totally wet
|
|
m_WetTime = gpGlobals->time + (1.0 - wetness) * WET_TIME;
|
|
|
|
pev->flags |= FL_INRAIN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((pev->flags & FL_INRAIN) != 0)
|
|
{
|
|
// Transition...
|
|
// Figure out how wet we are now (we were getting more wet...)
|
|
float wetness = 1.0f + (gpGlobals->time - m_WetTime) / WET_TIME;
|
|
if (wetness > 1.0f)
|
|
wetness = 1.0f;
|
|
|
|
// Here, wet time represents the time at which we get totally dry
|
|
m_WetTime = gpGlobals->time + wetness * DRY_TIME;
|
|
|
|
pev->flags &= ~FL_INRAIN;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::CategorizeGroundSurface( trace_t &pm )
|
|
{
|
|
IPhysicsSurfaceProps *physprops = MoveHelper()->GetSurfaceProps();
|
|
player->m_surfaceProps = pm.surface.surfaceProps;
|
|
player->m_pSurfaceData = physprops->GetSurfaceData( player->m_surfaceProps );
|
|
physprops->GetPhysicsProperties( player->m_surfaceProps, NULL, NULL, &player->m_surfaceFriction, NULL );
|
|
|
|
// HACKHACK: Scale this to fudge the relationship between vphysics friction values and player friction values.
|
|
// A value of 0.8f feels pretty normal for vphysics, whereas 1.0f is normal for players.
|
|
// This scaling trivially makes them equivalent. REVISIT if this affects low friction surfaces too much.
|
|
player->m_surfaceFriction *= 1.25f;
|
|
if ( player->m_surfaceFriction > 1.0f )
|
|
player->m_surfaceFriction = 1.0f;
|
|
|
|
player->m_chTextureType = player->m_pSurfaceData->game.material;
|
|
}
|
|
|
|
bool CGameMovement::IsDead( void ) const
|
|
{
|
|
return ( player->m_iHealth <= 0 && !player->IsAlive() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Figures out how the constraint should slow us down
|
|
//-----------------------------------------------------------------------------
|
|
float CGameMovement::ComputeConstraintSpeedFactor( void )
|
|
{
|
|
// If we have a constraint, slow down because of that too.
|
|
if ( !mv || mv->m_flConstraintRadius == 0.0f )
|
|
return 1.0f;
|
|
|
|
float flDistSq = mv->GetAbsOrigin().DistToSqr( mv->m_vecConstraintCenter );
|
|
|
|
float flOuterRadiusSq = mv->m_flConstraintRadius * mv->m_flConstraintRadius;
|
|
float flInnerRadiusSq = mv->m_flConstraintRadius - mv->m_flConstraintWidth;
|
|
flInnerRadiusSq *= flInnerRadiusSq;
|
|
|
|
// Only slow us down if we're inside the constraint ring
|
|
if ((flDistSq <= flInnerRadiusSq) || (flDistSq >= flOuterRadiusSq))
|
|
return 1.0f;
|
|
|
|
// Only slow us down if we're running away from the center
|
|
Vector vecDesired;
|
|
VectorMultiply( m_vecForward, mv->m_flForwardMove, vecDesired );
|
|
VectorMA( vecDesired, mv->m_flSideMove, m_vecRight, vecDesired );
|
|
VectorMA( vecDesired, mv->m_flUpMove, m_vecUp, vecDesired );
|
|
|
|
Vector vecDelta;
|
|
VectorSubtract( mv->GetAbsOrigin(), mv->m_vecConstraintCenter, vecDelta );
|
|
VectorNormalize( vecDelta );
|
|
VectorNormalize( vecDesired );
|
|
if (DotProduct( vecDelta, vecDesired ) < 0.0f)
|
|
return 1.0f;
|
|
|
|
float flFrac = (sqrt(flDistSq) - (mv->m_flConstraintRadius - mv->m_flConstraintWidth)) / mv->m_flConstraintWidth;
|
|
|
|
float flSpeedFactor = Lerp( flFrac, 1.0f, mv->m_flConstraintSpeedFactor );
|
|
return flSpeedFactor;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::CheckParameters( void )
|
|
{
|
|
QAngle v_angle;
|
|
|
|
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->m_pSurfaceData)
|
|
{
|
|
flSpeedFactor = player->m_pSurfaceData->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() )
|
|
{
|
|
player->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;
|
|
}
|
|
}
|
|
|
|
void CGameMovement::ReduceTimers( void )
|
|
{
|
|
float frame_msec = 1000.0f * gpGlobals->frametime;
|
|
|
|
if ( player->m_Local.m_flDucktime > 0 )
|
|
{
|
|
player->m_Local.m_flDucktime -= frame_msec;
|
|
if ( player->m_Local.m_flDucktime < 0 )
|
|
{
|
|
player->m_Local.m_flDucktime = 0;
|
|
}
|
|
}
|
|
if ( player->m_Local.m_flDuckJumpTime > 0 )
|
|
{
|
|
player->m_Local.m_flDuckJumpTime -= frame_msec;
|
|
if ( player->m_Local.m_flDuckJumpTime < 0 )
|
|
{
|
|
player->m_Local.m_flDuckJumpTime = 0;
|
|
}
|
|
}
|
|
if ( player->m_Local.m_flJumpTime > 0 )
|
|
{
|
|
player->m_Local.m_flJumpTime -= frame_msec;
|
|
if ( player->m_Local.m_flJumpTime < 0 )
|
|
{
|
|
player->m_Local.m_flJumpTime = 0;
|
|
}
|
|
}
|
|
if ( player->m_flSwimSoundTime > 0 )
|
|
{
|
|
player->m_flSwimSoundTime -= frame_msec;
|
|
if ( player->m_flSwimSoundTime < 0 )
|
|
{
|
|
player->m_flSwimSoundTime = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pMove -
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove )
|
|
{
|
|
Assert( pMove && pPlayer );
|
|
|
|
float flStoreFrametime = gpGlobals->frametime;
|
|
|
|
//!!HACK HACK: Adrian - slow down all player movement by this factor.
|
|
//!!Blame Yahn for this one.
|
|
gpGlobals->frametime *= pPlayer->GetLaggedMovementValue();
|
|
|
|
ResetGetPointContentsCache();
|
|
|
|
// Cropping movement speed scales mv->m_fForwardSpeed etc. globally
|
|
// Once we crop, we don't want to recursively crop again, so we set the crop
|
|
// flag globally here once per usercmd cycle.
|
|
m_iSpeedCropped = SPEED_CROPPED_RESET;
|
|
|
|
// StartTrackPredictionErrors should have set this
|
|
Assert( player == pPlayer );
|
|
player = pPlayer;
|
|
|
|
mv = pMove;
|
|
mv->m_flMaxSpeed = pPlayer->GetPlayerMaxSpeed();
|
|
|
|
// CheckV( player->CurrentCommandNumber(), "StartPos", mv->GetAbsOrigin() );
|
|
|
|
DiffPrint( "start %f %f %f", mv->GetAbsOrigin().x, mv->GetAbsOrigin().y, mv->GetAbsOrigin().z );
|
|
|
|
// Run the command.
|
|
PlayerMove();
|
|
|
|
FinishMove();
|
|
|
|
DiffPrint( "end %f %f %f", mv->GetAbsOrigin().x, mv->GetAbsOrigin().y, mv->GetAbsOrigin().z );
|
|
|
|
// CheckV( player->CurrentCommandNumber(), "EndPos", mv->GetAbsOrigin() );
|
|
|
|
//This is probably not needed, but just in case.
|
|
gpGlobals->frametime = flStoreFrametime;
|
|
|
|
// player = NULL;
|
|
}
|
|
|
|
void CGameMovement::StartTrackPredictionErrors( CBasePlayer *pPlayer )
|
|
{
|
|
player = pPlayer;
|
|
|
|
#if PREDICTION_ERROR_CHECK_LEVEL > 0
|
|
StartCommand( CBaseEntity::IsServer(), player->CurrentCommandNumber() );
|
|
#endif
|
|
}
|
|
|
|
void CGameMovement::FinishTrackPredictionErrors( CBasePlayer *pPlayer )
|
|
{
|
|
#if PREDICTION_ERROR_CHECK_LEVEL > 0
|
|
Assert( player == pPlayer );
|
|
|
|
// DiffPrint( "end %f", player->m_Local.m_vecPunchAngleVel.m_Value.x );
|
|
|
|
// Call validate at end of checking
|
|
Validate( CBaseEntity::IsServer(), player->CurrentCommandNumber() );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets ground entity
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FinishMove( void )
|
|
{
|
|
mv->m_nOldButtons = mv->m_nButtons;
|
|
}
|
|
|
|
#define PUNCH_DAMPING 9.0f // bigger number makes the response more damped, smaller is less damped
|
|
// currently the system will overshoot, with larger damping values it won't
|
|
#define PUNCH_SPRING_CONSTANT 65.0f // bigger number increases the speed at which the view corrects
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Decays the punchangle toward 0,0,0.
|
|
// Modelled as a damped spring
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::DecayPunchAngle( void )
|
|
{
|
|
if ( player->m_Local.m_vecPunchAngle->LengthSqr() > 0.001 || player->m_Local.m_vecPunchAngleVel->LengthSqr() > 0.001 )
|
|
{
|
|
player->m_Local.m_vecPunchAngle += player->m_Local.m_vecPunchAngleVel * gpGlobals->frametime;
|
|
float damping = 1 - (PUNCH_DAMPING * gpGlobals->frametime);
|
|
|
|
if ( damping < 0 )
|
|
{
|
|
damping = 0;
|
|
}
|
|
player->m_Local.m_vecPunchAngleVel *= damping;
|
|
|
|
// torsional spring
|
|
// UNDONE: Per-axis spring constant?
|
|
float springForceMagnitude = PUNCH_SPRING_CONSTANT * gpGlobals->frametime;
|
|
springForceMagnitude = clamp(springForceMagnitude, 0.f, 2.f );
|
|
player->m_Local.m_vecPunchAngleVel -= player->m_Local.m_vecPunchAngle * springForceMagnitude;
|
|
|
|
// don't wrap around
|
|
player->m_Local.m_vecPunchAngle.Init(
|
|
clamp(player->m_Local.m_vecPunchAngle->x, -89.f, 89.f ),
|
|
clamp(player->m_Local.m_vecPunchAngle->y, -179.f, 179.f ),
|
|
clamp(player->m_Local.m_vecPunchAngle->z, -89.f, 89.f ) );
|
|
}
|
|
else
|
|
{
|
|
player->m_Local.m_vecPunchAngle.Init( 0, 0, 0 );
|
|
player->m_Local.m_vecPunchAngleVel.Init( 0, 0, 0 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::StartGravity( void )
|
|
{
|
|
float ent_gravity;
|
|
|
|
if (player->GetGravity())
|
|
ent_gravity = player->GetGravity();
|
|
else
|
|
ent_gravity = 1.0;
|
|
|
|
// Add gravity so they'll be in the correct position during movement
|
|
// yes, this 0.5 looks wrong, but it's not.
|
|
mv->m_vecVelocity[2] -= (ent_gravity * GetCurrentGravity() * 0.5 * gpGlobals->frametime );
|
|
mv->m_vecVelocity[2] += player->GetBaseVelocity()[2] * gpGlobals->frametime;
|
|
|
|
Vector temp = player->GetBaseVelocity();
|
|
temp[ 2 ] = 0;
|
|
player->SetBaseVelocity( temp );
|
|
|
|
CheckVelocity();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::CheckWaterJump( void )
|
|
{
|
|
Vector flatforward;
|
|
Vector forward;
|
|
Vector flatvelocity;
|
|
float curspeed;
|
|
|
|
AngleVectors( mv->m_vecViewAngles, &forward ); // Determine movement angles
|
|
|
|
// Already water jumping.
|
|
if (player->m_flWaterJumpTime)
|
|
return;
|
|
|
|
// Don't hop out if we just jumped in
|
|
if (mv->m_vecVelocity[2] < -180)
|
|
return; // only hop out if we are moving up
|
|
|
|
// See if we are backing up
|
|
flatvelocity[0] = mv->m_vecVelocity[0];
|
|
flatvelocity[1] = mv->m_vecVelocity[1];
|
|
flatvelocity[2] = 0;
|
|
|
|
// Must be moving
|
|
curspeed = VectorNormalize( flatvelocity );
|
|
|
|
// see if near an edge
|
|
flatforward[0] = forward[0];
|
|
flatforward[1] = forward[1];
|
|
flatforward[2] = 0;
|
|
VectorNormalize (flatforward);
|
|
|
|
// Are we backing into water from steps or something? If so, don't pop forward
|
|
if ( curspeed != 0.0 && ( DotProduct( flatvelocity, flatforward ) < 0.0 ) )
|
|
return;
|
|
|
|
Vector vecStart;
|
|
// Start line trace at waist height (using the center of the player for this here)
|
|
vecStart = mv->GetAbsOrigin() + (GetPlayerMins() + GetPlayerMaxs() ) * 0.5;
|
|
|
|
Vector vecEnd;
|
|
VectorMA( vecStart, 24.0f, flatforward, vecEnd );
|
|
|
|
trace_t tr;
|
|
TracePlayerBBox( vecStart, vecEnd, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, tr );
|
|
if ( tr.fraction < 1.0 ) // solid at waist
|
|
{
|
|
IPhysicsObject *pPhysObj = tr.m_pEnt->VPhysicsGetObject();
|
|
if ( pPhysObj )
|
|
{
|
|
if ( pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
|
|
return;
|
|
}
|
|
|
|
vecStart.z = mv->GetAbsOrigin().z + player->GetViewOffset().z + WATERJUMP_HEIGHT;
|
|
VectorMA( vecStart, 24.0f, flatforward, vecEnd );
|
|
VectorMA( vec3_origin, -50.0f, tr.plane.normal, player->m_vecWaterJumpVel );
|
|
|
|
TracePlayerBBox( vecStart, vecEnd, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, tr );
|
|
if ( tr.fraction == 1.0 ) // open at eye level
|
|
{
|
|
// Now trace down to see if we would actually land on a standable surface.
|
|
VectorCopy( vecEnd, vecStart );
|
|
vecEnd.z -= 1024.0f;
|
|
TracePlayerBBox( vecStart, vecEnd, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, tr );
|
|
if ( ( tr.fraction < 1.0f ) && ( tr.plane.normal.z >= 0.7 ) )
|
|
{
|
|
mv->m_vecVelocity[2] = 256.0f; // Push up
|
|
mv->m_nOldButtons |= IN_JUMP; // Don't jump again until released
|
|
player->AddFlag( FL_WATERJUMP );
|
|
player->m_flWaterJumpTime = 2000.0f; // Do this for 2 seconds
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::WaterJump( void )
|
|
{
|
|
if (player->m_flWaterJumpTime > 10000)
|
|
player->m_flWaterJumpTime = 10000;
|
|
|
|
if (!player->m_flWaterJumpTime)
|
|
return;
|
|
|
|
player->m_flWaterJumpTime -= 1000.0f * gpGlobals->frametime;
|
|
|
|
if (player->m_flWaterJumpTime <= 0 || !player->GetWaterLevel())
|
|
{
|
|
player->m_flWaterJumpTime = 0;
|
|
player->RemoveFlag( FL_WATERJUMP );
|
|
}
|
|
|
|
mv->m_vecVelocity[0] = player->m_vecWaterJumpVel[0];
|
|
mv->m_vecVelocity[1] = player->m_vecWaterJumpVel[1];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::WaterMove( void )
|
|
{
|
|
int i;
|
|
Vector wishvel;
|
|
float wishspeed;
|
|
Vector wishdir;
|
|
Vector start, dest;
|
|
Vector temp;
|
|
trace_t pm;
|
|
float speed, newspeed, addspeed, accelspeed;
|
|
Vector forward, right, up;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
//
|
|
// user intentions
|
|
//
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
wishvel[i] = forward[i]*mv->m_flForwardMove + right[i]*mv->m_flSideMove;
|
|
}
|
|
|
|
// if we have the jump key down, move us up as well
|
|
if (mv->m_nButtons & IN_JUMP)
|
|
{
|
|
wishvel[2] += mv->m_flClientMaxSpeed;
|
|
}
|
|
// Sinking after no other movement occurs
|
|
else if (!mv->m_flForwardMove && !mv->m_flSideMove && !mv->m_flUpMove)
|
|
{
|
|
wishvel[2] -= 60; // drift towards bottom
|
|
}
|
|
else // Go straight up by upmove amount.
|
|
{
|
|
// exaggerate upward movement along forward as well
|
|
float upwardMovememnt = mv->m_flForwardMove * forward.z * 2;
|
|
upwardMovememnt = clamp( upwardMovememnt, 0.f, mv->m_flClientMaxSpeed );
|
|
wishvel[2] += mv->m_flUpMove + upwardMovememnt;
|
|
}
|
|
|
|
// Copy it over and determine speed
|
|
VectorCopy (wishvel, wishdir);
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
// Cap speed.
|
|
if (wishspeed > mv->m_flMaxSpeed)
|
|
{
|
|
VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
|
|
wishspeed = mv->m_flMaxSpeed;
|
|
}
|
|
|
|
// Slow us down a bit.
|
|
wishspeed *= 0.8;
|
|
|
|
// Water friction
|
|
VectorCopy(mv->m_vecVelocity, temp);
|
|
speed = VectorNormalize(temp);
|
|
if (speed)
|
|
{
|
|
newspeed = speed - gpGlobals->frametime * speed * sv_friction.GetFloat() * player->m_surfaceFriction;
|
|
if (newspeed < 0.1f)
|
|
{
|
|
newspeed = 0;
|
|
}
|
|
|
|
VectorScale (mv->m_vecVelocity, newspeed/speed, mv->m_vecVelocity);
|
|
}
|
|
else
|
|
{
|
|
newspeed = 0;
|
|
}
|
|
|
|
// water acceleration
|
|
if (wishspeed >= 0.1f) // old !
|
|
{
|
|
addspeed = wishspeed - newspeed;
|
|
if (addspeed > 0)
|
|
{
|
|
VectorNormalize(wishvel);
|
|
accelspeed = sv_accelerate.GetFloat() * wishspeed * gpGlobals->frametime * player->m_surfaceFriction;
|
|
if (accelspeed > addspeed)
|
|
{
|
|
accelspeed = addspeed;
|
|
}
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
float deltaSpeed = accelspeed * wishvel[i];
|
|
mv->m_vecVelocity[i] += deltaSpeed;
|
|
mv->m_outWishVel[i] += deltaSpeed;
|
|
}
|
|
}
|
|
}
|
|
|
|
VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
|
|
|
|
// Now move
|
|
// assume it is a stair or a slope, so press down from stepheight above
|
|
VectorMA (mv->GetAbsOrigin(), gpGlobals->frametime, mv->m_vecVelocity, dest);
|
|
|
|
TracePlayerBBox( mv->GetAbsOrigin(), dest, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
if ( pm.fraction == 1.0f )
|
|
{
|
|
VectorCopy( dest, start );
|
|
if ( player->m_Local.m_bAllowAutoMovement )
|
|
{
|
|
start[2] += player->m_Local.m_flStepSize + 1;
|
|
}
|
|
|
|
TracePlayerBBox( start, dest, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
|
|
if (!pm.startsolid && !pm.allsolid)
|
|
{
|
|
float stepDist = pm.endpos.z - mv->GetAbsOrigin().z;
|
|
mv->m_outStepHeight += stepDist;
|
|
// walked up the step, so just keep result and exit
|
|
mv->SetAbsOrigin( pm.endpos );
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
return;
|
|
}
|
|
|
|
// Try moving straight along out normal path.
|
|
TryPlayerMove();
|
|
}
|
|
else
|
|
{
|
|
if ( !player->GetGroundEntity() )
|
|
{
|
|
TryPlayerMove();
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
return;
|
|
}
|
|
|
|
StepMove( dest, pm );
|
|
}
|
|
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Does the basic move attempting to climb up step heights. It uses
|
|
// the mv->GetAbsOrigin() and mv->m_vecVelocity. It returns a new
|
|
// new mv->GetAbsOrigin(), mv->m_vecVelocity, and mv->m_outStepHeight.
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::StepMove( Vector &vecDestination, trace_t &trace )
|
|
{
|
|
Vector vecEndPos;
|
|
VectorCopy( vecDestination, vecEndPos );
|
|
|
|
// Try sliding forward both on ground and up 16 pixels
|
|
// take the move that goes farthest
|
|
Vector vecPos, vecVel;
|
|
VectorCopy( mv->GetAbsOrigin(), vecPos );
|
|
VectorCopy( mv->m_vecVelocity, vecVel );
|
|
|
|
// Slide move down.
|
|
TryPlayerMove( &vecEndPos, &trace );
|
|
|
|
// Down results.
|
|
Vector vecDownPos, vecDownVel;
|
|
VectorCopy( mv->GetAbsOrigin(), vecDownPos );
|
|
VectorCopy( mv->m_vecVelocity, vecDownVel );
|
|
|
|
// Reset original values.
|
|
mv->SetAbsOrigin( vecPos );
|
|
VectorCopy( vecVel, mv->m_vecVelocity );
|
|
|
|
// Move up a stair height.
|
|
VectorCopy( mv->GetAbsOrigin(), vecEndPos );
|
|
if ( player->m_Local.m_bAllowAutoMovement )
|
|
{
|
|
vecEndPos.z += player->m_Local.m_flStepSize + DIST_EPSILON;
|
|
}
|
|
|
|
TracePlayerBBox( mv->GetAbsOrigin(), vecEndPos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
if ( !trace.startsolid && !trace.allsolid )
|
|
{
|
|
mv->SetAbsOrigin( trace.endpos );
|
|
}
|
|
|
|
// Slide move up.
|
|
TryPlayerMove();
|
|
|
|
// Move down a stair (attempt to).
|
|
VectorCopy( mv->GetAbsOrigin(), vecEndPos );
|
|
if ( player->m_Local.m_bAllowAutoMovement )
|
|
{
|
|
vecEndPos.z -= player->m_Local.m_flStepSize + DIST_EPSILON;
|
|
}
|
|
|
|
TracePlayerBBox( mv->GetAbsOrigin(), vecEndPos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
|
|
// If we are not on the ground any more then use the original movement attempt.
|
|
if ( trace.plane.normal[2] < 0.7 )
|
|
{
|
|
mv->SetAbsOrigin( vecDownPos );
|
|
VectorCopy( vecDownVel, mv->m_vecVelocity );
|
|
float flStepDist = mv->GetAbsOrigin().z - vecPos.z;
|
|
if ( flStepDist > 0.0f )
|
|
{
|
|
mv->m_outStepHeight += flStepDist;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If the trace ended up in empty space, copy the end over to the origin.
|
|
if ( !trace.startsolid && !trace.allsolid )
|
|
{
|
|
mv->SetAbsOrigin( trace.endpos );
|
|
}
|
|
|
|
// Copy this origin to up.
|
|
Vector vecUpPos;
|
|
VectorCopy( mv->GetAbsOrigin(), vecUpPos );
|
|
|
|
// decide which one went farther
|
|
float flDownDist = ( vecDownPos.x - vecPos.x ) * ( vecDownPos.x - vecPos.x ) + ( vecDownPos.y - vecPos.y ) * ( vecDownPos.y - vecPos.y );
|
|
float flUpDist = ( vecUpPos.x - vecPos.x ) * ( vecUpPos.x - vecPos.x ) + ( vecUpPos.y - vecPos.y ) * ( vecUpPos.y - vecPos.y );
|
|
if ( flDownDist > flUpDist )
|
|
{
|
|
mv->SetAbsOrigin( vecDownPos );
|
|
VectorCopy( vecDownVel, mv->m_vecVelocity );
|
|
}
|
|
else
|
|
{
|
|
// copy z value from slide move
|
|
mv->m_vecVelocity.z = vecDownVel.z;
|
|
}
|
|
|
|
float flStepDist = mv->GetAbsOrigin().z - vecPos.z;
|
|
if ( flStepDist > 0 )
|
|
{
|
|
mv->m_outStepHeight += flStepDist;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::Friction( void )
|
|
{
|
|
float speed, newspeed, control;
|
|
float friction;
|
|
float drop;
|
|
|
|
// If we are in water jump cycle, don't apply friction
|
|
if (player->m_flWaterJumpTime)
|
|
return;
|
|
|
|
// Calculate speed
|
|
speed = VectorLength( mv->m_vecVelocity );
|
|
|
|
// If too slow, return
|
|
if (speed < 0.1f)
|
|
{
|
|
return;
|
|
}
|
|
|
|
drop = 0;
|
|
|
|
// apply ground friction
|
|
if (player->GetGroundEntity() != NULL) // On an entity that is the ground
|
|
{
|
|
friction = sv_friction.GetFloat() * player->m_surfaceFriction;
|
|
|
|
// Bleed off some speed, but if we have less than the bleed
|
|
// threshold, bleed the threshold amount.
|
|
|
|
if ( IsX360() )
|
|
{
|
|
if( player->m_Local.m_bDucked )
|
|
{
|
|
control = (speed < sv_stopspeed.GetFloat()) ? sv_stopspeed.GetFloat() : speed;
|
|
}
|
|
else
|
|
{
|
|
#if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL )
|
|
control = (speed < sv_stopspeed.GetFloat()) ? sv_stopspeed.GetFloat() : speed;
|
|
#else
|
|
control = (speed < sv_stopspeed.GetFloat()) ? (sv_stopspeed.GetFloat() * 2.0f) : speed;
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
control = (speed < sv_stopspeed.GetFloat()) ? sv_stopspeed.GetFloat() : speed;
|
|
}
|
|
|
|
// Add the amount to the drop amount.
|
|
drop += control*friction*gpGlobals->frametime;
|
|
}
|
|
|
|
// scale the velocity
|
|
newspeed = speed - drop;
|
|
if (newspeed < 0)
|
|
newspeed = 0;
|
|
|
|
if ( newspeed != speed )
|
|
{
|
|
// Determine proportion of old speed we are using.
|
|
newspeed /= speed;
|
|
// Adjust velocity according to proportion.
|
|
VectorScale( mv->m_vecVelocity, newspeed, mv->m_vecVelocity );
|
|
}
|
|
|
|
mv->m_outWishVel -= (1.f-newspeed) * mv->m_vecVelocity;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FinishGravity( void )
|
|
{
|
|
float ent_gravity;
|
|
|
|
if ( player->m_flWaterJumpTime )
|
|
return;
|
|
|
|
if ( player->GetGravity() )
|
|
ent_gravity = player->GetGravity();
|
|
else
|
|
ent_gravity = 1.0;
|
|
|
|
// Get the correct velocity for the end of the dt
|
|
mv->m_vecVelocity[2] -= (ent_gravity * GetCurrentGravity() * gpGlobals->frametime * 0.5);
|
|
|
|
CheckVelocity();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : wishdir -
|
|
// accel -
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::AirAccelerate( Vector& wishdir, float wishspeed, float accel )
|
|
{
|
|
int i;
|
|
float addspeed, accelspeed, currentspeed;
|
|
float wishspd;
|
|
|
|
wishspd = wishspeed;
|
|
|
|
if (player->pl.deadflag)
|
|
return;
|
|
|
|
if (player->m_flWaterJumpTime)
|
|
return;
|
|
|
|
// Cap speed
|
|
if ( wishspd > GetAirSpeedCap() )
|
|
wishspd = GetAirSpeedCap();
|
|
|
|
// Determine veer amount
|
|
currentspeed = mv->m_vecVelocity.Dot(wishdir);
|
|
|
|
// See how much to add
|
|
addspeed = wishspd - currentspeed;
|
|
|
|
// If not adding any, done.
|
|
if (addspeed <= 0)
|
|
return;
|
|
|
|
// Determine acceleration speed after acceleration
|
|
accelspeed = accel * wishspeed * gpGlobals->frametime * player->m_surfaceFriction;
|
|
|
|
// Cap it
|
|
if (accelspeed > addspeed)
|
|
accelspeed = addspeed;
|
|
|
|
// Adjust pmove vel.
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
mv->m_vecVelocity[i] += accelspeed * wishdir[i];
|
|
mv->m_outWishVel[i] += accelspeed * wishdir[i];
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::AirMove( void )
|
|
{
|
|
int i;
|
|
Vector wishvel;
|
|
float fmove, smove;
|
|
Vector wishdir;
|
|
float wishspeed;
|
|
Vector forward, right, up;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
// Copy movement amounts
|
|
fmove = mv->m_flForwardMove;
|
|
smove = mv->m_flSideMove;
|
|
|
|
// Zero out z components of movement vectors
|
|
forward[2] = 0;
|
|
right[2] = 0;
|
|
VectorNormalize(forward); // Normalize remainder of vectors
|
|
VectorNormalize(right); //
|
|
|
|
for (i=0 ; i<2 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
wishvel[2] = 0; // Zero out z part of velocity
|
|
|
|
VectorCopy (wishvel, wishdir); // Determine maginitude of speed of move
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
//
|
|
// clamp to server defined max speed
|
|
//
|
|
if ( wishspeed != 0 && (wishspeed > mv->m_flMaxSpeed))
|
|
{
|
|
VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
|
|
wishspeed = mv->m_flMaxSpeed;
|
|
}
|
|
|
|
AirAccelerate( wishdir, wishspeed, sv_airaccelerate.GetFloat() );
|
|
|
|
// Add in any base velocity to the current velocity.
|
|
VectorAdd(mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
|
|
TryPlayerMove();
|
|
|
|
// Now pull the base velocity back out. Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
}
|
|
|
|
|
|
bool CGameMovement::CanAccelerate()
|
|
{
|
|
// Dead players don't accelerate.
|
|
if (player->pl.deadflag)
|
|
return false;
|
|
|
|
// If waterjumping, don't accelerate
|
|
if (player->m_flWaterJumpTime)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : wishdir -
|
|
// wishspeed -
|
|
// accel -
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::Accelerate( Vector& wishdir, float wishspeed, float accel )
|
|
{
|
|
int i;
|
|
float addspeed, accelspeed, currentspeed;
|
|
|
|
// This gets overridden because some games (CSPort) want to allow dead (observer) players
|
|
// to be able to move around.
|
|
if ( !CanAccelerate() )
|
|
return;
|
|
|
|
// See if we are changing direction a bit
|
|
currentspeed = mv->m_vecVelocity.Dot(wishdir);
|
|
|
|
// Reduce wishspeed by the amount of veer.
|
|
addspeed = wishspeed - currentspeed;
|
|
|
|
// If not going to add any speed, done.
|
|
if (addspeed <= 0)
|
|
return;
|
|
|
|
// Determine amount of accleration.
|
|
accelspeed = accel * gpGlobals->frametime * wishspeed * player->m_surfaceFriction;
|
|
|
|
// Cap at addspeed
|
|
if (accelspeed > addspeed)
|
|
accelspeed = addspeed;
|
|
|
|
// Adjust velocity.
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
mv->m_vecVelocity[i] += accelspeed * wishdir[i];
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Try to keep a walking player on the ground when running down slopes etc
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::StayOnGround( void )
|
|
{
|
|
trace_t trace;
|
|
Vector start( mv->GetAbsOrigin() );
|
|
Vector end( mv->GetAbsOrigin() );
|
|
start.z += 2;
|
|
end.z -= player->GetStepSize();
|
|
|
|
// See how far up we can go without getting stuck
|
|
|
|
TracePlayerBBox( mv->GetAbsOrigin(), start, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
start = trace.endpos;
|
|
|
|
// using trace.startsolid is unreliable here, it doesn't get set when
|
|
// tracing bounding box vs. terrain
|
|
|
|
// Now trace down from a known safe position
|
|
TracePlayerBBox( start, end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
if ( trace.fraction > 0.0f && // must go somewhere
|
|
trace.fraction < 1.0f && // must hit something
|
|
!trace.startsolid && // can't be embedded in a solid
|
|
trace.plane.normal[2] >= 0.7 ) // can't hit a steep slope that we can't stand on anyway
|
|
{
|
|
float flDelta = fabs(mv->GetAbsOrigin().z - trace.endpos.z);
|
|
|
|
//This is incredibly hacky. The real problem is that trace returning that strange value we can't network over.
|
|
if ( flDelta > 0.5f * COORD_RESOLUTION)
|
|
{
|
|
mv->SetAbsOrigin( trace.endpos );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::WalkMove( void )
|
|
{
|
|
int i;
|
|
|
|
Vector wishvel;
|
|
float spd;
|
|
float fmove, smove;
|
|
Vector wishdir;
|
|
float wishspeed;
|
|
|
|
Vector dest;
|
|
trace_t pm;
|
|
Vector forward, right, up;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
CHandle< CBaseEntity > oldground;
|
|
oldground = player->GetGroundEntity();
|
|
|
|
// Copy movement amounts
|
|
fmove = mv->m_flForwardMove;
|
|
smove = mv->m_flSideMove;
|
|
|
|
// Zero out z components of movement vectors
|
|
if ( g_bMovementOptimizations )
|
|
{
|
|
if ( forward[2] != 0 )
|
|
{
|
|
forward[2] = 0;
|
|
VectorNormalize( forward );
|
|
}
|
|
|
|
if ( right[2] != 0 )
|
|
{
|
|
right[2] = 0;
|
|
VectorNormalize( right );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
forward[2] = 0;
|
|
right[2] = 0;
|
|
|
|
VectorNormalize (forward); // Normalize remainder of vectors.
|
|
VectorNormalize (right); //
|
|
}
|
|
|
|
for (i=0 ; i<2 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
|
|
wishvel[2] = 0; // Zero out z part of velocity
|
|
|
|
VectorCopy (wishvel, wishdir); // Determine maginitude of speed of move
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
//
|
|
// Clamp to server defined max speed
|
|
//
|
|
if ((wishspeed != 0.0f) && (wishspeed > mv->m_flMaxSpeed))
|
|
{
|
|
VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
|
|
wishspeed = mv->m_flMaxSpeed;
|
|
}
|
|
|
|
// Set pmove velocity
|
|
mv->m_vecVelocity[2] = 0;
|
|
Accelerate ( wishdir, wishspeed, sv_accelerate.GetFloat() );
|
|
mv->m_vecVelocity[2] = 0;
|
|
|
|
// Add in any base velocity to the current velocity.
|
|
VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
|
|
spd = VectorLength( mv->m_vecVelocity );
|
|
|
|
if ( spd < 1.0f )
|
|
{
|
|
mv->m_vecVelocity.Init();
|
|
// Now pull the base velocity back out. Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
return;
|
|
}
|
|
|
|
// first try just moving to the destination
|
|
dest[0] = mv->GetAbsOrigin()[0] + mv->m_vecVelocity[0]*gpGlobals->frametime;
|
|
dest[1] = mv->GetAbsOrigin()[1] + mv->m_vecVelocity[1]*gpGlobals->frametime;
|
|
dest[2] = mv->GetAbsOrigin()[2];
|
|
|
|
// first try moving directly to the next spot
|
|
TracePlayerBBox( mv->GetAbsOrigin(), dest, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
|
|
// If we made it all the way, then copy trace end as new player position.
|
|
mv->m_outWishVel += wishdir * wishspeed;
|
|
|
|
if ( pm.fraction == 1 )
|
|
{
|
|
mv->SetAbsOrigin( pm.endpos );
|
|
// Now pull the base velocity back out. Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
|
|
StayOnGround();
|
|
return;
|
|
}
|
|
|
|
// Don't walk up stairs if not on ground.
|
|
if ( oldground == NULL && player->GetWaterLevel() == 0 )
|
|
{
|
|
// Now pull the base velocity back out. Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
return;
|
|
}
|
|
|
|
// If we are jumping out of water, don't do anything more.
|
|
if ( player->m_flWaterJumpTime )
|
|
{
|
|
// Now pull the base velocity back out. Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
return;
|
|
}
|
|
|
|
StepMove( dest, pm );
|
|
|
|
// Now pull the base velocity back out. Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
|
|
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
|
|
StayOnGround();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FullWalkMove( )
|
|
{
|
|
if ( !CheckWater() )
|
|
{
|
|
StartGravity();
|
|
}
|
|
|
|
// If we are leaping out of the water, just update the counters.
|
|
if (player->m_flWaterJumpTime)
|
|
{
|
|
WaterJump();
|
|
TryPlayerMove();
|
|
// See if we are still in water?
|
|
CheckWater();
|
|
return;
|
|
}
|
|
|
|
// If we are swimming in the water, see if we are nudging against a place we can jump up out
|
|
// of, and, if so, start out jump. Otherwise, if we are not moving up, then reset jump timer to 0
|
|
if ( player->GetWaterLevel() >= WL_Waist )
|
|
{
|
|
if ( player->GetWaterLevel() == WL_Waist )
|
|
{
|
|
CheckWaterJump();
|
|
}
|
|
|
|
// If we are falling again, then we must not trying to jump out of water any more.
|
|
if ( mv->m_vecVelocity[2] < 0 &&
|
|
player->m_flWaterJumpTime )
|
|
{
|
|
player->m_flWaterJumpTime = 0;
|
|
}
|
|
|
|
// Was jump button pressed?
|
|
if (mv->m_nButtons & IN_JUMP)
|
|
{
|
|
CheckJumpButton();
|
|
}
|
|
else
|
|
{
|
|
mv->m_nOldButtons &= ~IN_JUMP;
|
|
}
|
|
|
|
// Perform regular water movement
|
|
WaterMove();
|
|
|
|
// Redetermine position vars
|
|
CategorizePosition();
|
|
|
|
// If we are on ground, no downward velocity.
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
mv->m_vecVelocity[2] = 0;
|
|
}
|
|
}
|
|
else
|
|
// Not fully underwater
|
|
{
|
|
// Was jump button pressed?
|
|
if (mv->m_nButtons & IN_JUMP)
|
|
{
|
|
CheckJumpButton();
|
|
}
|
|
else
|
|
{
|
|
mv->m_nOldButtons &= ~IN_JUMP;
|
|
}
|
|
|
|
// Fricion is handled before we add in any base velocity. That way, if we are on a conveyor,
|
|
// we don't slow when standing still, relative to the conveyor.
|
|
if (player->GetGroundEntity() != NULL)
|
|
{
|
|
mv->m_vecVelocity[2] = 0.0;
|
|
Friction();
|
|
}
|
|
|
|
// Make sure velocity is valid.
|
|
CheckVelocity();
|
|
|
|
if (player->GetGroundEntity() != NULL)
|
|
{
|
|
WalkMove();
|
|
}
|
|
else
|
|
{
|
|
AirMove(); // Take into account movement when in air.
|
|
}
|
|
|
|
// Set final flags.
|
|
CategorizePosition();
|
|
|
|
// Make sure velocity is valid.
|
|
CheckVelocity();
|
|
|
|
// Add any remaining gravitational component.
|
|
if ( !CheckWater() )
|
|
{
|
|
FinishGravity();
|
|
}
|
|
|
|
// If we are on ground, no downward velocity.
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
mv->m_vecVelocity[2] = 0;
|
|
}
|
|
CheckFalling();
|
|
}
|
|
|
|
if ( ( m_nOldWaterLevel == WL_NotInWater && player->GetWaterLevel() != WL_NotInWater ) ||
|
|
( m_nOldWaterLevel != WL_NotInWater && player->GetWaterLevel() == WL_NotInWater ) )
|
|
{
|
|
PlaySwimSound();
|
|
#if !defined( CLIENT_DLL )
|
|
player->Splash();
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FullObserverMove( void )
|
|
{
|
|
int mode = player->GetObserverMode();
|
|
|
|
if ( mode == OBS_MODE_IN_EYE || mode == OBS_MODE_CHASE )
|
|
{
|
|
CBaseEntity * target = player->GetObserverTarget();
|
|
|
|
if ( target != NULL )
|
|
{
|
|
mv->SetAbsOrigin( target->GetAbsOrigin() );
|
|
mv->m_vecViewAngles = target->GetAbsAngles();
|
|
mv->m_vecVelocity = target->GetAbsVelocity();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if ( mode != OBS_MODE_ROAMING )
|
|
{
|
|
// don't move in fixed or death cam mode
|
|
return;
|
|
}
|
|
|
|
if ( sv_specnoclip.GetBool() )
|
|
{
|
|
// roam in noclip mode
|
|
FullNoClipMove( sv_specspeed.GetFloat(), sv_specaccelerate.GetFloat() );
|
|
return;
|
|
}
|
|
|
|
// do a full clipped free roam move:
|
|
|
|
Vector wishvel;
|
|
Vector forward, right, up;
|
|
Vector wishdir, wishend;
|
|
float wishspeed;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
// Copy movement amounts
|
|
|
|
float factor = sv_specspeed.GetFloat();
|
|
|
|
if ( mv->m_nButtons & IN_SPEED )
|
|
{
|
|
factor /= 2.0f;
|
|
}
|
|
|
|
float fmove = mv->m_flForwardMove * factor;
|
|
float smove = mv->m_flSideMove * factor;
|
|
|
|
VectorNormalize (forward); // Normalize remainder of vectors
|
|
VectorNormalize (right); //
|
|
|
|
for (int i=0 ; i<3 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
wishvel[2] += mv->m_flUpMove;
|
|
|
|
VectorCopy (wishvel, wishdir); // Determine maginitude of speed of move
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
//
|
|
// Clamp to server defined max speed
|
|
//
|
|
|
|
float maxspeed = sv_maxvelocity.GetFloat();
|
|
|
|
|
|
if (wishspeed > maxspeed )
|
|
{
|
|
VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
|
|
wishspeed = maxspeed;
|
|
}
|
|
|
|
// Set pmove velocity, give observer 50% acceration bonus
|
|
Accelerate ( wishdir, wishspeed, sv_specaccelerate.GetFloat() );
|
|
|
|
float spd = VectorLength( mv->m_vecVelocity );
|
|
if (spd < 1.0f)
|
|
{
|
|
mv->m_vecVelocity.Init();
|
|
return;
|
|
}
|
|
|
|
float friction = sv_friction.GetFloat();
|
|
|
|
// Add the amount to the drop amount.
|
|
float drop = spd * friction * gpGlobals->frametime;
|
|
|
|
// scale the velocity
|
|
float newspeed = spd - drop;
|
|
|
|
if (newspeed < 0)
|
|
newspeed = 0;
|
|
|
|
// Determine proportion of old speed we are using.
|
|
newspeed /= spd;
|
|
|
|
VectorScale( mv->m_vecVelocity, newspeed, mv->m_vecVelocity );
|
|
|
|
CheckVelocity();
|
|
|
|
TryPlayerMove();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FullNoClipMove( float factor, float maxacceleration )
|
|
{
|
|
Vector wishvel;
|
|
Vector forward, right, up;
|
|
Vector wishdir;
|
|
float wishspeed;
|
|
float maxspeed = sv_maxspeed.GetFloat() * factor;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
if ( mv->m_nButtons & IN_SPEED )
|
|
{
|
|
factor /= 2.0f;
|
|
}
|
|
|
|
// Copy movement amounts
|
|
float fmove = mv->m_flForwardMove * factor;
|
|
float smove = mv->m_flSideMove * factor;
|
|
|
|
VectorNormalize (forward); // Normalize remainder of vectors
|
|
VectorNormalize (right); //
|
|
|
|
for (int i=0 ; i<3 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
wishvel[2] += mv->m_flUpMove * factor;
|
|
|
|
VectorCopy (wishvel, wishdir); // Determine maginitude of speed of move
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
//
|
|
// Clamp to server defined max speed
|
|
//
|
|
if (wishspeed > maxspeed )
|
|
{
|
|
VectorScale (wishvel, maxspeed/wishspeed, wishvel);
|
|
wishspeed = maxspeed;
|
|
}
|
|
|
|
if ( maxacceleration > 0.0 )
|
|
{
|
|
// Set pmove velocity
|
|
Accelerate ( wishdir, wishspeed, maxacceleration );
|
|
|
|
float spd = VectorLength( mv->m_vecVelocity );
|
|
if (spd < 1.0f)
|
|
{
|
|
mv->m_vecVelocity.Init();
|
|
return;
|
|
}
|
|
|
|
// Bleed off some speed, but if we have less than the bleed
|
|
// threshhold, bleed the theshold amount.
|
|
float control = (spd < maxspeed/4.0) ? maxspeed/4.0 : spd;
|
|
|
|
float friction = sv_friction.GetFloat() * player->m_surfaceFriction;
|
|
|
|
// Add the amount to the drop amount.
|
|
float drop = control * friction * gpGlobals->frametime;
|
|
|
|
// scale the velocity
|
|
float newspeed = spd - drop;
|
|
if (newspeed < 0)
|
|
newspeed = 0;
|
|
|
|
// Determine proportion of old speed we are using.
|
|
newspeed /= spd;
|
|
VectorScale( mv->m_vecVelocity, newspeed, mv->m_vecVelocity );
|
|
}
|
|
else
|
|
{
|
|
VectorCopy( wishvel, mv->m_vecVelocity );
|
|
}
|
|
|
|
// Just move ( don't clip or anything )
|
|
Vector out;
|
|
VectorMA( mv->GetAbsOrigin(), gpGlobals->frametime, mv->m_vecVelocity, out );
|
|
mv->SetAbsOrigin( out );
|
|
|
|
// Zero out velocity if in noaccel mode
|
|
if ( maxacceleration < 0.0f )
|
|
{
|
|
mv->m_vecVelocity.Init();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Checks to see if we should actually jump
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::PlaySwimSound()
|
|
{
|
|
MoveHelper()->StartSound( mv->GetAbsOrigin(), "Player.Swim" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameMovement::CheckJumpButton( void )
|
|
{
|
|
if (player->pl.deadflag)
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP ; // don't jump again until released
|
|
return false;
|
|
}
|
|
|
|
// See if we are waterjumping. If so, decrement count and return.
|
|
if (player->m_flWaterJumpTime)
|
|
{
|
|
player->m_flWaterJumpTime -= gpGlobals->frametime;
|
|
if (player->m_flWaterJumpTime < 0)
|
|
player->m_flWaterJumpTime = 0;
|
|
|
|
return false;
|
|
}
|
|
|
|
// If we are in the water most of the way...
|
|
if ( player->GetWaterLevel() >= 2 )
|
|
{
|
|
// swimming, not jumping
|
|
SetGroundEntity( NULL );
|
|
|
|
if(player->GetWaterType() == CONTENTS_WATER) // We move up a certain amount
|
|
mv->m_vecVelocity[2] = 100;
|
|
else if (player->GetWaterType() == CONTENTS_SLIME)
|
|
mv->m_vecVelocity[2] = 80;
|
|
|
|
// play swiming sound
|
|
if ( player->m_flSwimSoundTime <= 0 )
|
|
{
|
|
// Don't play sound again for 1 second
|
|
player->m_flSwimSoundTime = 1000;
|
|
PlaySwimSound();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// No more effect
|
|
if (player->GetGroundEntity() == NULL)
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP;
|
|
return false; // in air, so no effect
|
|
}
|
|
|
|
// Don't allow jumping when the player is in a stasis field.
|
|
#ifndef HL2_EPISODIC
|
|
if ( player->m_Local.m_bSlowMovement )
|
|
return false;
|
|
#endif
|
|
|
|
if ( mv->m_nOldButtons & IN_JUMP )
|
|
return false; // don't pogo stick
|
|
|
|
// Cannot jump will in the unduck transition.
|
|
if ( player->m_Local.m_bDucking && ( player->GetFlags() & FL_DUCKING ) )
|
|
return false;
|
|
|
|
// Still updating the eye position.
|
|
if ( player->m_Local.m_flDuckJumpTime > 0.0f )
|
|
return false;
|
|
|
|
|
|
// In the air now.
|
|
SetGroundEntity( NULL );
|
|
|
|
player->PlayStepSound( (Vector &)mv->GetAbsOrigin(), player->m_pSurfaceData, 1.0, true );
|
|
|
|
MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
|
|
|
|
float flGroundFactor = 1.0f;
|
|
if (player->m_pSurfaceData)
|
|
{
|
|
flGroundFactor = player->m_pSurfaceData->game.jumpFactor;
|
|
}
|
|
|
|
float flMul;
|
|
if ( g_bMovementOptimizations )
|
|
{
|
|
#if defined(HL2_DLL) || defined(HL2_CLIENT_DLL)
|
|
Assert( GetCurrentGravity() == 600.0f );
|
|
flMul = 160.0f; // approx. 21 units.
|
|
#else
|
|
Assert( GetCurrentGravity() == 800.0f );
|
|
flMul = 268.3281572999747f;
|
|
#endif
|
|
|
|
}
|
|
else
|
|
{
|
|
flMul = sqrt(2 * GetCurrentGravity() * GAMEMOVEMENT_JUMP_HEIGHT);
|
|
}
|
|
|
|
// Acclerate upward
|
|
// If we are ducking...
|
|
float startz = mv->m_vecVelocity[2];
|
|
if ( ( player->m_Local.m_bDucking ) || ( player->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 * flMul; // 2 * gravity * height
|
|
}
|
|
else
|
|
{
|
|
mv->m_vecVelocity[2] += flGroundFactor * flMul; // 2 * gravity * height
|
|
}
|
|
|
|
// Add a little forward velocity based on your current forward velocity - if you are not sprinting.
|
|
#if defined( HL2_DLL ) || defined( HL2_CLIENT_DLL )
|
|
if ( gpGlobals->maxClients == 1 )
|
|
{
|
|
CHLMoveData *pMoveData = ( CHLMoveData* )mv;
|
|
Vector vecForward;
|
|
AngleVectors( mv->m_vecViewAngles, &vecForward );
|
|
vecForward.z = 0;
|
|
VectorNormalize( vecForward );
|
|
|
|
// We give a certain percentage of the current forward movement as a bonus to the jump speed. That bonus is clipped
|
|
// to not accumulate over time.
|
|
float flSpeedBoostPerc = ( !pMoveData->m_bIsSprinting && !player->m_Local.m_bDucked ) ? 0.5f : 0.1f;
|
|
float flSpeedAddition = fabs( mv->m_flForwardMove * flSpeedBoostPerc );
|
|
float flMaxSpeed = mv->m_flMaxSpeed + ( mv->m_flMaxSpeed * flSpeedBoostPerc );
|
|
float flNewSpeed = ( flSpeedAddition + mv->m_vecVelocity.Length2D() );
|
|
|
|
// If we're over the maximum, we want to only boost as much as will get us to the goal speed
|
|
if ( flNewSpeed > flMaxSpeed )
|
|
{
|
|
flSpeedAddition -= flNewSpeed - flMaxSpeed;
|
|
}
|
|
|
|
if ( mv->m_flForwardMove < 0.0f )
|
|
flSpeedAddition *= -1.0f;
|
|
|
|
// Add it on
|
|
VectorAdd( (vecForward*flSpeedAddition), mv->m_vecVelocity, mv->m_vecVelocity );
|
|
}
|
|
#endif
|
|
|
|
FinishGravity();
|
|
|
|
CheckV( player->CurrentCommandNumber(), "CheckJump", mv->m_vecVelocity );
|
|
|
|
mv->m_outJumpVel.z += mv->m_vecVelocity[2] - startz;
|
|
mv->m_outStepHeight += 0.15f;
|
|
|
|
OnJump(mv->m_outJumpVel.z);
|
|
|
|
// Set jump time.
|
|
if ( gpGlobals->maxClients == 1 )
|
|
{
|
|
player->m_Local.m_flJumpTime = GAMEMOVEMENT_JUMP_TIME;
|
|
player->m_Local.m_bInDuckJump = true;
|
|
}
|
|
|
|
#if defined( HL2_DLL )
|
|
|
|
if ( xc_uncrouch_on_jump.GetBool() )
|
|
{
|
|
// Uncrouch when jumping
|
|
if ( player->GetToggledDuckState() )
|
|
{
|
|
player->ToggleDuck();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// Flag that we jumped.
|
|
mv->m_nOldButtons |= IN_JUMP; // don't jump again until released
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FullLadderMove()
|
|
{
|
|
CheckWater();
|
|
|
|
// Was jump button pressed? If so, set velocity to 270 away from ladder.
|
|
if ( mv->m_nButtons & IN_JUMP )
|
|
{
|
|
CheckJumpButton();
|
|
}
|
|
else
|
|
{
|
|
mv->m_nOldButtons &= ~IN_JUMP;
|
|
}
|
|
|
|
// Perform the move accounting for any base velocity.
|
|
VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
|
|
TryPlayerMove();
|
|
VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CGameMovement::TryPlayerMove( Vector *pFirstDest, trace_t *pFirstTrace )
|
|
{
|
|
int bumpcount, numbumps;
|
|
Vector dir;
|
|
float d;
|
|
int numplanes;
|
|
Vector planes[MAX_CLIP_PLANES];
|
|
Vector primal_velocity, original_velocity;
|
|
Vector new_velocity;
|
|
int i, j;
|
|
trace_t pm;
|
|
Vector end;
|
|
float time_left, allFraction;
|
|
int blocked;
|
|
|
|
numbumps = 4; // Bump up to four times
|
|
|
|
blocked = 0; // Assume not blocked
|
|
numplanes = 0; // and not sliding along any planes
|
|
|
|
VectorCopy (mv->m_vecVelocity, original_velocity); // Store original velocity
|
|
VectorCopy (mv->m_vecVelocity, primal_velocity);
|
|
|
|
allFraction = 0;
|
|
time_left = gpGlobals->frametime; // Total time for this movement operation.
|
|
|
|
new_velocity.Init();
|
|
|
|
for (bumpcount=0 ; bumpcount < numbumps; bumpcount++)
|
|
{
|
|
if ( mv->m_vecVelocity.Length() == 0.0 )
|
|
break;
|
|
|
|
// Assume we can move all the way from the current origin to the
|
|
// end point.
|
|
VectorMA( mv->GetAbsOrigin(), time_left, mv->m_vecVelocity, end );
|
|
|
|
// See if we can make it from origin to end point.
|
|
if ( g_bMovementOptimizations )
|
|
{
|
|
// If their velocity Z is 0, then we can avoid an extra trace here during WalkMove.
|
|
if ( pFirstDest && end == *pFirstDest )
|
|
pm = *pFirstTrace;
|
|
else
|
|
{
|
|
#if defined( PLAYER_GETTING_STUCK_TESTING )
|
|
trace_t foo;
|
|
TracePlayerBBox( mv->GetAbsOrigin(), mv->GetAbsOrigin(), PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, foo );
|
|
if ( foo.startsolid || foo.fraction != 1.0f )
|
|
{
|
|
Msg( "bah\n" );
|
|
}
|
|
#endif
|
|
TracePlayerBBox( mv->GetAbsOrigin(), end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TracePlayerBBox( mv->GetAbsOrigin(), end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
}
|
|
|
|
allFraction += pm.fraction;
|
|
|
|
// If we started in a solid object, or we were in solid space
|
|
// the whole way, zero out our velocity and return that we
|
|
// are blocked by floor and wall.
|
|
if (pm.allsolid)
|
|
{
|
|
// entity is trapped in another solid
|
|
VectorCopy (vec3_origin, mv->m_vecVelocity);
|
|
return 4;
|
|
}
|
|
|
|
// If we moved some portion of the total distance, then
|
|
// copy the end position into the pmove.origin and
|
|
// zero the plane counter.
|
|
if( pm.fraction > 0 )
|
|
{
|
|
if ( numbumps > 0 && pm.fraction == 1 )
|
|
{
|
|
// There's a precision issue with terrain tracing that can cause a swept box to successfully trace
|
|
// when the end position is stuck in the triangle. Re-run the test with an uswept box to catch that
|
|
// case until the bug is fixed.
|
|
// If we detect getting stuck, don't allow the movement
|
|
trace_t stuck;
|
|
TracePlayerBBox( pm.endpos, pm.endpos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, stuck );
|
|
if ( stuck.startsolid || stuck.fraction != 1.0f )
|
|
{
|
|
//Msg( "Player will become stuck!!!\n" );
|
|
VectorCopy (vec3_origin, mv->m_vecVelocity);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if defined( PLAYER_GETTING_STUCK_TESTING )
|
|
trace_t foo;
|
|
TracePlayerBBox( pm.endpos, pm.endpos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, foo );
|
|
if ( foo.startsolid || foo.fraction != 1.0f )
|
|
{
|
|
Msg( "Player will become stuck!!!\n" );
|
|
}
|
|
#endif
|
|
// actually covered some distance
|
|
mv->SetAbsOrigin( pm.endpos);
|
|
VectorCopy (mv->m_vecVelocity, original_velocity);
|
|
numplanes = 0;
|
|
}
|
|
|
|
// If we covered the entire distance, we are done
|
|
// and can return.
|
|
if (pm.fraction == 1)
|
|
{
|
|
break; // moved the entire distance
|
|
}
|
|
|
|
// Save entity that blocked us (since fraction was < 1.0)
|
|
// for contact
|
|
// Add it if it's not already in the list!!!
|
|
MoveHelper( )->AddToTouched( pm, mv->m_vecVelocity );
|
|
|
|
// If the plane we hit has a high z component in the normal, then
|
|
// it's probably a floor
|
|
if (pm.plane.normal[2] > 0.7)
|
|
{
|
|
blocked |= 1; // floor
|
|
}
|
|
// If the plane has a zero z component in the normal, then it's a
|
|
// step or wall
|
|
if (!pm.plane.normal[2])
|
|
{
|
|
blocked |= 2; // step / wall
|
|
}
|
|
|
|
// Reduce amount of m_flFrameTime left by total time left * fraction
|
|
// that we covered.
|
|
time_left -= time_left * pm.fraction;
|
|
|
|
// Did we run out of planes to clip against?
|
|
if (numplanes >= MAX_CLIP_PLANES)
|
|
{
|
|
// this shouldn't really happen
|
|
// Stop our movement if so.
|
|
VectorCopy (vec3_origin, mv->m_vecVelocity);
|
|
//Con_DPrintf("Too many planes 4\n");
|
|
|
|
break;
|
|
}
|
|
|
|
// Set up next clipping plane
|
|
VectorCopy (pm.plane.normal, planes[numplanes]);
|
|
numplanes++;
|
|
|
|
// modify original_velocity so it parallels all of the clip planes
|
|
//
|
|
|
|
// reflect player velocity
|
|
// Only give this a try for first impact plane because you can get yourself stuck in an acute corner by jumping in place
|
|
// and pressing forward and nobody was really using this bounce/reflection feature anyway...
|
|
if ( numplanes == 1 &&
|
|
player->GetMoveType() == MOVETYPE_WALK &&
|
|
player->GetGroundEntity() == NULL )
|
|
{
|
|
for ( i = 0; i < numplanes; i++ )
|
|
{
|
|
if ( planes[i][2] > 0.7 )
|
|
{
|
|
// floor or slope
|
|
ClipVelocity( original_velocity, planes[i], new_velocity, 1 );
|
|
VectorCopy( new_velocity, original_velocity );
|
|
}
|
|
else
|
|
{
|
|
ClipVelocity( original_velocity, planes[i], new_velocity, 1.0 + sv_bounce.GetFloat() * (1 - player->m_surfaceFriction) );
|
|
}
|
|
}
|
|
|
|
VectorCopy( new_velocity, mv->m_vecVelocity );
|
|
VectorCopy( new_velocity, original_velocity );
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; i < numplanes ; i++)
|
|
{
|
|
ClipVelocity (
|
|
original_velocity,
|
|
planes[i],
|
|
mv->m_vecVelocity,
|
|
1);
|
|
|
|
for (j=0 ; j<numplanes ; j++)
|
|
if (j != i)
|
|
{
|
|
// Are we now moving against this plane?
|
|
if (mv->m_vecVelocity.Dot(planes[j]) < 0)
|
|
break; // not ok
|
|
}
|
|
if (j == numplanes) // Didn't have to clip, so we're ok
|
|
break;
|
|
}
|
|
|
|
// Did we go all the way through plane set
|
|
if (i != numplanes)
|
|
{ // go along this plane
|
|
// pmove.velocity is set in clipping call, no need to set again.
|
|
;
|
|
}
|
|
else
|
|
{ // go along the crease
|
|
if (numplanes != 2)
|
|
{
|
|
VectorCopy (vec3_origin, mv->m_vecVelocity);
|
|
break;
|
|
}
|
|
CrossProduct (planes[0], planes[1], dir);
|
|
dir.NormalizeInPlace();
|
|
d = dir.Dot(mv->m_vecVelocity);
|
|
VectorScale (dir, d, mv->m_vecVelocity );
|
|
}
|
|
|
|
//
|
|
// if original velocity is against the original velocity, stop dead
|
|
// to avoid tiny occilations in sloping corners
|
|
//
|
|
d = mv->m_vecVelocity.Dot(primal_velocity);
|
|
if (d <= 0)
|
|
{
|
|
//Con_DPrintf("Back\n");
|
|
VectorCopy (vec3_origin, mv->m_vecVelocity);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( allFraction == 0 )
|
|
{
|
|
VectorCopy (vec3_origin, mv->m_vecVelocity);
|
|
}
|
|
|
|
// Check if they slammed into a wall
|
|
float fSlamVol = 0.0f;
|
|
|
|
float fLateralStoppingAmount = primal_velocity.Length2D() - mv->m_vecVelocity.Length2D();
|
|
if ( fLateralStoppingAmount > PLAYER_MAX_SAFE_FALL_SPEED * 2.0f )
|
|
{
|
|
fSlamVol = 1.0f;
|
|
}
|
|
else if ( fLateralStoppingAmount > PLAYER_MAX_SAFE_FALL_SPEED )
|
|
{
|
|
fSlamVol = 0.85f;
|
|
}
|
|
|
|
PlayerRoughLandingEffects( fSlamVol );
|
|
|
|
return blocked;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determine whether or not the player is on a ladder (physprop or world).
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CGameMovement::OnLadder( trace_t &trace )
|
|
{
|
|
if ( trace.contents & CONTENTS_LADDER )
|
|
return true;
|
|
|
|
IPhysicsSurfaceProps *pPhysProps = MoveHelper( )->GetSurfaceProps();
|
|
if ( pPhysProps )
|
|
{
|
|
const surfacedata_t *pSurfaceData = pPhysProps->GetSurfaceData( trace.surface.surfaceProps );
|
|
if ( pSurfaceData )
|
|
{
|
|
if ( pSurfaceData->game.climbable != 0 )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN
|
|
// [sbodenbender] make ladders easier to climb in cstrike
|
|
//=============================================================================
|
|
#if defined (CSTRIKE_DLL)
|
|
ConVar sv_ladder_dampen ( "sv_ladder_dampen", "0.2", FCVAR_REPLICATED, "Amount to dampen perpendicular movement on a ladder", true, 0.0f, true, 1.0f );
|
|
ConVar sv_ladder_angle( "sv_ladder_angle", "-0.707", FCVAR_REPLICATED, "Cos of angle of incidence to ladder perpendicular for applying ladder_dampen", true, -1.0f, true, 1.0f );
|
|
#endif
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameMovement::LadderMove( void )
|
|
{
|
|
trace_t pm;
|
|
bool onFloor;
|
|
Vector floor;
|
|
Vector wishdir;
|
|
Vector end;
|
|
|
|
if ( player->GetMoveType() == MOVETYPE_NOCLIP )
|
|
return false;
|
|
|
|
if ( !GameHasLadders() )
|
|
return false;
|
|
|
|
// If I'm already moving on a ladder, use the previous ladder direction
|
|
if ( player->GetMoveType() == MOVETYPE_LADDER )
|
|
{
|
|
wishdir = -player->m_vecLadderNormal;
|
|
}
|
|
else
|
|
{
|
|
// otherwise, use the direction player is attempting to move
|
|
if ( mv->m_flForwardMove || mv->m_flSideMove )
|
|
{
|
|
for (int i=0 ; i<3 ; i++) // Determine x and y parts of velocity
|
|
wishdir[i] = m_vecForward[i]*mv->m_flForwardMove + m_vecRight[i]*mv->m_flSideMove;
|
|
|
|
VectorNormalize(wishdir);
|
|
}
|
|
else
|
|
{
|
|
// Player is not attempting to move, no ladder behavior
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// wishdir points toward the ladder if any exists
|
|
VectorMA( mv->GetAbsOrigin(), LadderDistance(), wishdir, end );
|
|
TracePlayerBBox( mv->GetAbsOrigin(), end, LadderMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
|
|
// no ladder in that direction, return
|
|
if ( pm.fraction == 1.0f || !OnLadder( pm ) )
|
|
return false;
|
|
|
|
player->SetMoveType( MOVETYPE_LADDER );
|
|
player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
|
|
|
|
player->m_vecLadderNormal = pm.plane.normal;
|
|
|
|
// On ladder, convert movement to be relative to the ladder
|
|
|
|
VectorCopy( mv->GetAbsOrigin(), floor );
|
|
floor[2] += GetPlayerMins()[2] - 1;
|
|
|
|
if( enginetrace->GetPointContents( floor ) == CONTENTS_SOLID || player->GetGroundEntity() != NULL )
|
|
{
|
|
onFloor = true;
|
|
}
|
|
else
|
|
{
|
|
onFloor = false;
|
|
}
|
|
|
|
player->SetGravity( 0 );
|
|
|
|
float climbSpeed = ClimbSpeed();
|
|
|
|
float forwardSpeed = 0, rightSpeed = 0;
|
|
if ( mv->m_nButtons & IN_BACK )
|
|
forwardSpeed -= climbSpeed;
|
|
|
|
if ( mv->m_nButtons & IN_FORWARD )
|
|
forwardSpeed += climbSpeed;
|
|
|
|
if ( mv->m_nButtons & IN_MOVELEFT )
|
|
rightSpeed -= climbSpeed;
|
|
|
|
if ( mv->m_nButtons & IN_MOVERIGHT )
|
|
rightSpeed += climbSpeed;
|
|
|
|
if ( mv->m_nButtons & IN_JUMP )
|
|
{
|
|
player->SetMoveType( MOVETYPE_WALK );
|
|
player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
|
|
|
|
VectorScale( pm.plane.normal, 270, mv->m_vecVelocity );
|
|
}
|
|
else
|
|
{
|
|
if ( forwardSpeed != 0 || rightSpeed != 0 )
|
|
{
|
|
Vector velocity, perp, cross, lateral, tmp;
|
|
|
|
//ALERT(at_console, "pev %.2f %.2f %.2f - ",
|
|
// pev->velocity.x, pev->velocity.y, pev->velocity.z);
|
|
// Calculate player's intended velocity
|
|
//Vector velocity = (forward * gpGlobals->v_forward) + (right * gpGlobals->v_right);
|
|
VectorScale( m_vecForward, forwardSpeed, velocity );
|
|
VectorMA( velocity, rightSpeed, m_vecRight, velocity );
|
|
|
|
// Perpendicular in the ladder plane
|
|
VectorCopy( vec3_origin, tmp );
|
|
tmp[2] = 1;
|
|
CrossProduct( tmp, pm.plane.normal, perp );
|
|
VectorNormalize( perp );
|
|
|
|
// decompose velocity into ladder plane
|
|
float normal = DotProduct( velocity, pm.plane.normal );
|
|
|
|
// This is the velocity into the face of the ladder
|
|
VectorScale( pm.plane.normal, normal, cross );
|
|
|
|
// This is the player's additional velocity
|
|
VectorSubtract( velocity, cross, lateral );
|
|
|
|
// This turns the velocity into the face of the ladder into velocity that
|
|
// is roughly vertically perpendicular to the face of the ladder.
|
|
// NOTE: It IS possible to face up and move down or face down and move up
|
|
// because the velocity is a sum of the directional velocity and the converted
|
|
// velocity through the face of the ladder -- by design.
|
|
CrossProduct( pm.plane.normal, perp, tmp );
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN
|
|
// [sbodenbender] make ladders easier to climb in cstrike
|
|
//=============================================================================
|
|
#if defined (CSTRIKE_DLL)
|
|
// break lateral into direction along tmp (up the ladder) and direction along perp (perpendicular to ladder)
|
|
float tmpDist = DotProduct ( tmp, lateral );
|
|
float perpDist = DotProduct ( perp, lateral );
|
|
|
|
Vector angleVec = perp * perpDist;
|
|
angleVec += cross;
|
|
// angleVec is our desired movement in the ladder normal/perpendicular plane
|
|
VectorNormalize(angleVec);
|
|
float angleDot = DotProduct(angleVec, pm.plane.normal);
|
|
// angleDot is our angle of incidence to the laddernormal in the ladder normal/perpendicular plane
|
|
|
|
if (angleDot < sv_ladder_angle.GetFloat())
|
|
lateral = (tmp * tmpDist) + (perp * sv_ladder_dampen.GetFloat() * perpDist);
|
|
#endif // CSTRIKE_DLL
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
VectorMA( lateral, -normal, tmp, mv->m_vecVelocity );
|
|
|
|
if ( onFloor && normal > 0 ) // On ground moving away from the ladder
|
|
{
|
|
VectorMA( mv->m_vecVelocity, MAX_CLIMB_SPEED, pm.plane.normal, mv->m_vecVelocity );
|
|
}
|
|
//pev->velocity = lateral - (CrossProduct( trace.vecPlaneNormal, perp ) * normal);
|
|
}
|
|
else
|
|
{
|
|
mv->m_vecVelocity.Init();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : axis -
|
|
// Output : const char
|
|
//-----------------------------------------------------------------------------
|
|
#if !defined(_STATIC_LINKED) || defined(CLIENT_DLL)
|
|
const char *DescribeAxis( int axis )
|
|
{
|
|
static char sz[ 32 ];
|
|
|
|
switch ( axis )
|
|
{
|
|
case 0:
|
|
Q_strncpy( sz, "X", sizeof( sz ) );
|
|
break;
|
|
case 1:
|
|
Q_strncpy( sz, "Y", sizeof( sz ) );
|
|
break;
|
|
case 2:
|
|
default:
|
|
Q_strncpy( sz, "Z", sizeof( sz ) );
|
|
break;
|
|
}
|
|
|
|
return sz;
|
|
}
|
|
#else
|
|
const char *DescribeAxis( int axis );
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::CheckVelocity( void )
|
|
{
|
|
int i;
|
|
|
|
//
|
|
// bound velocity
|
|
//
|
|
|
|
Vector org = mv->GetAbsOrigin();
|
|
|
|
for (i=0; i < 3; i++)
|
|
{
|
|
// See if it's bogus.
|
|
if (IS_NAN(mv->m_vecVelocity[i]))
|
|
{
|
|
DevMsg( 1, "PM Got a NaN velocity %s\n", DescribeAxis( i ) );
|
|
mv->m_vecVelocity[i] = 0;
|
|
}
|
|
|
|
if (IS_NAN(org[i]))
|
|
{
|
|
DevMsg( 1, "PM Got a NaN origin on %s\n", DescribeAxis( i ) );
|
|
org[ i ] = 0;
|
|
mv->SetAbsOrigin( org );
|
|
}
|
|
|
|
// Bound it.
|
|
if (mv->m_vecVelocity[i] > sv_maxvelocity.GetFloat())
|
|
{
|
|
DevMsg( 1, "PM Got a velocity too high on %s\n", DescribeAxis( i ) );
|
|
mv->m_vecVelocity[i] = sv_maxvelocity.GetFloat();
|
|
}
|
|
else if (mv->m_vecVelocity[i] < -sv_maxvelocity.GetFloat())
|
|
{
|
|
DevMsg( 1, "PM Got a velocity too low on %s\n", DescribeAxis( i ) );
|
|
mv->m_vecVelocity[i] = -sv_maxvelocity.GetFloat();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::AddGravity( void )
|
|
{
|
|
float ent_gravity;
|
|
|
|
if ( player->m_flWaterJumpTime )
|
|
return;
|
|
|
|
if (player->GetGravity())
|
|
ent_gravity = player->GetGravity();
|
|
else
|
|
ent_gravity = 1.0;
|
|
|
|
// Add gravity incorrectly
|
|
mv->m_vecVelocity[2] -= (ent_gravity * GetCurrentGravity() * gpGlobals->frametime);
|
|
mv->m_vecVelocity[2] += player->GetBaseVelocity()[2] * gpGlobals->frametime;
|
|
Vector temp = player->GetBaseVelocity();
|
|
temp[2] = 0;
|
|
player->SetBaseVelocity( temp );
|
|
|
|
CheckVelocity();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : push -
|
|
// Output : trace_t
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::PushEntity( Vector& push, trace_t *pTrace )
|
|
{
|
|
Vector end;
|
|
|
|
VectorAdd (mv->GetAbsOrigin(), push, end);
|
|
TracePlayerBBox( mv->GetAbsOrigin(), end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, *pTrace );
|
|
mv->SetAbsOrigin( pTrace->endpos );
|
|
|
|
// So we can run impact function afterwards.
|
|
// If
|
|
if ( pTrace->fraction < 1.0 && !pTrace->allsolid )
|
|
{
|
|
MoveHelper( )->AddToTouched( *pTrace, mv->m_vecVelocity );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : in -
|
|
// normal -
|
|
// out -
|
|
// overbounce -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CGameMovement::ClipVelocity( Vector& in, Vector& normal, Vector& out, float overbounce )
|
|
{
|
|
float backoff;
|
|
float change;
|
|
float angle;
|
|
int i, blocked;
|
|
|
|
angle = normal[ 2 ];
|
|
|
|
blocked = 0x00; // Assume unblocked.
|
|
if (angle > 0) // If the plane that is blocking us has a positive z component, then assume it's a floor.
|
|
blocked |= 0x01; //
|
|
if (!angle) // If the plane has no Z, it is vertical (wall/step)
|
|
blocked |= 0x02; //
|
|
|
|
|
|
// Determine how far along plane to slide based on incoming direction.
|
|
backoff = DotProduct (in, normal) * overbounce;
|
|
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
change = normal[i]*backoff;
|
|
out[i] = in[i] - change;
|
|
}
|
|
|
|
// iterate once to make sure we aren't still moving through the plane
|
|
float adjust = DotProduct( out, normal );
|
|
if( adjust < 0.0f )
|
|
{
|
|
out -= ( normal * adjust );
|
|
// Msg( "Adjustment = %lf\n", adjust );
|
|
}
|
|
|
|
// Return blocking flags.
|
|
return blocked;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Computes roll angle for a certain movement direction and velocity
|
|
// Input : angles -
|
|
// velocity -
|
|
// rollangle -
|
|
// rollspeed -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CGameMovement::CalcRoll ( const QAngle &angles, const Vector &velocity, float rollangle, float rollspeed )
|
|
{
|
|
float sign;
|
|
float side;
|
|
float value;
|
|
Vector forward, right, up;
|
|
|
|
AngleVectors (angles, &forward, &right, &up);
|
|
|
|
side = DotProduct (velocity, right);
|
|
sign = side < 0 ? -1 : 1;
|
|
side = fabs(side);
|
|
value = rollangle;
|
|
if (side < rollspeed)
|
|
{
|
|
side = side * value / rollspeed;
|
|
}
|
|
else
|
|
{
|
|
side = value;
|
|
}
|
|
return side*sign;
|
|
}
|
|
|
|
#define CHECKSTUCK_MINTIME 0.05 // Don't check again too quickly.
|
|
|
|
#if !defined(_STATIC_LINKED) || defined(CLIENT_DLL)
|
|
Vector rgv3tStuckTable[54];
|
|
#else
|
|
extern Vector rgv3tStuckTable[54];
|
|
#endif
|
|
|
|
#if !defined(_STATIC_LINKED) || defined(CLIENT_DLL)
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CreateStuckTable( void )
|
|
{
|
|
float x, y, z;
|
|
int idx;
|
|
int i;
|
|
float zi[3];
|
|
static int firsttime = 1;
|
|
|
|
if ( !firsttime )
|
|
return;
|
|
|
|
firsttime = 0;
|
|
|
|
memset(rgv3tStuckTable, 0, sizeof(rgv3tStuckTable));
|
|
|
|
idx = 0;
|
|
// Little Moves.
|
|
x = y = 0;
|
|
// Z moves
|
|
for (z = -0.125 ; z <= 0.125 ; z += 0.125)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
x = z = 0;
|
|
// Y moves
|
|
for (y = -0.125 ; y <= 0.125 ; y += 0.125)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
y = z = 0;
|
|
// X moves
|
|
for (x = -0.125 ; x <= 0.125 ; x += 0.125)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
|
|
// Remaining multi axis nudges.
|
|
for ( x = - 0.125; x <= 0.125; x += 0.250 )
|
|
{
|
|
for ( y = - 0.125; y <= 0.125; y += 0.250 )
|
|
{
|
|
for ( z = - 0.125; z <= 0.125; z += 0.250 )
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Big Moves.
|
|
x = y = 0;
|
|
zi[0] = 0.0f;
|
|
zi[1] = 1.0f;
|
|
zi[2] = 6.0f;
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
// Z moves
|
|
z = zi[i];
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
|
|
x = z = 0;
|
|
|
|
// Y moves
|
|
for (y = -2.0f ; y <= 2.0f ; y += 2.0)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
y = z = 0;
|
|
// X moves
|
|
for (x = -2.0f ; x <= 2.0f ; x += 2.0f)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
|
|
// Remaining multi axis nudges.
|
|
for (i = 0 ; i < 3; i++)
|
|
{
|
|
z = zi[i];
|
|
|
|
for (x = -2.0f ; x <= 2.0f ; x += 2.0f)
|
|
{
|
|
for (y = -2.0f ; y <= 2.0f ; y += 2.0)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
Assert( idx < sizeof(rgv3tStuckTable)/sizeof(rgv3tStuckTable[0]));
|
|
}
|
|
#else
|
|
extern void CreateStuckTable( void );
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : nIndex -
|
|
// server -
|
|
// offset -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int GetRandomStuckOffsets( CBasePlayer *pPlayer, Vector& offset)
|
|
{
|
|
// Last time we did a full
|
|
int idx;
|
|
idx = pPlayer->m_StuckLast++;
|
|
|
|
VectorCopy(rgv3tStuckTable[idx % 54], offset);
|
|
|
|
return (idx % 54);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : nIndex -
|
|
// server -
|
|
//-----------------------------------------------------------------------------
|
|
void ResetStuckOffsets( CBasePlayer *pPlayer )
|
|
{
|
|
pPlayer->m_StuckLast = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &input -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CGameMovement::CheckStuck( void )
|
|
{
|
|
Vector base;
|
|
Vector offset;
|
|
Vector test;
|
|
EntityHandle_t hitent;
|
|
int idx;
|
|
float fTime;
|
|
trace_t traceresult;
|
|
|
|
CreateStuckTable();
|
|
|
|
hitent = TestPlayerPosition( mv->GetAbsOrigin(), COLLISION_GROUP_PLAYER_MOVEMENT, traceresult );
|
|
if ( hitent == INVALID_ENTITY_HANDLE )
|
|
{
|
|
ResetStuckOffsets( player );
|
|
return 0;
|
|
}
|
|
|
|
// Deal with stuckness...
|
|
#ifndef DEDICATED
|
|
if ( developer.GetBool() )
|
|
{
|
|
bool isServer = player->IsServer();
|
|
engine->Con_NPrintf( isServer, "%s stuck on object %i/%s",
|
|
isServer ? "server" : "client",
|
|
hitent.GetEntryIndex(), MoveHelper()->GetName(hitent) );
|
|
}
|
|
#endif
|
|
|
|
VectorCopy( mv->GetAbsOrigin(), base );
|
|
|
|
//
|
|
// Deal with precision error in network.
|
|
//
|
|
// World or BSP model
|
|
if ( !player->IsServer() )
|
|
{
|
|
if ( MoveHelper()->IsWorldEntity( hitent ) )
|
|
{
|
|
int nReps = 0;
|
|
ResetStuckOffsets( player );
|
|
do
|
|
{
|
|
GetRandomStuckOffsets( player, offset );
|
|
VectorAdd( base, offset, test );
|
|
|
|
if ( TestPlayerPosition( test, COLLISION_GROUP_PLAYER_MOVEMENT, traceresult ) == INVALID_ENTITY_HANDLE )
|
|
{
|
|
ResetStuckOffsets( player );
|
|
mv->SetAbsOrigin( test );
|
|
return 0;
|
|
}
|
|
nReps++;
|
|
} while (nReps < 54);
|
|
}
|
|
}
|
|
|
|
// Only an issue on the client.
|
|
idx = player->IsServer() ? 0 : 1;
|
|
|
|
fTime = engine->Time();
|
|
// Too soon?
|
|
if ( m_flStuckCheckTime[ player->entindex() ][ idx ] >= fTime - CHECKSTUCK_MINTIME )
|
|
{
|
|
return 1;
|
|
}
|
|
m_flStuckCheckTime[ player->entindex() ][ idx ] = fTime;
|
|
|
|
MoveHelper( )->AddToTouched( traceresult, mv->m_vecVelocity );
|
|
GetRandomStuckOffsets( player, offset );
|
|
VectorAdd( base, offset, test );
|
|
|
|
if ( TestPlayerPosition( test, COLLISION_GROUP_PLAYER_MOVEMENT, traceresult ) == INVALID_ENTITY_HANDLE)
|
|
{
|
|
ResetStuckOffsets( player );
|
|
mv->SetAbsOrigin( test );
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : bool
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameMovement::InWater( void )
|
|
{
|
|
return ( player->GetWaterLevel() > WL_Feet );
|
|
}
|
|
|
|
|
|
void CGameMovement::ResetGetPointContentsCache()
|
|
{
|
|
for ( int slot = 0; slot < MAX_PC_CACHE_SLOTS; ++slot )
|
|
{
|
|
for ( int i = 0; i < MAX_PLAYERS; ++i )
|
|
{
|
|
m_CachedGetPointContents[ i ][ slot ] = -9999;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int CGameMovement::GetPointContentsCached( const Vector &point, int slot )
|
|
{
|
|
if ( g_bMovementOptimizations )
|
|
{
|
|
Assert( player );
|
|
Assert( slot >= 0 && slot < MAX_PC_CACHE_SLOTS );
|
|
|
|
int idx = player->entindex() - 1;
|
|
|
|
if ( m_CachedGetPointContents[ idx ][ slot ] == -9999 || point.DistToSqr( m_CachedGetPointContentsPoint[ idx ][ slot ] ) > 1 )
|
|
{
|
|
m_CachedGetPointContents[ idx ][ slot ] = enginetrace->GetPointContents ( point );
|
|
m_CachedGetPointContentsPoint[ idx ][ slot ] = point;
|
|
}
|
|
|
|
return m_CachedGetPointContents[ idx ][ slot ];
|
|
}
|
|
else
|
|
{
|
|
return enginetrace->GetPointContents ( point );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &input -
|
|
// Output : bool
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameMovement::CheckWater( void )
|
|
{
|
|
Vector point;
|
|
int cont;
|
|
|
|
Vector vPlayerMins = GetPlayerMins();
|
|
Vector vPlayerMaxs = GetPlayerMaxs();
|
|
|
|
// Pick a spot just above the players feet.
|
|
point[0] = mv->GetAbsOrigin()[0] + (vPlayerMins[0] + vPlayerMaxs[0]) * 0.5;
|
|
point[1] = mv->GetAbsOrigin()[1] + (vPlayerMins[1] + vPlayerMaxs[1]) * 0.5;
|
|
point[2] = mv->GetAbsOrigin()[2] + vPlayerMins[2] + 1;
|
|
|
|
// Assume that we are not in water at all.
|
|
player->SetWaterLevel( WL_NotInWater );
|
|
player->SetWaterType( CONTENTS_EMPTY );
|
|
|
|
// Grab point contents.
|
|
cont = GetPointContentsCached( point, 0 );
|
|
|
|
// Are we under water? (not solid and not empty?)
|
|
if ( cont & MASK_WATER )
|
|
{
|
|
// Set water type
|
|
player->SetWaterType( cont );
|
|
|
|
// We are at least at level one
|
|
player->SetWaterLevel( WL_Feet );
|
|
|
|
// Now check a point that is at the player hull midpoint.
|
|
point[2] = mv->GetAbsOrigin()[2] + (vPlayerMins[2] + vPlayerMaxs[2])*0.5;
|
|
cont = GetPointContentsCached( point, 1 );
|
|
// If that point is also under water...
|
|
if ( cont & MASK_WATER )
|
|
{
|
|
// Set a higher water level.
|
|
player->SetWaterLevel( WL_Waist );
|
|
|
|
// Now check the eye position. (view_ofs is relative to the origin)
|
|
point[2] = mv->GetAbsOrigin()[2] + player->GetViewOffset()[2];
|
|
cont = GetPointContentsCached( point, 2 );
|
|
if ( cont & MASK_WATER )
|
|
player->SetWaterLevel( WL_Eyes ); // In over our eyes
|
|
}
|
|
|
|
// Adjust velocity based on water current, if any.
|
|
if ( cont & MASK_CURRENT )
|
|
{
|
|
Vector v;
|
|
VectorClear(v);
|
|
if ( cont & CONTENTS_CURRENT_0 )
|
|
v[0] += 1;
|
|
if ( cont & CONTENTS_CURRENT_90 )
|
|
v[1] += 1;
|
|
if ( cont & CONTENTS_CURRENT_180 )
|
|
v[0] -= 1;
|
|
if ( cont & CONTENTS_CURRENT_270 )
|
|
v[1] -= 1;
|
|
if ( cont & CONTENTS_CURRENT_UP )
|
|
v[2] += 1;
|
|
if ( cont & CONTENTS_CURRENT_DOWN )
|
|
v[2] -= 1;
|
|
|
|
// BUGBUG -- this depends on the value of an unspecified enumerated type
|
|
// The deeper we are, the stronger the current.
|
|
Vector temp;
|
|
VectorMA( player->GetBaseVelocity(), 50.0*player->GetWaterLevel(), v, temp );
|
|
player->SetBaseVelocity( temp );
|
|
}
|
|
}
|
|
|
|
// if we just transitioned from not in water to in water, record the time it happened
|
|
if ( ( WL_NotInWater == m_nOldWaterLevel ) && ( player->GetWaterLevel() > WL_NotInWater ) )
|
|
{
|
|
m_flWaterEntryTime = gpGlobals->curtime;
|
|
}
|
|
|
|
return ( player->GetWaterLevel() > WL_Feet );
|
|
}
|
|
|
|
void CGameMovement::SetGroundEntity( trace_t *pm )
|
|
{
|
|
CBaseEntity *newGround = pm ? pm->m_pEnt : NULL;
|
|
|
|
CBaseEntity *oldGround = player->GetGroundEntity();
|
|
Vector vecBaseVelocity = player->GetBaseVelocity();
|
|
|
|
if ( !oldGround && newGround )
|
|
{
|
|
// Subtract ground velocity at instant we hit ground jumping
|
|
vecBaseVelocity -= newGround->GetAbsVelocity();
|
|
vecBaseVelocity.z = newGround->GetAbsVelocity().z;
|
|
}
|
|
else if ( oldGround && !newGround )
|
|
{
|
|
// Add in ground velocity at instant we started jumping
|
|
vecBaseVelocity += oldGround->GetAbsVelocity();
|
|
vecBaseVelocity.z = oldGround->GetAbsVelocity().z;
|
|
}
|
|
|
|
player->SetBaseVelocity( vecBaseVelocity );
|
|
player->SetGroundEntity( newGround );
|
|
|
|
// If we are on something...
|
|
|
|
if ( newGround )
|
|
{
|
|
CategorizeGroundSurface( *pm );
|
|
|
|
// Then we are not in water jump sequence
|
|
player->m_flWaterJumpTime = 0;
|
|
|
|
// Standing on an entity other than the world, so signal that we are touching something.
|
|
if ( !pm->DidHitWorld() )
|
|
{
|
|
MoveHelper()->AddToTouched( *pm, mv->m_vecVelocity );
|
|
}
|
|
|
|
mv->m_vecVelocity.z = 0.0f;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Traces the player's collision bounds in quadrants, looking for a plane that
|
|
// can be stood upon (normal's z >= 0.7f). Regardless of success or failure,
|
|
// replace the fraction and endpos with the original ones, so we don't try to
|
|
// move the player down to the new floor and get stuck on a leaning wall that
|
|
// the original trace hit first.
|
|
//-----------------------------------------------------------------------------
|
|
void TracePlayerBBoxForGround( const Vector& start, const Vector& end, const Vector& minsSrc,
|
|
const Vector& maxsSrc, IHandleEntity *player, unsigned int fMask,
|
|
int collisionGroup, trace_t& pm )
|
|
{
|
|
VPROF( "TracePlayerBBoxForGround" );
|
|
|
|
Ray_t ray;
|
|
Vector mins, maxs;
|
|
|
|
float fraction = pm.fraction;
|
|
Vector endpos = pm.endpos;
|
|
|
|
// Check the -x, -y quadrant
|
|
mins = minsSrc;
|
|
maxs.Init( MIN( 0, maxsSrc.x ), MIN( 0, maxsSrc.y ), maxsSrc.z );
|
|
ray.Init( start, end, mins, maxs );
|
|
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
// Check the +x, +y quadrant
|
|
mins.Init( MAX( 0, minsSrc.x ), MAX( 0, minsSrc.y ), minsSrc.z );
|
|
maxs = maxsSrc;
|
|
ray.Init( start, end, mins, maxs );
|
|
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
// Check the -x, +y quadrant
|
|
mins.Init( minsSrc.x, MAX( 0, minsSrc.y ), minsSrc.z );
|
|
maxs.Init( MIN( 0, maxsSrc.x ), maxsSrc.y, maxsSrc.z );
|
|
ray.Init( start, end, mins, maxs );
|
|
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
// Check the +x, -y quadrant
|
|
mins.Init( MAX( 0, minsSrc.x ), minsSrc.y, minsSrc.z );
|
|
maxs.Init( maxsSrc.x, MIN( 0, maxsSrc.y ), maxsSrc.z );
|
|
ray.Init( start, end, mins, maxs );
|
|
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Traces the player's collision bounds in quadrants, looking for a plane that
|
|
// can be stood upon (normal's z >= 0.7f). Regardless of success or failure,
|
|
// replace the fraction and endpos with the original ones, so we don't try to
|
|
// move the player down to the new floor and get stuck on a leaning wall that
|
|
// the original trace hit first.
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::TryTouchGroundInQuadrants( const Vector& start, const Vector& end, unsigned int fMask, int collisionGroup, trace_t& pm )
|
|
{
|
|
VPROF( "CGameMovement::TryTouchGroundInQuadrants" );
|
|
|
|
Vector mins, maxs;
|
|
Vector minsSrc = GetPlayerMins();
|
|
Vector maxsSrc = GetPlayerMaxs();
|
|
|
|
float fraction = pm.fraction;
|
|
Vector endpos = pm.endpos;
|
|
|
|
// Check the -x, -y quadrant
|
|
mins = minsSrc;
|
|
maxs.Init( MIN( 0, maxsSrc.x ), MIN( 0, maxsSrc.y ), maxsSrc.z );
|
|
TryTouchGround( start, end, mins, maxs, fMask, collisionGroup, pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
// Check the +x, +y quadrant
|
|
mins.Init( MAX( 0, minsSrc.x ), MAX( 0, minsSrc.y ), minsSrc.z );
|
|
maxs = maxsSrc;
|
|
TryTouchGround( start, end, mins, maxs, fMask, collisionGroup, pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
// Check the -x, +y quadrant
|
|
mins.Init( minsSrc.x, MAX( 0, minsSrc.y ), minsSrc.z );
|
|
maxs.Init( MIN( 0, maxsSrc.x ), maxsSrc.y, maxsSrc.z );
|
|
TryTouchGround( start, end, mins, maxs, fMask, collisionGroup, pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
// Check the +x, -y quadrant
|
|
mins.Init( MAX( 0, minsSrc.x ), minsSrc.y, minsSrc.z );
|
|
maxs.Init( maxsSrc.x, MIN( 0, maxsSrc.y ), maxsSrc.z );
|
|
TryTouchGround( start, end, mins, maxs, fMask, collisionGroup, pm );
|
|
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
|
|
{
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
return;
|
|
}
|
|
|
|
pm.fraction = fraction;
|
|
pm.endpos = endpos;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &input -
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::CategorizePosition( void )
|
|
{
|
|
Vector point;
|
|
trace_t pm;
|
|
|
|
// Reset this each time we-recategorize, otherwise we have bogus friction when we jump into water and plunge downward really quickly
|
|
player->m_surfaceFriction = 1.0f;
|
|
|
|
// if the player hull point one unit down is solid, the player
|
|
// is on ground
|
|
|
|
// see if standing on something solid
|
|
|
|
// Doing this before we move may introduce a potential latency in water detection, but
|
|
// doing it after can get us stuck on the bottom in water if the amount we move up
|
|
// is less than the 1 pixel 'threshold' we're about to snap to. Also, we'll call
|
|
// this several times per frame, so we really need to avoid sticking to the bottom of
|
|
// water on each call, and the converse case will correct itself if called twice.
|
|
CheckWater();
|
|
|
|
// observers don't have a ground entity
|
|
if ( player->IsObserver() )
|
|
return;
|
|
|
|
float flOffset = 2.0f;
|
|
|
|
point[0] = mv->GetAbsOrigin()[0];
|
|
point[1] = mv->GetAbsOrigin()[1];
|
|
point[2] = mv->GetAbsOrigin()[2] - flOffset;
|
|
|
|
Vector bumpOrigin;
|
|
bumpOrigin = mv->GetAbsOrigin();
|
|
|
|
// Shooting up really fast. Definitely not on ground.
|
|
// On ladder moving up, so not on ground either
|
|
// NOTE: 145 is a jump.
|
|
#define NON_JUMP_VELOCITY 140.0f
|
|
|
|
float zvel = mv->m_vecVelocity[2];
|
|
bool bMovingUp = zvel > 0.0f;
|
|
bool bMovingUpRapidly = zvel > NON_JUMP_VELOCITY;
|
|
float flGroundEntityVelZ = 0.0f;
|
|
if ( bMovingUpRapidly )
|
|
{
|
|
// Tracker 73219, 75878: ywb 8/2/07
|
|
// After save/restore (and maybe at other times), we can get a case where we were saved on a lift and
|
|
// after restore we'll have a high local velocity due to the lift making our abs velocity appear high.
|
|
// We need to account for standing on a moving ground object in that case in order to determine if we really
|
|
// are moving away from the object we are standing on at too rapid a speed. Note that CheckJump already sets
|
|
// ground entity to NULL, so this wouldn't have any effect unless we are moving up rapidly not from the jump button.
|
|
CBaseEntity *ground = player->GetGroundEntity();
|
|
if ( ground )
|
|
{
|
|
flGroundEntityVelZ = ground->GetAbsVelocity().z;
|
|
bMovingUpRapidly = ( zvel - flGroundEntityVelZ ) > NON_JUMP_VELOCITY;
|
|
}
|
|
}
|
|
|
|
// Was on ground, but now suddenly am not
|
|
if ( bMovingUpRapidly ||
|
|
( bMovingUp && player->GetMoveType() == MOVETYPE_LADDER ) )
|
|
{
|
|
SetGroundEntity( NULL );
|
|
}
|
|
else
|
|
{
|
|
// Try and move down.
|
|
TryTouchGround( bumpOrigin, point, GetPlayerMins(), GetPlayerMaxs(), MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
|
|
// Was on ground, but now suddenly am not. If we hit a steep plane, we are not on ground
|
|
if ( !pm.m_pEnt || pm.plane.normal[2] < 0.7 )
|
|
{
|
|
// Test four sub-boxes, to see if any of them would have found shallower slope we could actually stand on
|
|
TryTouchGroundInQuadrants( bumpOrigin, point, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
|
|
|
|
if ( !pm.m_pEnt || pm.plane.normal[2] < 0.7 )
|
|
{
|
|
SetGroundEntity( NULL );
|
|
// probably want to add a check for a +z velocity too!
|
|
if ( ( mv->m_vecVelocity.z > 0.0f ) &&
|
|
( player->GetMoveType() != MOVETYPE_NOCLIP ) )
|
|
{
|
|
player->m_surfaceFriction = 0.25f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetGroundEntity( &pm );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetGroundEntity( &pm ); // Otherwise, point to index of ent under us.
|
|
}
|
|
|
|
#ifndef CLIENT_DLL
|
|
|
|
//Adrian: vehicle code handles for us.
|
|
if ( player->IsInAVehicle() == false )
|
|
{
|
|
// If our gamematerial has changed, tell any player surface triggers that are watching
|
|
IPhysicsSurfaceProps *physprops = MoveHelper()->GetSurfaceProps();
|
|
surfacedata_t *pSurfaceProp = physprops->GetSurfaceData( pm.surface.surfaceProps );
|
|
char cCurrGameMaterial = pSurfaceProp->game.material;
|
|
if ( !player->GetGroundEntity() )
|
|
{
|
|
cCurrGameMaterial = 0;
|
|
}
|
|
|
|
// Changed?
|
|
if ( player->m_chPreviousTextureType != cCurrGameMaterial )
|
|
{
|
|
CEnvPlayerSurfaceTrigger::SetPlayerSurface( player, cCurrGameMaterial );
|
|
}
|
|
|
|
player->m_chPreviousTextureType = cCurrGameMaterial;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determine if the player has hit the ground while falling, apply
|
|
// damage, and play the appropriate impact sound.
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::CheckFalling( void )
|
|
{
|
|
// this function really deals with landing, not falling, so early out otherwise
|
|
if ( player->GetGroundEntity() == NULL || player->m_Local.m_flFallVelocity <= 0 )
|
|
return;
|
|
|
|
if ( !IsDead() && player->m_Local.m_flFallVelocity >= PLAYER_FALL_PUNCH_THRESHOLD )
|
|
{
|
|
bool bAlive = true;
|
|
float fvol = 0.5;
|
|
|
|
if ( player->GetWaterLevel() > 0 )
|
|
{
|
|
// They landed in water.
|
|
}
|
|
else
|
|
{
|
|
// Scale it down if we landed on something that's floating...
|
|
if ( player->GetGroundEntity()->IsFloating() )
|
|
{
|
|
player->m_Local.m_flFallVelocity -= PLAYER_LAND_ON_FLOATING_OBJECT;
|
|
}
|
|
|
|
//
|
|
// They hit the ground.
|
|
//
|
|
if( player->GetGroundEntity()->GetAbsVelocity().z < 0.0f )
|
|
{
|
|
// Player landed on a descending object. Subtract the velocity of the ground entity.
|
|
player->m_Local.m_flFallVelocity += player->GetGroundEntity()->GetAbsVelocity().z;
|
|
player->m_Local.m_flFallVelocity = MAX( 0.1f, player->m_Local.m_flFallVelocity );
|
|
}
|
|
|
|
if ( player->m_Local.m_flFallVelocity > PLAYER_MAX_SAFE_FALL_SPEED )
|
|
{
|
|
//
|
|
// If they hit the ground going this fast they may take damage (and die).
|
|
//
|
|
bAlive = MoveHelper( )->PlayerFallingDamage();
|
|
fvol = 1.0;
|
|
}
|
|
else if ( player->m_Local.m_flFallVelocity > PLAYER_MAX_SAFE_FALL_SPEED / 2 )
|
|
{
|
|
fvol = 0.85;
|
|
}
|
|
else if ( player->m_Local.m_flFallVelocity < PLAYER_MIN_BOUNCE_SPEED )
|
|
{
|
|
fvol = 0;
|
|
}
|
|
}
|
|
|
|
PlayerRoughLandingEffects( fvol );
|
|
|
|
if (bAlive)
|
|
{
|
|
MoveHelper( )->PlayerSetAnimation( PLAYER_WALK );
|
|
}
|
|
}
|
|
|
|
// let any subclasses know that the player has landed and how hard
|
|
OnLand(player->m_Local.m_flFallVelocity);
|
|
|
|
//
|
|
// Clear the fall velocity so the impact doesn't happen again.
|
|
//
|
|
player->m_Local.m_flFallVelocity = 0;
|
|
}
|
|
|
|
void CGameMovement::PlayerRoughLandingEffects( float fvol )
|
|
{
|
|
if ( fvol > 0.0 )
|
|
{
|
|
//
|
|
// Play landing sound right away.
|
|
player->m_flStepSoundTime = 400;
|
|
|
|
// Play step sound for current texture.
|
|
player->PlayStepSound( (Vector &)mv->GetAbsOrigin(), player->m_pSurfaceData, fvol, true );
|
|
|
|
//
|
|
// Knock the screen around a little bit, temporary effect.
|
|
//
|
|
player->m_Local.m_vecPunchAngle.Set( ROLL, player->m_Local.m_flFallVelocity * 0.013 );
|
|
|
|
if ( player->m_Local.m_vecPunchAngle[PITCH] > 8 )
|
|
{
|
|
player->m_Local.m_vecPunchAngle.Set( PITCH, 8 );
|
|
}
|
|
|
|
#if !defined( CLIENT_DLL )
|
|
player->RumbleEffect( ( fvol > 0.85f ) ? ( RUMBLE_FALL_LONG ) : ( RUMBLE_FALL_SHORT ), 0, RUMBLE_FLAGS_NONE );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use for ease-in, ease-out style interpolation (accel/decel) Used by ducking code.
|
|
// Input : value -
|
|
// scale -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CGameMovement::SplineFraction( float value, float scale )
|
|
{
|
|
float valueSquared;
|
|
|
|
value = scale * value;
|
|
valueSquared = value * value;
|
|
|
|
// Nice little ease-in, ease-out spline-like curve
|
|
return 3 * valueSquared - 2 * valueSquared * value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determine if crouch/uncrouch caused player to get stuck in world
|
|
// Input : direction -
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FixPlayerCrouchStuck( bool upward )
|
|
{
|
|
EntityHandle_t hitent;
|
|
int i;
|
|
Vector test;
|
|
trace_t dummy;
|
|
|
|
int direction = upward ? 1 : 0;
|
|
|
|
hitent = TestPlayerPosition( mv->GetAbsOrigin(), COLLISION_GROUP_PLAYER_MOVEMENT, dummy );
|
|
if (hitent == INVALID_ENTITY_HANDLE )
|
|
return;
|
|
|
|
VectorCopy( mv->GetAbsOrigin(), test );
|
|
for ( i = 0; i < 36; i++ )
|
|
{
|
|
Vector org = mv->GetAbsOrigin();
|
|
org.z += direction;
|
|
mv->SetAbsOrigin( org );
|
|
hitent = TestPlayerPosition( mv->GetAbsOrigin(), COLLISION_GROUP_PLAYER_MOVEMENT, dummy );
|
|
if (hitent == INVALID_ENTITY_HANDLE )
|
|
return;
|
|
}
|
|
|
|
mv->SetAbsOrigin( test ); // Failed
|
|
}
|
|
|
|
bool CGameMovement::CanUnduck()
|
|
{
|
|
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
|
|
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 );
|
|
}
|
|
|
|
bool saveducked = player->m_Local.m_bDucked;
|
|
player->m_Local.m_bDucked = false;
|
|
TracePlayerBBox( mv->GetAbsOrigin(), newOrigin, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
player->m_Local.m_bDucked = saveducked;
|
|
if ( trace.startsolid || ( trace.fraction != 1.0f ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Stop ducking
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::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
|
|
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;
|
|
player->m_Local.m_bInDuckJump = false;
|
|
player->SetViewOffset( GetPlayerViewOffset( false ) );
|
|
player->m_Local.m_flDucktime = 0;
|
|
|
|
mv->SetAbsOrigin( newOrigin );
|
|
|
|
#ifdef CLIENT_DLL
|
|
#ifdef STAGING_ONLY
|
|
if ( debug_latch_reset_onduck.GetBool() )
|
|
{
|
|
player->ResetLatched();
|
|
}
|
|
#else
|
|
player->ResetLatched();
|
|
#endif
|
|
#endif // CLIENT_DLL
|
|
|
|
// Recategorize position since ducking can change origin
|
|
CategorizePosition();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::UpdateDuckJumpEyeOffset( void )
|
|
{
|
|
if ( player->m_Local.m_flDuckJumpTime != 0.0f )
|
|
{
|
|
float flDuckMilliseconds = MAX( 0.0f, GAMEMOVEMENT_DUCK_TIME - ( float )player->m_Local.m_flDuckJumpTime );
|
|
float flDuckSeconds = flDuckMilliseconds / GAMEMOVEMENT_DUCK_TIME;
|
|
if ( flDuckSeconds > TIME_TO_UNDUCK )
|
|
{
|
|
player->m_Local.m_flDuckJumpTime = 0.0f;
|
|
SetDuckedEyeOffset( 0.0f );
|
|
}
|
|
else
|
|
{
|
|
float flDuckFraction = SimpleSpline( 1.0f - ( flDuckSeconds / TIME_TO_UNDUCK ) );
|
|
SetDuckedEyeOffset( flDuckFraction );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FinishUnDuckJump( trace_t &trace )
|
|
{
|
|
Vector vecNewOrigin;
|
|
VectorCopy( mv->GetAbsOrigin(), vecNewOrigin );
|
|
|
|
// Up for uncrouching.
|
|
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 );
|
|
|
|
float flDeltaZ = viewDelta.z;
|
|
viewDelta.z *= trace.fraction;
|
|
flDeltaZ -= viewDelta.z;
|
|
|
|
player->RemoveFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucked = false;
|
|
player->m_Local.m_bDucking = false;
|
|
player->m_Local.m_bInDuckJump = false;
|
|
player->m_Local.m_flDucktime = 0.0f;
|
|
player->m_Local.m_flDuckJumpTime = 0.0f;
|
|
player->m_Local.m_flJumpTime = 0.0f;
|
|
|
|
Vector vecViewOffset = GetPlayerViewOffset( false );
|
|
vecViewOffset.z -= flDeltaZ;
|
|
player->SetViewOffset( vecViewOffset );
|
|
|
|
VectorSubtract( vecNewOrigin, viewDelta, vecNewOrigin );
|
|
mv->SetAbsOrigin( vecNewOrigin );
|
|
|
|
// Recategorize position since ducking can change origin
|
|
CategorizePosition();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finish ducking
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FinishDuck( void )
|
|
{
|
|
// if ( player->GetFlags() & FL_DUCKING ) return;
|
|
|
|
player->AddFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucked = true;
|
|
player->m_Local.m_bDucking = false;
|
|
|
|
player->SetViewOffset( GetPlayerViewOffset( true ) );
|
|
|
|
// HACKHACK - Fudge for collision bug - no time to fix this properly
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
for ( int i = 0; i < 3; i++ )
|
|
{
|
|
Vector org = mv->GetAbsOrigin();
|
|
org[ i ]-= ( VEC_DUCK_HULL_MIN_SCALED( player )[i] - VEC_HULL_MIN_SCALED( player )[i] );
|
|
mv->SetAbsOrigin( org );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
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 );
|
|
Vector out;
|
|
VectorAdd( mv->GetAbsOrigin(), viewDelta, out );
|
|
mv->SetAbsOrigin( out );
|
|
|
|
#ifdef CLIENT_DLL
|
|
#ifdef STAGING_ONLY
|
|
if ( debug_latch_reset_onduck.GetBool() )
|
|
{
|
|
player->ResetLatched();
|
|
}
|
|
#else
|
|
player->ResetLatched();
|
|
#endif
|
|
#endif // CLIENT_DLL
|
|
}
|
|
|
|
// See if we are stuck?
|
|
FixPlayerCrouchStuck( true );
|
|
|
|
// Recategorize position since ducking can change origin
|
|
CategorizePosition();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::StartUnDuckJump( void )
|
|
{
|
|
player->AddFlag( FL_DUCKING );
|
|
player->m_Local.m_bDucked = true;
|
|
player->m_Local.m_bDucking = false;
|
|
|
|
player->SetViewOffset( GetPlayerViewOffset( true ) );
|
|
|
|
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 );
|
|
Vector out;
|
|
VectorAdd( mv->GetAbsOrigin(), viewDelta, out );
|
|
mv->SetAbsOrigin( out );
|
|
|
|
// See if we are stuck?
|
|
FixPlayerCrouchStuck( true );
|
|
|
|
// Recategorize position since ducking can change origin
|
|
CategorizePosition();
|
|
}
|
|
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : duckFraction -
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::SetDuckedEyeOffset( float duckFraction )
|
|
{
|
|
Vector vDuckHullMin = GetPlayerMins( true );
|
|
Vector vStandHullMin = GetPlayerMins( false );
|
|
|
|
float fMore = ( vDuckHullMin.z - vStandHullMin.z );
|
|
|
|
Vector vecDuckViewOffset = GetPlayerViewOffset( true );
|
|
Vector vecStandViewOffset = GetPlayerViewOffset( false );
|
|
Vector temp = player->GetViewOffset();
|
|
temp.z = ( ( vecDuckViewOffset.z - fMore ) * duckFraction ) +
|
|
( vecStandViewOffset.z * ( 1 - duckFraction ) );
|
|
player->SetViewOffset( temp );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Crop the speed of the player when ducking and on the ground.
|
|
// Input: bInDuck - is the player already ducking
|
|
// bInAir - is the player in air
|
|
// NOTE: Only crop player speed once.
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::HandleDuckingSpeedCrop( void )
|
|
{
|
|
if ( !( m_iSpeedCropped & SPEED_CROPPED_DUCK ) && ( player->GetFlags() & FL_DUCKING ) && ( player->GetGroundEntity() != NULL ) )
|
|
{
|
|
float frac = 0.33333333f;
|
|
mv->m_flForwardMove *= frac;
|
|
mv->m_flSideMove *= frac;
|
|
mv->m_flUpMove *= frac;
|
|
m_iSpeedCropped |= SPEED_CROPPED_DUCK;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check to see if we are in a situation where we can unduck jump.
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameMovement::CanUnDuckJump( trace_t &trace )
|
|
{
|
|
// Trace down to the stand position and see if we can stand.
|
|
Vector vecEnd( mv->GetAbsOrigin() );
|
|
vecEnd.z -= 36.0f; // This will have to change if bounding hull change!
|
|
TracePlayerBBox( mv->GetAbsOrigin(), vecEnd, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
|
|
if ( trace.fraction < 1.0f )
|
|
{
|
|
// Find the endpoint.
|
|
vecEnd.z = mv->GetAbsOrigin().z + ( -36.0f * trace.fraction );
|
|
|
|
// Test a normal hull.
|
|
trace_t traceUp;
|
|
bool bWasDucked = player->m_Local.m_bDucked;
|
|
player->m_Local.m_bDucked = false;
|
|
TracePlayerBBox( vecEnd, vecEnd, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, traceUp );
|
|
player->m_Local.m_bDucked = bWasDucked;
|
|
if ( !traceUp.startsolid )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: See if duck button is pressed and do the appropriate things
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::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"
|
|
|
|
// Check to see if we are in the air.
|
|
bool bInAir = ( player->GetGroundEntity() == NULL );
|
|
bool bInDuck = ( player->GetFlags() & FL_DUCKING ) ? true : false;
|
|
bool bDuckJump = ( player->m_Local.m_flJumpTime > 0.0f );
|
|
bool bDuckJumpTime = ( player->m_Local.m_flDuckJumpTime > 0.0f );
|
|
|
|
if ( mv->m_nButtons & IN_DUCK )
|
|
{
|
|
mv->m_nOldButtons |= IN_DUCK;
|
|
}
|
|
else
|
|
{
|
|
mv->m_nOldButtons &= ~IN_DUCK;
|
|
}
|
|
|
|
// Handle death.
|
|
if ( IsDead() )
|
|
return;
|
|
|
|
// Slow down ducked players.
|
|
HandleDuckingSpeedCrop();
|
|
|
|
// If the player is holding down the duck button, the player is in duck transition, ducking, or duck-jumping.
|
|
if ( ( mv->m_nButtons & IN_DUCK ) || player->m_Local.m_bDucking || bInDuck || bDuckJump )
|
|
{
|
|
// DUCK
|
|
if ( ( mv->m_nButtons & IN_DUCK ) || bDuckJump )
|
|
{
|
|
// XBOX SERVER ONLY
|
|
#if !defined(CLIENT_DLL)
|
|
if ( IsX360() && buttonsPressed & IN_DUCK )
|
|
{
|
|
// Hinting logic
|
|
if ( player->GetToggledDuckState() && player->m_nNumCrouches < NUM_CROUCH_HINTS )
|
|
{
|
|
UTIL_HudHintText( player, "#Valve_Hint_Crouch" );
|
|
player->m_nNumCrouches++;
|
|
}
|
|
}
|
|
#endif
|
|
// Have the duck button pressed, but the player currently isn't in the duck position.
|
|
if ( ( buttonsPressed & IN_DUCK ) && !bInDuck && !bDuckJump && !bDuckJumpTime )
|
|
{
|
|
player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME;
|
|
player->m_Local.m_bDucking = true;
|
|
}
|
|
|
|
// The player is in duck transition and not duck-jumping.
|
|
if ( player->m_Local.m_bDucking && !bDuckJump && !bDuckJumpTime )
|
|
{
|
|
float flDuckMilliseconds = MAX( 0.0f, GAMEMOVEMENT_DUCK_TIME - ( float )player->m_Local.m_flDucktime );
|
|
float flDuckSeconds = flDuckMilliseconds * 0.001f;
|
|
|
|
// Finish in duck transition when transition time is over, in "duck", in air.
|
|
if ( ( flDuckSeconds > TIME_TO_DUCK ) || bInDuck || bInAir )
|
|
{
|
|
FinishDuck();
|
|
}
|
|
else
|
|
{
|
|
// Calc parametric time
|
|
float flDuckFraction = SimpleSpline( flDuckSeconds / TIME_TO_DUCK );
|
|
SetDuckedEyeOffset( flDuckFraction );
|
|
}
|
|
}
|
|
|
|
if ( bDuckJump )
|
|
{
|
|
// Make the bounding box small immediately.
|
|
if ( !bInDuck )
|
|
{
|
|
StartUnDuckJump();
|
|
}
|
|
else
|
|
{
|
|
// Check for a crouch override.
|
|
if ( !( mv->m_nButtons & IN_DUCK ) )
|
|
{
|
|
trace_t trace;
|
|
if ( CanUnDuckJump( trace ) )
|
|
{
|
|
FinishUnDuckJump( trace );
|
|
player->m_Local.m_flDuckJumpTime = ( GAMEMOVEMENT_TIME_TO_UNDUCK * ( 1.0f - trace.fraction ) ) + GAMEMOVEMENT_TIME_TO_UNDUCK_INV;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// UNDUCK (or attempt to...)
|
|
else
|
|
{
|
|
if ( player->m_Local.m_bInDuckJump )
|
|
{
|
|
// Check for a crouch override.
|
|
if ( !( mv->m_nButtons & IN_DUCK ) )
|
|
{
|
|
trace_t trace;
|
|
if ( CanUnDuckJump( trace ) )
|
|
{
|
|
FinishUnDuckJump( trace );
|
|
|
|
if ( trace.fraction < 1.0f )
|
|
{
|
|
player->m_Local.m_flDuckJumpTime = ( GAMEMOVEMENT_TIME_TO_UNDUCK * ( 1.0f - trace.fraction ) ) + GAMEMOVEMENT_TIME_TO_UNDUCK_INV;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
player->m_Local.m_bInDuckJump = false;
|
|
}
|
|
}
|
|
|
|
if ( bDuckJumpTime )
|
|
return;
|
|
|
|
// Try to unduck unless automovement is not allowed
|
|
// NOTE: When not onground, you can always unduck
|
|
if ( player->m_Local.m_bAllowAutoMovement || bInAir || player->m_Local.m_bDucking )
|
|
{
|
|
// We released the duck button, we aren't in "duck" and we are not in the air - start unduck transition.
|
|
if ( ( buttonsReleased & IN_DUCK ) )
|
|
{
|
|
if ( bInDuck && !bDuckJump )
|
|
{
|
|
player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME;
|
|
}
|
|
else if ( player->m_Local.m_bDucking && !player->m_Local.m_bDucked )
|
|
{
|
|
// Invert time if release before fully ducked!!!
|
|
float unduckMilliseconds = 1000.0f * TIME_TO_UNDUCK;
|
|
float duckMilliseconds = 1000.0f * TIME_TO_DUCK;
|
|
float elapsedMilliseconds = GAMEMOVEMENT_DUCK_TIME - player->m_Local.m_flDucktime;
|
|
|
|
float fracDucked = elapsedMilliseconds / duckMilliseconds;
|
|
float remainingUnduckMilliseconds = fracDucked * unduckMilliseconds;
|
|
|
|
player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME - unduckMilliseconds + remainingUnduckMilliseconds;
|
|
}
|
|
}
|
|
|
|
|
|
// Check to see if we are capable of unducking.
|
|
if ( CanUnduck() )
|
|
{
|
|
// or unducking
|
|
if ( ( player->m_Local.m_bDucking || player->m_Local.m_bDucked ) )
|
|
{
|
|
float flDuckMilliseconds = MAX( 0.0f, GAMEMOVEMENT_DUCK_TIME - (float)player->m_Local.m_flDucktime );
|
|
float flDuckSeconds = flDuckMilliseconds * 0.001f;
|
|
|
|
// Finish ducking immediately if duck time is over or not on ground
|
|
if ( flDuckSeconds > TIME_TO_UNDUCK || ( bInAir && !bDuckJump ) )
|
|
{
|
|
FinishUnDuck();
|
|
}
|
|
else
|
|
{
|
|
// Calc parametric time
|
|
float flDuckFraction = SimpleSpline( 1.0f - ( flDuckSeconds / TIME_TO_UNDUCK ) );
|
|
SetDuckedEyeOffset( flDuckFraction );
|
|
player->m_Local.m_bDucking = true;
|
|
}
|
|
}
|
|
}
|
|
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.
|
|
if ( player->m_Local.m_flDucktime != GAMEMOVEMENT_DUCK_TIME )
|
|
{
|
|
SetDuckedEyeOffset(1.0f);
|
|
player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME;
|
|
player->m_Local.m_bDucked = true;
|
|
player->m_Local.m_bDucking = false;
|
|
player->AddFlag( FL_DUCKING );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// HACK: (jimd 5/25/2006) we have a reoccuring bug (#50063 in Tracker) where the player's
|
|
// view height gets left at the ducked height while the player is standing, but we haven't
|
|
// been able to repro it to find the cause. It may be fixed now due to a change I'm
|
|
// also making in UpdateDuckJumpEyeOffset but just in case, this code will sense the
|
|
// problem and restore the eye to the proper position. It doesn't smooth the transition,
|
|
// but it is preferable to leaving the player's view too low.
|
|
//
|
|
// If the player is still alive and not an observer, check to make sure that
|
|
// his view height is at the standing height.
|
|
else if ( !IsDead() && !player->IsObserver() && !player->IsInAVehicle() )
|
|
{
|
|
if ( ( player->m_Local.m_flDuckJumpTime == 0.0f ) && ( fabs(player->GetViewOffset().z - GetPlayerViewOffset( false ).z) > 0.1 ) )
|
|
{
|
|
// we should rarely ever get here, so assert so a coder knows when it happens
|
|
Assert(0);
|
|
DevMsg( 1, "Restoring player view height\n" );
|
|
|
|
// set the eye height to the non-ducked height
|
|
SetDuckedEyeOffset(0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
static ConVar sv_optimizedmovement( "sv_optimizedmovement", "1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::PlayerMove( void )
|
|
{
|
|
VPROF( "CGameMovement::PlayerMove" );
|
|
|
|
CheckParameters();
|
|
|
|
// clear output applied velocity
|
|
mv->m_outWishVel.Init();
|
|
mv->m_outJumpVel.Init();
|
|
|
|
MoveHelper( )->ResetTouchList(); // Assume we don't touch anything
|
|
|
|
ReduceTimers();
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &m_vecForward, &m_vecRight, &m_vecUp ); // Determine movement angles
|
|
|
|
// Always try and unstick us unless we are using a couple of the movement modes
|
|
if ( player->GetMoveType() != MOVETYPE_NOCLIP &&
|
|
player->GetMoveType() != MOVETYPE_NONE &&
|
|
player->GetMoveType() != MOVETYPE_ISOMETRIC &&
|
|
player->GetMoveType() != MOVETYPE_OBSERVER &&
|
|
!player->pl.deadflag )
|
|
{
|
|
if ( CheckInterval( STUCK ) )
|
|
{
|
|
if ( CheckStuck() )
|
|
{
|
|
// Can't move, we're stuck
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now that we are "unstuck", see where we are (player->GetWaterLevel() and type, player->GetGroundEntity()).
|
|
if ( player->GetMoveType() != MOVETYPE_WALK ||
|
|
mv->m_bGameCodeMovedPlayer ||
|
|
!sv_optimizedmovement.GetBool() )
|
|
{
|
|
CategorizePosition();
|
|
}
|
|
else
|
|
{
|
|
if ( mv->m_vecVelocity.z > 250.0f )
|
|
{
|
|
SetGroundEntity( NULL );
|
|
}
|
|
}
|
|
|
|
// Store off the starting water level
|
|
m_nOldWaterLevel = player->GetWaterLevel();
|
|
|
|
// If we are not on ground, store off how fast we are moving down
|
|
if ( player->GetGroundEntity() == NULL )
|
|
{
|
|
player->m_Local.m_flFallVelocity = -mv->m_vecVelocity[ 2 ];
|
|
}
|
|
|
|
m_nOnLadder = 0;
|
|
|
|
player->UpdateStepSound( player->m_pSurfaceData, mv->GetAbsOrigin(), mv->m_vecVelocity );
|
|
|
|
UpdateDuckJumpEyeOffset();
|
|
Duck();
|
|
|
|
// Don't run ladder code if dead on on a train
|
|
if ( !player->pl.deadflag && !(player->GetFlags() & FL_ONTRAIN) )
|
|
{
|
|
// If was not on a ladder now, but was on one before,
|
|
// get off of the ladder
|
|
|
|
// TODO: this causes lots of weirdness.
|
|
//bool bCheckLadder = CheckInterval( LADDER );
|
|
//if ( bCheckLadder || player->GetMoveType() == MOVETYPE_LADDER )
|
|
{
|
|
if ( !LadderMove() &&
|
|
( player->GetMoveType() == MOVETYPE_LADDER ) )
|
|
{
|
|
// Clear ladder stuff unless player is dead or riding a train
|
|
// It will be reset immediately again next frame if necessary
|
|
player->SetMoveType( MOVETYPE_WALK );
|
|
player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
Msg("%i, %i, %s, player = %8x, move type = %2i, ground entity = %8x, velocity = (%f %f %f)\n",
|
|
player->CurrentCommandNumber(),
|
|
player->m_nTickBase,
|
|
player->IsServer() ? "SERVER" : "CLIENT",
|
|
player,
|
|
player->GetMoveType(),
|
|
player->GetGroundEntity(),
|
|
mv->m_vecVelocity[0], mv->m_vecVelocity[1], mv->m_vecVelocity[2]);
|
|
|
|
#endif
|
|
|
|
// Handle movement modes.
|
|
switch (player->GetMoveType())
|
|
{
|
|
case MOVETYPE_NONE:
|
|
break;
|
|
|
|
case MOVETYPE_NOCLIP:
|
|
FullNoClipMove( sv_noclipspeed.GetFloat(), sv_noclipaccelerate.GetFloat() );
|
|
break;
|
|
|
|
case MOVETYPE_FLY:
|
|
case MOVETYPE_FLYGRAVITY:
|
|
FullTossMove();
|
|
break;
|
|
|
|
case MOVETYPE_LADDER:
|
|
FullLadderMove();
|
|
break;
|
|
|
|
case MOVETYPE_WALK:
|
|
FullWalkMove();
|
|
break;
|
|
|
|
case MOVETYPE_ISOMETRIC:
|
|
//IsometricMove();
|
|
// Could also try: FullTossMove();
|
|
FullWalkMove();
|
|
break;
|
|
|
|
case MOVETYPE_OBSERVER:
|
|
FullObserverMove(); // clips against world&players
|
|
break;
|
|
|
|
default:
|
|
DevMsg( 1, "Bogus pmove player movetype %i on (%i) 0=cl 1=sv\n", player->GetMoveType(), player->IsServer());
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Performs the collision resolution for fliers.
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::PerformFlyCollisionResolution( trace_t &pm, Vector &move )
|
|
{
|
|
Vector base;
|
|
float vel;
|
|
float backoff;
|
|
|
|
switch (player->GetMoveCollide())
|
|
{
|
|
case MOVECOLLIDE_FLY_CUSTOM:
|
|
// Do nothing; the velocity should have been modified by touch
|
|
// FIXME: It seems wrong for touch to modify velocity
|
|
// given that it can be called in a number of places
|
|
// where collision resolution do *not* in fact occur
|
|
|
|
// Should this ever occur for players!?
|
|
Assert(0);
|
|
break;
|
|
|
|
case MOVECOLLIDE_FLY_BOUNCE:
|
|
case MOVECOLLIDE_DEFAULT:
|
|
{
|
|
if (player->GetMoveCollide() == MOVECOLLIDE_FLY_BOUNCE)
|
|
backoff = 2.0 - player->m_surfaceFriction;
|
|
else
|
|
backoff = 1;
|
|
|
|
ClipVelocity (mv->m_vecVelocity, pm.plane.normal, mv->m_vecVelocity, backoff);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Invalid collide type!
|
|
Assert(0);
|
|
break;
|
|
}
|
|
|
|
// stop if on ground
|
|
if (pm.plane.normal[2] > 0.7)
|
|
{
|
|
base.Init();
|
|
if (mv->m_vecVelocity[2] < GetCurrentGravity() * gpGlobals->frametime)
|
|
{
|
|
// we're rolling on the ground, add static friction.
|
|
SetGroundEntity( &pm );
|
|
mv->m_vecVelocity[2] = 0;
|
|
}
|
|
|
|
vel = DotProduct( mv->m_vecVelocity, mv->m_vecVelocity );
|
|
|
|
// Con_DPrintf("%f %f: %.0f %.0f %.0f\n", vel, trace.fraction, ent->velocity[0], ent->velocity[1], ent->velocity[2] );
|
|
|
|
if (vel < (30 * 30) || (player->GetMoveCollide() != MOVECOLLIDE_FLY_BOUNCE))
|
|
{
|
|
SetGroundEntity( &pm );
|
|
mv->m_vecVelocity.Init();
|
|
}
|
|
else
|
|
{
|
|
VectorScale (mv->m_vecVelocity, (1.0 - pm.fraction) * gpGlobals->frametime * 0.9, move);
|
|
PushEntity( move, &pm );
|
|
}
|
|
VectorSubtract( mv->m_vecVelocity, base, mv->m_vecVelocity );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::FullTossMove( void )
|
|
{
|
|
trace_t pm;
|
|
Vector move;
|
|
|
|
CheckWater();
|
|
|
|
// add velocity if player is moving
|
|
if ( (mv->m_flForwardMove != 0.0f) || (mv->m_flSideMove != 0.0f) || (mv->m_flUpMove != 0.0f))
|
|
{
|
|
Vector forward, right, up;
|
|
float fmove, smove;
|
|
Vector wishdir, wishvel;
|
|
float wishspeed;
|
|
int i;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
// Copy movement amounts
|
|
fmove = mv->m_flForwardMove;
|
|
smove = mv->m_flSideMove;
|
|
|
|
VectorNormalize (forward); // Normalize remainder of vectors.
|
|
VectorNormalize (right); //
|
|
|
|
for (i=0 ; i<3 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
|
|
wishvel[2] += mv->m_flUpMove;
|
|
|
|
VectorCopy (wishvel, wishdir); // Determine maginitude of speed of move
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
//
|
|
// Clamp to server defined max speed
|
|
//
|
|
if (wishspeed > mv->m_flMaxSpeed)
|
|
{
|
|
VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
|
|
wishspeed = mv->m_flMaxSpeed;
|
|
}
|
|
|
|
// Set pmove velocity
|
|
Accelerate ( wishdir, wishspeed, sv_accelerate.GetFloat() );
|
|
}
|
|
|
|
if ( mv->m_vecVelocity[2] > 0 )
|
|
{
|
|
SetGroundEntity( NULL );
|
|
}
|
|
|
|
// If on ground and not moving, return.
|
|
if ( player->GetGroundEntity() != NULL )
|
|
{
|
|
if (VectorCompare(player->GetBaseVelocity(), vec3_origin) &&
|
|
VectorCompare(mv->m_vecVelocity, vec3_origin))
|
|
return;
|
|
}
|
|
|
|
CheckVelocity();
|
|
|
|
// add gravity
|
|
if ( player->GetMoveType() == MOVETYPE_FLYGRAVITY )
|
|
{
|
|
AddGravity();
|
|
}
|
|
|
|
// move origin
|
|
// Base velocity is not properly accounted for since this entity will move again after the bounce without
|
|
// taking it into account
|
|
VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
|
|
|
|
CheckVelocity();
|
|
|
|
VectorScale (mv->m_vecVelocity, gpGlobals->frametime, move);
|
|
VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
|
|
|
|
PushEntity( move, &pm ); // Should this clear basevelocity
|
|
|
|
CheckVelocity();
|
|
|
|
if (pm.allsolid)
|
|
{
|
|
// entity is trapped in another solid
|
|
SetGroundEntity( &pm );
|
|
mv->m_vecVelocity.Init();
|
|
return;
|
|
}
|
|
|
|
if (pm.fraction != 1)
|
|
{
|
|
PerformFlyCollisionResolution( pm, move );
|
|
}
|
|
|
|
// check for in water
|
|
CheckWater();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: TF2 commander mode movement logic
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#pragma warning (disable : 4701)
|
|
|
|
void CGameMovement::IsometricMove( void )
|
|
{
|
|
int i;
|
|
Vector wishvel;
|
|
float fmove, smove;
|
|
Vector forward, right, up;
|
|
|
|
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
|
|
|
|
// Copy movement amounts
|
|
fmove = mv->m_flForwardMove;
|
|
smove = mv->m_flSideMove;
|
|
|
|
// No up / down movement
|
|
forward[2] = 0;
|
|
right[2] = 0;
|
|
|
|
VectorNormalize (forward); // Normalize remainder of vectors
|
|
VectorNormalize (right); //
|
|
|
|
for (i=0 ; i<3 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
//wishvel[2] += mv->m_flUpMove;
|
|
|
|
Vector out;
|
|
VectorMA (mv->GetAbsOrigin(), gpGlobals->frametime, wishvel, out );
|
|
mv->SetAbsOrigin( out );
|
|
|
|
// Zero out the velocity so that we don't accumulate a huge downward velocity from
|
|
// gravity, etc.
|
|
mv->m_vecVelocity.Init();
|
|
}
|
|
|
|
#pragma warning (default : 4701)
|
|
|
|
|
|
bool CGameMovement::GameHasLadders() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Traces player movement + position
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::TracePlayerBBox( const Vector& start, const Vector& end, unsigned int fMask, int collisionGroup, trace_t& pm )
|
|
{
|
|
VPROF( "CGameMovement::TracePlayerBBox" );
|
|
|
|
Ray_t ray;
|
|
ray.Init( start, end, GetPlayerMins(), GetPlayerMaxs() );
|
|
UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &pm );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: overridded by game classes to limit results (to standable objects for example)
|
|
//-----------------------------------------------------------------------------
|
|
void CGameMovement::TryTouchGround( const Vector& start, const Vector& end, const Vector& mins, const Vector& maxs, unsigned int fMask, int collisionGroup, trace_t& pm )
|
|
{
|
|
VPROF( "CGameMovement::TryTouchGround" );
|
|
|
|
Ray_t ray;
|
|
ray.Init( start, end, mins, maxs );
|
|
UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &pm );
|
|
}
|
|
|