First version of the SOurce SDK 2013

1 files changed, 4909 insertions, 0 deletions

diff --git a/mp/src/game/shared/gamemovement.cpp b/mp/src/game/shared/gamemovement.cpp
new file mode 100644
index 00000000..816379f3
--- /dev/null
+++ b/mp/src/game/shared/gamemovement.cpp
@@ -0,0 +1,4909 @@
+//========= 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

+

+// [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

+	player->ResetLatched();

+#endif

+

+	// 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

+		player->ResetLatched();

+#endif

+	}

+

+	// 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 );

+}

+