1HEADmaster

1 files changed, 2149 insertions, 0 deletions

diff --git a/game/shared/tf2/tf_gamemovement.cpp b/game/shared/tf2/tf_gamemovement.cpp
new file mode 100644
index 0000000..46366d9
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement.cpp
@@ -0,0 +1,2149 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement.h"
+#include "in_buttons.h"
+#include "tier0/vprof.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+
+#define	SPEED_STOP_THRESHOLD		1.0f
+#define BUMP_MAX_COUNT				8
+
+//#define IMPACT_NORMAL_FLOOR			0.35f
+#define	IMPACT_NORMAL_FLOOR			0.7f
+#define IMPACT_NORMAL_WALL			0.0f
+
+enum
+{
+	MOVEMENT_BLOCKED_NONE  = 0x0,
+	MOVEMENT_BLOCKED_WALL  = 0x1,
+	MOVEMENT_BLOCKED_FLOOR = 0x2,
+	MOVEMENT_BLOCKED_ALL   = 0x4
+};
+
+#define SPEED_CROP_FRACTION_WALKING		0.4f
+#define SPEED_CROP_FRACTION_USING		0.3f
+#define SPEED_CROP_FRACTION_DUCKING		0.3f
+
+char    *va(char *format, ...);
+
+extern bool g_bMovementOptimizations;
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::CategorizePosition( void )
+{
+	VPROF( "CTFGameMovement::CategorizePosition" );
+
+	// 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();
+
+	trace_t trace;
+	Vector vStart( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z );
+	Vector vEnd( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z - 66 );
+
+	// Assume we are not on the ground
+	SetGroundEntity( NULL );
+	m_pSurfaceData = NULL;
+	m_surfaceFriction = 1.0f;
+	m_chTextureType = 'C';
+
+	// Check our velocity in z (are we shooting up really fast - then we are not on ground).
+	if ( mv->m_vecVelocity.z <= 180.0f )
+	{
+		// Move downward.
+		TracePlayerBBox( vStart, vEnd, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+
+		// Check to see if we are on the ground
+		if ( ( ( trace.plane.normal.z >= IMPACT_NORMAL_FLOOR ) || trace.IsDispSurfaceWalkable() ) && ( trace.fraction < 0.06f ) )
+		{
+			SetGroundEntity( &trace );
+			VectorCopy( trace.plane.normal, m_vecGroundNormal );
+
+			// Add standing on object to touch list
+			if ( trace.DidHitNonWorldEntity() )
+			{
+				MoveHelper()->AddToTouched( trace, mv->m_vecVelocity );
+			}
+
+			// Reset water jumping.
+			player->m_flWaterJumpTime = 0.0f;
+
+			// If we could make the move, drop us down that 1 pixel
+			if ( ( int )player->GetWaterLevel() < WL_Waist && !trace.startsolid && !trace.allsolid )
+			{
+				// check distance we would like to move -- this is supposed to just keep up
+				// "on the ground" surface not stap us back to earth
+				mv->m_vecAbsOrigin = vStart + trace.fraction * ( vEnd - vStart );
+//				VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+			}		
+		}
+
+		// NOTE: should this be surrounded by trace.fraction <= 1.0f ?????
+
+		// Setup surface properties.
+		{
+			VPROF( "CTFGameMovement::CategorizePosition / Surface Props" );
+			IPhysicsSurfaceProps *physprops = MoveHelper( )->GetSurfaceProps();
+			m_surfaceProps = trace.surface.surfaceProps;
+			m_pSurfaceData = physprops->GetSurfaceData( m_surfaceProps );
+			physprops->GetPhysicsProperties( m_surfaceProps, NULL, NULL, &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.
+		m_surfaceFriction *= 1.25f;
+		if ( m_surfaceFriction > 1.0f )
+			m_surfaceFriction = 1.0f;
+		m_chTextureType = m_pSurfaceData->game.material;
+	}
+
+	// If we are not on the ground...
+	if ( player->GetGroundEntity() == NULL )
+	{
+		player->m_Local.m_flFallVelocity = -mv->m_vecVelocity.z;
+	}
+
+	// Store off the starting water level
+	m_nOldWaterLevel = player->GetWaterLevel();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::HandleLadder( void )
+{
+	// No ladder movement if the player is dead or on a train.
+	if ( player->pl.deadflag || ( player->GetFlags() & FL_ONTRAIN ) )
+		return;
+
+	// Ladder initialization.
+	m_nOnLadder = 0;
+
+	if ( !BaseClass::LadderMove() && ( player->GetMoveType() == MOVETYPE_LADDER ) )
+	{
+		// clear ladder stuff unless player is noclipping or being lifted by barnacle. 
+		// it will be set immediately again next frame if necessary
+		player->SetMoveType( MOVETYPE_WALK );
+		player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SpeedCrop( void )
+{
+	// Verify speed hasn't been cropped already (shouldn't have!!!).
+	if ( m_iSpeedCropped & SPEED_CROPPED_DUCK )
+		return;
+
+	// Set the speed cropped flag.
+	m_iSpeedCropped		|= SPEED_CROPPED_DUCK;
+
+	// If the "walking" key is pressed -- crop speed.
+	if ( mv->m_nButtons & IN_SPEED )
+	{
+		mv->m_flForwardMove *= SPEED_CROP_FRACTION_WALKING;
+		mv->m_flSideMove *= SPEED_CROP_FRACTION_WALKING;
+		mv->m_flUpMove *= SPEED_CROP_FRACTION_WALKING;
+	}
+	// If the "use" key is pressed and the player is on the ground -- crop speed.
+	else if ( ( mv->m_nButtons & IN_USE ) && ( player->GetGroundEntity() != NULL ) )
+	{
+		mv->m_flForwardMove *= SPEED_CROP_FRACTION_USING;
+		mv->m_flSideMove *= SPEED_CROP_FRACTION_USING;
+		mv->m_flUpMove *= SPEED_CROP_FRACTION_USING;
+	}
+	// If the player is "ducking" -- crop speed
+	else if ( player->GetFlags() & FL_DUCKING )
+	{
+		mv->m_flForwardMove *= SPEED_CROP_FRACTION_DUCKING;
+		mv->m_flSideMove *= SPEED_CROP_FRACTION_DUCKING;
+		mv->m_flUpMove *= SPEED_CROP_FRACTION_DUCKING;
+	}
+
+	// Moving backwards happens more slowly
+	float flAngle = atan2( mv->m_flSideMove, mv->m_flForwardMove ) / M_PI;
+	flAngle = 2.0f * (fabs(flAngle) - 0.5f);
+	flAngle = clamp( flAngle, 0.0f, 1.0f );
+	float flFactor = 1.0f - fabs(flAngle) * (1.0f - sv_backspeed.GetFloat());
+
+	mv->m_flForwardMove *= flFactor;
+	mv->m_flSideMove *= flFactor;
+}
+
+
+//-----------------------------------------------------------------------------
+// Figures out how the constraint should slow us down
+//-----------------------------------------------------------------------------
+float CTFGameMovement::ComputeConstraintSpeedFactor( void )
+{
+	// If we have a constraint, slow down because of that too...
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove || pTFMove->m_flConstraintRadius == 0.0f )
+		return 1.0f;
+
+	float flDistSq = mv->m_vecAbsOrigin.DistToSqr( pTFMove->m_vecConstraintCenter );
+
+	float flOuterRadiusSq = pTFMove->m_flConstraintRadius * pTFMove->m_flConstraintRadius;
+	float flInnerRadiusSq = pTFMove->m_flConstraintRadius - pTFMove->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->m_vecAbsOrigin, pTFMove->m_vecConstraintCenter, vecDelta );
+	VectorNormalize( vecDelta );
+	VectorNormalize( vecDesired );
+	if (DotProduct( vecDelta, vecDesired ) < 0.0f)
+		return 1.0f;
+
+	float flFrac = (sqrt(flDistSq) - (pTFMove->m_flConstraintRadius - pTFMove->m_flConstraintWidth)) / pTFMove->m_flConstraintWidth;
+
+	float flSpeedFactor = Lerp( flFrac, 1.0f, pTFMove->m_flConstraintSpeedFactor ); 
+	return flSpeedFactor;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called in PrePlayerMove(), this function clamps the player's overall
+//          speed.  It is clamped to either the maximum client's or server's 
+//          speed (whichever is lower).
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SetupSpeed( void )
+{
+	// Reset the outgoing applied velocity.
+	mv->m_outWishVel.Init();
+
+	// Don't clamp speed if we are sin an "ISOMETRIC" or "NOCLIP" movetype.
+	if ( ( player->GetMoveType() == MOVETYPE_ISOMETRIC ) ||
+		 ( player->GetMoveType() == MOVETYPE_NOCLIP ) )
+		 return;
+
+	// Some events negate speed, check for these first.
+	if ( ( player->GetFlags() & FL_FROZEN ) || ( player->GetFlags() & FL_ONTRAIN ) ||  IsDead() )
+	{
+		mv->m_flForwardMove = 0;
+		mv->m_flSideMove = 0;
+		mv->m_flUpMove = 0;
+		return;
+	}
+
+	// Calculate the players max speed given movements.
+	float flSpeed = ( mv->m_flForwardMove * mv->m_flForwardMove ) +
+		            ( mv->m_flSideMove * mv->m_flSideMove ) +
+			 	    ( mv->m_flUpMove * mv->m_flUpMove );
+	if ( flSpeed == 0.0f )
+		return;
+
+	flSpeed = sqrt( flSpeed );
+
+	// NOTE: The client max speed was set to the movement max speed (mv->m_flMaxSpeed)
+	//       in the SetupMove, however the _ProcessMovement code post sets
+	//       mv->m_flMaxSpeed to the maximum server speed (sv_maxspeed),
+	//       thus, the need to the check.  If we forego the maximum server speed, 
+	//       this code can be removed.
+	if ( mv->m_flClientMaxSpeed )
+	{
+		mv->m_flMaxSpeed = MIN( mv->m_flClientMaxSpeed, mv->m_flMaxSpeed );
+	}
+
+	// Slow down by the speed factor
+	float flSpeedFactor = 1.0f;
+	if (m_pSurfaceData)
+	{
+		flSpeedFactor = m_pSurfaceData->game.maxSpeedFactor;
+	}
+
+	// If we have a constraint, slow down because of that too...
+	// Get the TF movement data
+	float flConstraintSpeedFactor = ComputeConstraintSpeedFactor();
+	if (flConstraintSpeedFactor < flSpeedFactor)
+		flSpeedFactor = flConstraintSpeedFactor;
+
+	mv->m_flMaxSpeed *= flSpeedFactor;
+
+	if ( flSpeed > mv->m_flMaxSpeed )
+	{
+		float flRatio = mv->m_flMaxSpeed / flSpeed;
+		mv->m_flForwardMove *= flRatio;
+		mv->m_flSideMove *= flRatio;
+		mv->m_flUpMove *= flRatio;
+	}
+
+	// Crop speed if necessary.
+	SpeedCrop();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::FinishUnDuck( void )
+{
+	int i;
+	trace_t trace;
+	Vector newOrigin;
+
+	Vector vDuckHullMin = GetPlayerMins( true );
+	Vector vStandHullMin = GetPlayerMins( false );
+
+	VectorCopy( mv->m_vecAbsOrigin, newOrigin );
+
+	if ( player->GetGroundEntity() != NULL )
+	{
+		for ( i = 0; i < 3; i++ )
+		{
+			newOrigin[i] += ( vDuckHullMin[i] - vStandHullMin[i] );
+		}
+	}
+	else
+	{
+  		Vector viewDelta = player->GetViewOffset() - GetPlayerViewOffset( false );
+		VectorAdd( newOrigin, viewDelta, newOrigin );
+	}
+	
+	TracePlayerBBox( newOrigin, newOrigin, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+	if ( !trace.startsolid )
+	{
+		player->m_Local.m_bDucked = false;
+
+		// Oh, no, changing hulls stuck us into something, try unsticking downward first.
+		TracePlayerBBox( newOrigin, newOrigin, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+		if ( trace.startsolid )
+		{
+			// See if we are stuck?  If so, stay ducked with the duck hull until we have a clear spot
+			player->m_Local.m_bDucked = true;
+			return;
+		}
+
+		player->RemoveFlag( FL_DUCKING );
+		player->m_Local.m_bDucking  = false;
+		player->SetViewOffset( GetPlayerViewOffset( false ) );
+		player->m_Local.m_flDucktime = 0;
+		
+		VectorCopy( newOrigin, mv->m_vecAbsOrigin );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::HandleDuck( void )
+{
+	// Store button presses and changes.
+	int buttonsChanged	= ( mv->m_nOldButtons ^ mv->m_nButtons );	// These buttons have changed this frame
+	int buttonsPressed	=  buttonsChanged & mv->m_nButtons;			// The changed ones still down are "pressed"
+	int buttonsReleased	=  buttonsChanged & mv->m_nOldButtons;		// The changed ones which were previously down are "released"
+
+	if ( mv->m_nButtons & IN_DUCK )
+	{
+		mv->m_nOldButtons |= IN_DUCK;
+	}
+	else
+	{
+		mv->m_nOldButtons &= ~IN_DUCK;
+	}
+
+	// Handle the player dead case.
+	if ( IsDead() && ( player->GetFlags() & FL_DUCKING ) )
+	{
+		FinishUnDuck();
+		return;
+	}
+
+	if ( ( mv->m_nButtons & IN_DUCK ) || ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
+	{
+		// Remove all movement when ducking!
+		mv->m_flForwardMove = 0.0f;
+		mv->m_flSideMove = 0.0f;
+		mv->m_flUpMove = 0.0f;
+
+		if ( mv->m_nButtons & IN_DUCK )
+		{
+			if ( ( buttonsPressed & IN_DUCK ) && !( player->GetFlags() & FL_DUCKING ) )
+			{
+				// Use 1 second so super long jump will work
+				player->m_Local.m_flDucktime = 1000;
+				player->m_Local.m_bDucking    = true;
+			}
+
+			float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
+			float duckseconds = duckmilliseconds / 1000.0f;
+			
+			if ( player->m_Local.m_bDucking )
+			{
+				// Finish ducking immediately if duck time is over or not on ground
+				if ( ( duckseconds > TIME_TO_DUCK ) || 
+					( player->GetGroundEntity() == NULL ) )
+				{
+					FinishDuck();
+				}
+				else
+				{
+					// Calc parametric time
+					float duckFraction = SimpleSpline( duckseconds / TIME_TO_DUCK );
+					SetDuckedEyeOffset( duckFraction );
+				}
+			}
+		}
+		else
+		{
+			if ( (buttonsReleased & IN_DUCK ) && ( player->GetFlags() & FL_DUCKING ) )
+			{
+				// Use 1 second so super long jump will work
+				player->m_Local.m_flDucktime = 1000;
+				player->m_Local.m_bDucking    = true;  // or unducking
+			}
+
+			float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
+			float duckseconds = duckmilliseconds / 1000.0f;
+
+			if ( player->m_Local.m_bDucking ) // or unducking
+			{
+				// Finish ducking immediately if duck time is over or not on ground
+				if ( ( duckseconds > TIME_TO_UNDUCK ) ||
+					 ( player->GetGroundEntity() == NULL ) )
+				{
+					FinishUnDuck();
+				}
+				else
+				{
+					// Calc parametric time
+					float duckFraction = SimpleSpline( 1.0f - ( duckseconds / TIME_TO_UNDUCK ) );
+					SetDuckedEyeOffset( duckFraction );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SetupViewAngles( void )
+{
+	// Cache the view angles.
+	AngleVectors( mv->m_vecViewAngles, &m_vecForward, &m_vecRight, &m_vecUp );
+
+	// Add a view punch if necessary.
+	QAngle	v_angle = ( mv->m_vecViewAngles + player->m_Local.m_vecPunchAngle );
+	
+	// Adjust the view roll angle.
+	if ( ( player->GetMoveType() != MOVETYPE_ISOMETRIC ) && ( player->GetMoveType() != MOVETYPE_NOCLIP ) )
+	{
+		mv->m_vecViewAngles[ROLL] = CalcRoll( v_angle, mv->m_vecVelocity, sv_rollangle.GetFloat(), sv_rollspeed.GetFloat() ) * 4.0f;
+	}
+	else
+	{
+		mv->m_vecViewAngles[ROLL] = 0.0f;
+	}
+
+	// Copy the yaw and pitch.
+	// NOTE: Adjust the client view angles to match the values on the server.
+	mv->m_vecViewAngles[PITCH] = v_angle[PITCH];
+	mv->m_vecViewAngles[YAW] = v_angle[YAW];
+	if ( mv->m_vecViewAngles[YAW] > 180.0f )
+	{
+		mv->m_vecViewAngles[YAW] -= 360.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CheckDeath( void )
+{
+	// If we are dead, setup the appropriate data
+	if ( IsDead() )
+	{
+		mv->m_flForwardMove = 0.0f;
+		mv->m_flSideMove = 0.0f;
+		mv->m_flUpMove = 0.0f;
+
+		VectorCopy( mv->m_vecOldAngles, mv->m_vecViewAngles );
+
+		player->SetViewOffset( VEC_DEAD_VIEWHEIGHT_SCALED( this ) );
+
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::UpdateTimers( void )
+{
+	BaseClass::ReduceTimers();
+	BaseClass::DecayPunchAngle();
+}
+
+
+//-----------------------------------------------------------------------------
+// Should the step sound play?
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::ShouldPlayStepSound( surfacedata_t *psurface, float fvol )
+{
+	if ( !m_nOnLadder && Vector2DLength( mv->m_vecVelocity.AsVector2D() ) <= 100 )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : step - 
+//			fvol - 
+//			force - force sound to play
+//-----------------------------------------------------------------------------
+void CTFGameMovement::PlayStepSound( surfacedata_t *psurface, float fvol, bool force )
+{
+	if ( gpGlobals->maxClients > 1 && !sv_footsteps.GetFloat() )
+		return;
+
+	if ( !psurface )
+		return;
+
+	if (!force && !ShouldPlayStepSound( psurface, fvol ))
+		return;
+
+// TODO:  See note above, should this be hooked up?
+//	PlantFootprint( psurface );
+
+	unsigned short stepSoundName = player->m_Local.m_nStepside ? psurface->sounds.stepleft : psurface->sounds.stepright;
+	player->m_Local.m_nStepside = !player->m_Local.m_nStepside;
+
+	if ( !stepSoundName )
+		return;
+
+	if ( !mv->m_bFirstRunOfFunctions )
+		return;
+
+	IPhysicsSurfaceProps *physprops = MoveHelper( )->GetSurfaceProps();
+	const char *pSoundName = physprops->GetString( stepSoundName );
+	char szSound[256];
+
+	// Prepend our team's footsteps
+	if ( player->GetTeamNumber() == TEAM_HUMANS )
+	{
+		Q_snprintf( szSound, sizeof(szSound), "Human.%s", pSoundName );
+	}
+	else if ( player->GetTeamNumber() == TEAM_ALIENS )
+	{
+		Q_snprintf( szSound, sizeof(szSound), "Alien.%s", pSoundName );
+	}
+	else
+	{
+		return;
+	}
+
+	CSoundParameters params;
+	if ( !CBaseEntity::GetParametersForSound( szSound, params, NULL ) )
+		return;
+
+	MoveHelper( )->StartSound( mv->m_vecAbsOrigin, CHAN_BODY, params.soundname, fvol, params.soundlevel, 0, params.pitch );
+}	
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int CTFGameMovement::CheckStuck( void )
+{
+	VPROF( "CTFGameMovement::CheckStuck" );
+
+	// NOTE: I am not bothering much with this as I am going to 
+	//       implement an new UnSticking process.
+	if ( ( player->GetMoveType() == MOVETYPE_NOCLIP ) ||
+         ( player->GetMoveType() == MOVETYPE_NONE ) ||
+		 ( player->GetMoveType() == MOVETYPE_ISOMETRIC ) )
+		 return 0;
+
+	return BaseClass::CheckStuck();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::PrePlayerMove( void )
+{
+	VPROF( "CTFGameMovement::PrePlayerMove" );
+
+	// Assume we don't touch anything (Reset the touch list).
+	MoveHelper()->ResetTouchList();
+
+	// Check to see if we are stuck.
+	if ( CheckStuck() )
+		return false;
+
+	// Update (reduce) movement timers.
+	UpdateTimers();
+
+	// Check to see if the player is dead and setup death data, otherwise setup 
+	// the players view angles.
+	if ( !CheckDeath() )
+	{
+		SetupViewAngles();
+	}
+
+	// Handle ducking.
+	HandleDuck();
+
+	// Handle ladder.
+	HandleLadder();
+
+	// Categorize the player's position.
+	CategorizePosition();
+
+	// Calculate the player's movement speed (has to happen after categorize position)
+	SetupSpeed();
+
+	// Update our stepping sound (based on the player's location).
+	player->UpdateStepSound( m_pSurfaceData, mv->m_vecAbsOrigin, mv->m_vecVelocity );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::PostPlayerMove( void )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::HandlePlayerMove( void )
+{
+	// Handle movement.
+	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:
+			{
+				// This should be moved elsewhere!!!  Just get it going for now.
+				CTFMoveData *pTFMove = TFMove();
+				Vector vecPlayerOrigin( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z );
+				FullWalkMove();
+				Vector vecPlayerDelta;
+				VectorSubtract( mv->m_vecAbsOrigin, vecPlayerOrigin, vecPlayerDelta );
+
+				if ( ( fabs( vecPlayerDelta.x ) > 0.0001f ) || 
+					 ( fabs( vecPlayerDelta.y ) > 0.0001f ) ||
+					 ( fabs( vecPlayerDelta.z ) > 0.0001f ) )
+				{
+					VectorCopy( vecPlayerDelta, pTFMove->m_vecPosDelta );
+				}
+				break;
+			}
+
+		case MOVETYPE_ISOMETRIC:
+			{
+				//IsometricMove();
+				// Could also try:  FullTossMove();
+				FullWalkMove();
+				break;
+			}
+
+		default:
+			{
+				DevMsg( 1, "Bogus pmove player movetype %i on (%i) 0=cl 1=sv\n", player->GetMoveType(), player->IsServer());
+				break;
+			}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::PlayerMove( void )
+{
+	VPROF( "CTFGameMovement::PlayerMove" );
+
+	// Setup and initialization pre-player movement.
+	if (!PrePlayerMove())
+		return;
+
+	// Handle Movement
+	HandlePlayerMove();
+
+	// Clean-up and updates post-player movement.
+	PostPlayerMove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::FullWalkMove()
+{
+	VPROF( "CTFGameMovement::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();
+		VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
+
+		// Redetermine position vars
+		CategorizePosition();
+	}
+	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();
+			WalkMove2();
+		}
+		else
+		{
+ 			AirMove();  // Take into account movement when in air.
+		}
+
+		// Set final flags.
+		CategorizePosition();
+
+		// 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 );
+
+		// 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();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::AirMove( void )
+{
+	VPROF( "CTFGameMovement::AirMove" );
+
+	// NOTE: This was causing some additional problems with walking on physics
+	//       objects.  The movement system needs to be cleaned up!  Keep the old
+	//       code until the system has been fixed.s
+	BaseClass::AirMove();
+	return;
+
+
+	int			i;
+	Vector		wishvel;
+	float		fmove, smove;
+	Vector		wishdir;
+	float		wishspeed;
+	Vector forward, right, up;
+
+	// Initialize the movement stack.
+	VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[0].m_vecPosition );
+	VectorCopy( m_vecGroundNormal, m_aMovementStack[0].m_vecImpactNormal );
+	m_nMovementStackSize = 1;
+
+	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 > 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 );
+
+	TryPlayerMove2();
+
+	// Try to stand up.
+	TryStanding();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::WalkMove( void )
+{
+	_WalkMove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is here until the new movement code is complete.  I needed
+//          to override hl2's walk move so that "floors" are identified 
+//          differently.
+//-----------------------------------------------------------------------------
+void CTFGameMovement::_WalkMove( void )
+{
+	VPROF( "CTFGameMovement::_WalkMove" );
+
+	int clip;
+	int i;
+
+	Vector wishvel;
+	float spd;
+	float fmove, smove;
+	Vector wishdir;
+	float wishspeed;
+
+	Vector dest, start;
+	Vector original, originalvel;
+	Vector down, downvel;
+	float downdist, updist;
+	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
+	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 > 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();
+		return;
+	}
+
+	// first try just moving to the destination	
+	dest[0] = mv->m_vecAbsOrigin[0] + mv->m_vecVelocity[0]*gpGlobals->frametime;
+	dest[1] = mv->m_vecAbsOrigin[1] + mv->m_vecVelocity[1]*gpGlobals->frametime;	
+	dest[2] = mv->m_vecAbsOrigin[2];
+
+	// first try moving directly to the next spot
+	VectorCopy (dest, start);
+
+	TracePlayerBBox( mv->m_vecAbsOrigin, dest, MASK_PLAYERSOLID, 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)
+	{
+		VectorCopy( pm.endpos, mv->m_vecAbsOrigin );
+		return;
+	}
+
+	if (oldground == NULL &&   // Don't walk up stairs if not on ground.
+		player->GetWaterLevel()  == 0)
+		return;
+
+	if (player->m_flWaterJumpTime)         // If we are jumping out of water, don't do anything more.
+		return;
+
+	// Try sliding forward both on ground and up 16 pixels
+	//  take the move that goes farthest
+	VectorCopy (mv->m_vecAbsOrigin, original);       // Save out original pos &
+	VectorCopy (mv->m_vecVelocity, originalvel);  //  velocity.
+
+	// Slide move
+	clip = TryPlayerMove();
+
+	// Copy the results out
+	VectorCopy (mv->m_vecAbsOrigin  , down);
+	VectorCopy (mv->m_vecVelocity, downvel);
+
+	// Reset original values.
+	VectorCopy (original, mv->m_vecAbsOrigin);
+	VectorCopy (originalvel, mv->m_vecVelocity);
+
+	// Start out up one stair height
+	VectorCopy (mv->m_vecAbsOrigin, dest);
+	dest[2] += player->m_Local.m_flStepSize;
+
+	TracePlayerBBox( mv->m_vecAbsOrigin, dest, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+
+	// If we started okay and made it part of the way at least,
+	//  copy the results to the movement start position and then
+	//  run another move try.
+	if (!pm.startsolid && !pm.allsolid)
+	{
+		VectorCopy (pm.endpos, mv->m_vecAbsOrigin);
+	}
+
+	// slide move the rest of the way.
+	clip = TryPlayerMove();
+
+	// Now try going back down from the end point
+	//  press down the stepheight
+	VectorCopy (mv->m_vecAbsOrigin, dest);
+	dest[2] -= player->m_Local.m_flStepSize;
+
+	TracePlayerBBox( mv->m_vecAbsOrigin, dest, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+
+	// If we are not on the ground any more then
+	//  use the original movement attempt
+	if ( pm.plane.normal[2] < IMPACT_NORMAL_FLOOR )
+		goto usedown;
+	// If the trace ended up in empty space, copy the end
+	//  over to the origin.
+	if (!pm.startsolid && !pm.allsolid)
+	{
+		VectorCopy (pm.endpos, mv->m_vecAbsOrigin);
+	}
+	// Copy this origion to up.
+	VectorCopy (mv->m_vecAbsOrigin, up);
+
+	// decide which one went farther
+	downdist = (down[0] - original[0])*(down[0] - original[0])
+		     + (down[1] - original[1])*(down[1] - original[1]);
+	updist   = (up[0]   - original[0])*(up[0]   - original[0])
+		     + (up[1]   - original[1])*(up[1]   - original[1]);
+
+	if (downdist > updist)
+	{
+usedown:
+	;
+		VectorCopy (down   , mv->m_vecAbsOrigin);
+		VectorCopy (downvel, mv->m_vecVelocity);
+	}
+	else // copy z value from slide move
+		mv->m_vecVelocity[2] = downvel[2];
+
+	float stepDist = mv->m_vecAbsOrigin.z - original.z;
+	if ( stepDist > 0 )
+	{
+		mv->m_outStepHeight += stepDist;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::AccelerateWithoutMomentum( Vector &wishdir, float wishspeed, float accel )
+{
+	// No acceleration if the player is water-jumping or dead.
+	if ( player->pl.deadflag || player->m_flWaterJumpTime )
+		return;
+
+	// See if we are changing direction a bit
+//	float flCurrentSpeed = mv->m_vecVelocity.Dot( wishdir );
+	float flCurrentSpeed = mv->m_vecVelocity.Length();
+
+	// Reduce wishspeed by the amount of veer.
+	float flAddSpeed = wishspeed - flCurrentSpeed;
+
+	// If not going to add any speed, done.
+	if ( flAddSpeed <= 0.0f )
+		return;
+
+	// Determine amount of accleration.
+	float flAccelSpeed = accel * gpGlobals->frametime * wishspeed * m_surfaceFriction;
+
+	// Cap at addspeed
+	if ( flAccelSpeed > flAddSpeed )
+	{
+		flAccelSpeed = flAddSpeed;
+	}
+
+	// Adjust velocity.
+	for ( int iAxis = 0; iAxis < 3; iAxis++ )
+	{
+		mv->m_vecVelocity[iAxis] += flAccelSpeed * wishdir[iAxis];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::Accelerate( Vector &wishdir, float wishspeed, float accel )
+{
+	// No acceleration if the player is water-jumping or dead.
+	if ( player->pl.deadflag || player->m_flWaterJumpTime )
+		return;
+
+	// See if we are changing direction a bit
+//	float flCurrentSpeed = mv->m_vecVelocity.Dot( wishdir );
+	float flCurrentSpeed = mv->m_vecVelocity.Length();
+
+	// Reduce wishspeed by the amount of veer.
+	float flAddSpeed = wishspeed - flCurrentSpeed;
+
+	// If not going to add any speed, done.
+	if ( flAddSpeed <= 0.0f )
+		return;
+
+	// Determine amount of accleration.
+	float flAccelSpeed = accel * gpGlobals->frametime * wishspeed * m_surfaceFriction;
+
+	// Cap at addspeed
+	if ( flAccelSpeed > flAddSpeed )
+	{
+		flAccelSpeed = flAddSpeed;
+	}
+
+	// Gravity.
+	float flGravityAdj = CalcGravityAdjustment( wishdir );
+
+	// Adjust velocity.
+	for ( int iAxis = 0; iAxis < 3; iAxis++ )
+	{
+		mv->m_vecVelocity[iAxis] += ( flAccelSpeed * wishdir[iAxis] * flGravityAdj );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+float CTFGameMovement::CalcGravityAdjustment( const Vector &wishdir )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return 1.0f;
+
+	if ( player->GetMoveType() == MOVETYPE_NOCLIP )
+		return 1.0f;
+
+	Vector vecPositionDelta = pTFMove->m_vecPosDelta;
+	VectorNormalize( vecPositionDelta );
+
+	// Hard-code my table
+	float flModifier = 0.0f;
+	if ( vecPositionDelta.z < -0.342f )
+	{
+		flModifier = 1.25f;
+	}
+	else if ( vecPositionDelta.z < 0.0f )
+	{
+		flModifier = 1.15f;
+	}
+	else if ( vecPositionDelta.z < 0.342f )	/* >20 */
+	{
+		flModifier = 1.0f;
+	}
+	else if ( vecPositionDelta.z < 0.5f ) /* 20-30 */
+	{
+		float flDelta = 0.5f - vecPositionDelta.z;
+		flDelta /= 0.158f;
+		flDelta = 1.0f - flDelta;
+		flModifier = 1.0f - ( 0.25 * flDelta );
+	}
+	else if ( vecPositionDelta.z < 0.707f ) /* 30-45 */
+	{
+		float flDelta = 0.707f - vecPositionDelta.z;
+		flDelta /= 0.207f;
+		flDelta = 1.0f - flDelta;
+		flModifier = 0.75 - ( 0.25f * flDelta );
+	}
+	else if ( vecPositionDelta.z < 0.766f ) /* 45-50 */
+	{
+		float flDelta = 0.766f - vecPositionDelta.z;
+		flDelta /= 0.059f;
+		flDelta = 1.0f - flDelta;
+		flModifier = 0.5f - ( 0.40f * flDelta );
+	}
+	else
+	{
+		flModifier = 0.35f;
+	}
+
+	AddToMomentumList( flModifier );
+	flModifier = GetMomentum();
+
+#if 0
+	// Debug!
+	if ( player->IsServer() )
+	{
+		Msg( "Server:Gravity Adj = %lf\n", flModifier );
+	}
+	else
+	{
+		Msg( "Client:Gravity Adj = %lf\n", flModifier );
+	}
+#endif
+
+	return flModifier;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CalcWishVelocityAndPosition( Vector &vWishPos, Vector &vWishDir,
+												   float &flWishSpeed )
+{
+	//
+	// Determine the movement angles.
+	//
+	Vector vForward, vRight, vUp;
+	AngleVectors( mv->m_vecViewAngles, &vForward, &vRight, &vUp );
+
+	//
+	// Zero out the z component of the movement vectors and renormalize.
+	//
+	vForward.z = 0.0f;
+	VectorNormalize( vForward );
+	vRight.z = 0.0f;
+	VectorNormalize( vRight );
+
+	//
+	// Determine the xy parts of the velocity.
+	//
+	Vector vWishVel( 0.0f, 0.0f, 0.0f );
+	for ( int axis = 0; axis < 2; axis++ )
+	{
+		vWishVel[axis] = ( vForward[axis] * mv->m_flForwardMove ) +
+			             ( vRight[axis] * mv->m_flSideMove );
+	}
+	vWishVel.z = 0.0f;
+
+	//
+	// Componentize the velocity into direction and speed.
+	//
+	VectorCopy( vWishVel, vWishDir );
+	flWishSpeed = VectorNormalize( vWishDir );
+	if ( flWishSpeed > mv->m_flMaxSpeed )
+	{
+		VectorScale( vWishVel, ( mv->m_flMaxSpeed / flWishSpeed ), vWishVel );
+		flWishSpeed = mv->m_flMaxSpeed;
+	}
+
+	//
+	// Accelerate (in the plane).
+	//
+	mv->m_vecVelocity.z = 0.0f;
+	Accelerate( vWishDir, flWishSpeed, sv_accelerate.GetFloat() );
+	mv->m_vecVelocity.z = 0.0f;
+
+	// Add in any base velocity (from conveyers, etc.) to the current velocity.
+	VectorAdd( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+	//
+	// Stop the player (zero out velocity) if the player's speed is below a
+	// given threshold.
+	//
+	float flSpeed = VectorLength( mv->m_vecVelocity );
+	if ( flSpeed < SPEED_STOP_THRESHOLD )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	//
+	// Calculate the wish position.
+	//
+	vWishPos.x = mv->m_vecAbsOrigin.x + ( mv->m_vecVelocity.x * gpGlobals->frametime );
+	vWishPos.y = mv->m_vecAbsOrigin.y + ( mv->m_vecVelocity.y * gpGlobals->frametime );
+	vWishPos.z = mv->m_vecAbsOrigin.z;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+inline void CTFGameMovement::TracePlayerBBoxWithStep( const Vector &vStart, const Vector &vEnd, 
+							unsigned int fMask, int collisionGroup, trace_t &trace )
+{
+	VPROF( "CTFGameMovement::TracePlayerBBoxWithStep" );
+
+	Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
+	vHullMin.z += player->m_Local.m_flStepSize;
+	Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );
+
+	Ray_t ray;
+	ray.Init( vStart, vEnd, vHullMin, vHullMax );
+	UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &trace );
+}
+
+#if 0
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+inline void CGameMovement::TracePlayerBBox( const Vector &start, const Vector &end, 
+							unsigned int fMask, int collisionGroup, trace_t& pm )
+{
+	VPROF( "CTFGameMovement::TracePlayerBBox" );
+
+	Ray_t ray;
+	ray.Init( start, end, GetPlayerMins( player->m_Local.m_bDucked ), GetPlayerMaxs( player->m_Local.m_bDucked ) );
+	UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &pm );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+inline int CTFGameMovement::BlockerType( const Vector &vImpactNormal )
+{
+	// If the impact plane has a high z component in the normal, then
+	// it is probably a floor.
+	if ( vImpactNormal.z > IMPACT_NORMAL_FLOOR )
+		return 1;
+
+	// If the impact plane has a zero z component in the normal, then it is
+	// probably a step or wall.
+	if ( vImpactNormal.z == IMPACT_NORMAL_WALL )
+		return 2;
+
+	// None
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::RedirectGroundVelocity( const trace_t &trace )
+{
+	// Check for max planes.
+	if ( m_nImpactPlaneCount >= MAX_IMPACT_PLANES )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	// Add the impact plane normal to the list.
+	VectorCopy( trace.plane.normal, m_aImpactPlaneNormals[m_nImpactPlaneCount] );
+	m_nImpactPlaneCount++;
+	
+	int iPlane, iPlane2;
+	for ( iPlane = 0; iPlane < m_nImpactPlaneCount; iPlane++ )
+	{
+		// Reduce and redirect the player's velocity.
+		Vector vecVelocity( mv->m_vecVelocity.x, mv->m_vecVelocity.y, mv->m_vecVelocity.z );
+
+		// Don't let negatively sloped surfaces drive you into the ground.
+		if ( m_aImpactPlaneNormals[iPlane].z < 0.0f )
+		{
+			m_aImpactPlaneNormals[iPlane].z = 0.0f;
+			VectorNormalize( m_aImpactPlaneNormals[iPlane] );
+		}
+
+		ClipVelocity( vecVelocity, m_aImpactPlaneNormals[iPlane], mv->m_vecVelocity, 1.0f );
+
+		// Check to see if we need to continue clipping?
+		for( iPlane2 = 0; iPlane2 < m_nImpactPlaneCount; iPlane2++ )
+		{
+			if ( iPlane != iPlane2 )
+			{
+				if ( mv->m_vecVelocity.Dot( m_aImpactPlaneNormals[iPlane2] ) < 0.0f )
+					break;
+			}
+		}
+		if ( iPlane2 == m_nImpactPlaneCount )
+			break;
+	}
+
+	if ( iPlane == m_nImpactPlaneCount )
+	{
+		// Go along the crease here!
+		if ( m_nImpactPlaneCount != 2 )
+		{
+			mv->m_vecVelocity.Init();
+			return false;
+		}
+		else
+		{
+			Vector vecCross;
+			CrossProduct( m_aImpactPlaneNormals[0], m_aImpactPlaneNormals[1], vecCross );
+			float flScalar = vecCross.Dot( mv->m_vecVelocity );
+			VectorScale( vecCross, flScalar, mv->m_vecVelocity );
+		}
+	}
+
+	// If the original velocity is against the current velocity, stop dead to 
+	// avoid tiny occilations in sloping corners
+	if ( mv->m_vecVelocity.Dot( m_vecOriginalVelocity ) <= 0.0f )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::RedirectAirVelocity( const trace_t &trace )
+{
+	// Check for max planes.
+	if ( m_nImpactPlaneCount >= MAX_IMPACT_PLANES )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	// Add the impact plane normal to the list.
+	VectorCopy( trace.plane.normal, m_aImpactPlaneNormals[m_nImpactPlaneCount] );
+	m_nImpactPlaneCount++;
+
+	for ( int iPlane = 0; iPlane < m_nImpactPlaneCount; iPlane++ )
+	{
+		// Reduce and redirect the player's velocity.
+		Vector vecVelocity( mv->m_vecVelocity.x, mv->m_vecVelocity.y, mv->m_vecVelocity.z );
+
+		// Don't let negatively sloped surfaces drive you into the ground.
+		if ( m_aImpactPlaneNormals[iPlane].z < 0.0f )
+		{
+			m_aImpactPlaneNormals[iPlane].z = 0.0f;
+			VectorNormalize( m_aImpactPlaneNormals[iPlane] );
+		}
+
+		if ( m_aImpactPlaneNormals[iPlane].z > IMPACT_NORMAL_FLOOR )
+		{
+			ClipVelocity( vecVelocity, m_aImpactPlaneNormals[iPlane], mv->m_vecVelocity, 1.0f );
+		}
+		else
+		{
+			ClipVelocity( vecVelocity, m_aImpactPlaneNormals[iPlane], mv->m_vecVelocity, 1.0f + sv_bounce.GetFloat() * ( 1.0f - m_surfaceFriction ) );
+		}
+	}	
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::CollisionResponseNone( const trace_t &trace )
+{
+	// Move the player to the trace's ending position.
+	VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+
+	// Add the position to the stack.
+	if ( m_nMovementStackSize < MOVEMENTSTACK_MAXSIZE )
+	{
+		VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[m_nMovementStackSize].m_vecPosition );
+		VectorCopy( mv->m_vecVelocity, m_aMovementStack[m_nMovementStackSize].m_vecVelocity );
+		VectorCopy( m_aMovementStack[m_nMovementStackSize].m_vecImpactNormal, 
+			m_aMovementStack[m_nMovementStackSize].m_vecImpactNormal );
+		m_nMovementStackSize++;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::CollisionResponseStuck( void )
+{
+	mv->m_vecVelocity.Init();
+	//DevMsg( 1, "CollisionResponseStuck: %s is stuck (%s).\n", player->GetClassname(), player->IsServer() ? "sv" : "cl" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CollisionResponseGeneric( const trace_t &trace, int &nBlocked )
+{
+	// Check for any movement.
+	if ( trace.fraction > 0.0f )
+	{
+		// Move the partial move and reset the impact plane count.
+		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+		m_nImpactPlaneCount = 0;
+
+		// Add the data to the movement stack. -- the velocity is wrong here!!!
+		if ( m_nMovementStackSize < MOVEMENTSTACK_MAXSIZE )
+		{
+			VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[m_nMovementStackSize].m_vecPosition );
+			VectorCopy( mv->m_vecVelocity, m_aMovementStack[m_nMovementStackSize].m_vecVelocity );
+			VectorCopy( trace.plane.normal, m_aMovementStack[m_nMovementStackSize].m_vecImpactNormal );
+			m_nMovementStackSize++;
+		}
+	}
+
+	// Sanity check - Impact plane count.
+	Assert( m_nImpactPlaneCount < MAX_IMPACT_PLANES );
+
+	// Add the entity to the touched list (list itself maintains uniqueness).
+	MoveHelper()->AddToTouched( trace, mv->m_vecVelocity );
+
+	// Check for special "blockers" (walls, steps, floor).
+    nBlocked |= BlockerType( trace.plane.normal );
+	
+	// Re-direct or bounce the player's velocity vector.
+	if ( player->GetGroundEntity() != NULL )
+	{
+		return RedirectGroundVelocity( trace );
+	}
+	else
+	{
+		return RedirectAirVelocity( trace );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: See comment _WalkMove
+//-----------------------------------------------------------------------------
+int CTFGameMovement::TryPlayerMove( Vector *pFirstDest=NULL, trace_t *pFirstTrace=NULL )
+{
+	VPROF( "CTFGameMovement::TryPlayerMove" );
+
+	int			bumpcount, numbumps;
+	Vector		dir;
+	float		d;
+	int			numplanes;
+	Vector		planes[5/*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->m_vecAbsOrigin, 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
+				TracePlayerBBox( mv->m_vecAbsOrigin, end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+		}
+		else
+		{
+			TracePlayerBBox( mv->m_vecAbsOrigin, 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 )
+		{	
+			// actually covered some distance
+			VectorCopy (pm.endpos, mv->m_vecAbsOrigin);
+			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
+		}
+
+		// Indicate a collision occurred...
+		OnTryPlayerMoveCollision( pm );
+
+		// 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] > IMPACT_NORMAL_FLOOR)
+		{
+			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 >= 5/*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
+		//
+		if ( player->GetMoveType() == MOVETYPE_WALK &&
+			((player->GetGroundEntity() == NULL) /*|| (mv->m_fFriction != 1)*/ ) )	// relfect player velocity
+		{
+			for ( i = 0; i < numplanes; i++ )
+			{
+				if ( planes[i][2] > IMPACT_NORMAL_FLOOR  )
+				{
+					// 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 - 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);
+				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);
+	}
+
+	return blocked;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int CTFGameMovement::TryPlayerMove2( void )
+{
+	VPROF( "CTFGameMovement::TryPlayerMove2" );
+
+	int	nBlocked = MOVEMENT_BLOCKED_NONE;
+	trace_t	trace;
+	float flTimeLeft = gpGlobals->frametime;
+	m_nImpactPlaneCount = 0;
+
+	// Save off the original velocity -- coming in.
+	VectorCopy( mv->m_vecVelocity, m_vecOriginalVelocity );
+
+	float flTotalFraction = 0.0f;
+	for ( int iBump = 0; iBump < BUMP_MAX_COUNT; iBump++ )
+	{
+		// Check to see if we have any velocity left. EXPENSIVE!!!!
+		if ( mv->m_vecVelocity.Length() == 0.0f )
+			break;
+
+		//
+		// Calculate the wish position. 
+		//
+		Vector vecWishPos;
+		VectorMA( mv->m_vecAbsOrigin, flTimeLeft, mv->m_vecVelocity, vecWishPos );
+
+		//
+		// Attempt the move.
+		//
+		// NOTE:  This check can hit players and objects
+		TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecWishPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER, trace );
+
+		//  but if it didn't no need to do another trace for movement only
+		if ( trace.fraction == 1.0f )
+		{
+			flTotalFraction += trace.fraction;
+			CollisionResponseNone( trace );
+			break;
+		}
+		else
+		{
+			// Add the entity to the touched list (list itself maintains uniqueness).
+			MoveHelper()->AddToTouched( trace, mv->m_vecVelocity );
+			// Do a non-solid to player trace now, instead, and override what's in trace
+			TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecWishPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+		}
+
+		flTotalFraction += trace.fraction;
+
+		// Handle stuck in solid.
+		if ( trace.allsolid )
+		{
+			CollisionResponseStuck();
+			return MOVEMENT_BLOCKED_ALL;
+		}
+
+		// Handle full movement.
+		if ( trace.fraction == 1.0f )
+		{
+			CollisionResponseNone( trace );
+			break;
+		}
+
+		// Handle partial movement.
+		if ( !CollisionResponseGeneric( trace, nBlocked ) )
+			break;
+
+		// Reduce the time left.
+		flTimeLeft -= ( flTimeLeft * trace.fraction );
+
+		/*
+		//
+		// Attempt the move.
+		//
+		TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecWishPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+		flTotalFraction += trace.fraction;
+
+		// Handle stuck in solid.
+		if ( trace.allsolid )
+		{
+			CollisionResponseStuck();
+			return MOVEMENT_BLOCKED_ALL;
+		}
+
+		// Handle full movement.
+		if ( trace.fraction == 1.0f )
+		{
+			CollisionResponseNone( trace );
+			break;
+		}
+
+		// Handle partial movement.
+		if ( !CollisionResponseGeneric( trace, nBlocked ) )
+			break;
+
+		// Reduce the time left.
+		flTimeLeft -= ( flTimeLeft * trace.fraction );
+		*/
+	}
+	
+	// Finally, check for any movement.
+	if ( flTotalFraction == 0.0f )
+	{
+		CollisionResponseStuck();
+	}
+
+	return nBlocked;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::TryStanding( void )
+{
+	VPROF( "CTFGameMovement::TryStanding" );
+
+	// Step down.
+	Vector vecStandPos( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z - player->m_Local.m_flStepSize );
+
+	trace_t trace;
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+	if ( trace.fraction == 1.0f )
+		return;
+
+	// Attempt to stand up.
+	vecStandPos.z = mv->m_vecAbsOrigin.z + ( ( 1.0f - trace.fraction ) * player->m_Local.m_flStepSize );
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+	// A fraction of 1.0 means we stood up fine - done.
+	if ( trace.fraction == 1.0f )
+	{
+		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+		return;
+	}
+
+	// Use the movement stack to pop back and resolve the stand.
+	if ( m_nMovementStackSize > 0 )
+	{
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecPosition, mv->m_vecAbsOrigin );
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecVelocity, mv->m_vecVelocity );
+		m_nMovementStackSize--; 
+		TryStanding();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::ResolveStanding( void )
+{
+	VPROF( "CTFGameMovement::ResolveStanding" );
+
+	//
+	// Attempt to move down twice your step height.  Anything between 0.5 and 1.0
+	// is a valid "stand" value.
+	//
+	Vector vecStandPos( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z - ( player->m_Local.m_flStepSize * 2.0f ) );
+
+	trace_t trace;
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+	// Anything between 0.5 and 1.0 is a valid stand value
+	if ( fabs( trace.fraction - 0.5 ) < 0.0004f )
+	{
+		return;
+	}
+
+//	if ( trace.fraction == 0.5 )
+//	{
+//		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+//		return;
+//	}
+
+	if ( trace.fraction > 0.5f )
+	{
+		trace.fraction -= 0.5f;
+		Vector vecNewOrigin;
+		vecNewOrigin = mv->m_vecAbsOrigin + trace.fraction * ( vecStandPos - mv->m_vecAbsOrigin );
+		mv->m_vecAbsOrigin = vecNewOrigin;
+		return;
+	}
+
+	// Less than 0.5 mean we need to attempt to push up the difference.
+	vecStandPos.z = ( mv->m_vecAbsOrigin.z + ( ( 0.5f - trace.fraction ) * ( player->m_Local.m_flStepSize * 2.0f ) ) );
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+	
+	// A fraction of 1.0 means we stood up fine - done.
+	if ( trace.fraction == 1.0f )
+	{
+		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+		return;
+	}
+
+	// Use the movement stack to pop back and resolve the stand.
+	if ( m_nMovementStackSize > 0 )
+	{
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecPosition, mv->m_vecAbsOrigin );
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecVelocity, mv->m_vecVelocity );
+		m_nMovementStackSize--; 
+		ResolveStanding();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::WalkMove2( void )
+{
+	VPROF( "CTFGameMovement::WalkMove2" );
+
+	// Initialize the movement stack.
+	VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[0].m_vecPosition );
+	VectorCopy( m_vecGroundNormal, m_aMovementStack[0].m_vecImpactNormal );
+	m_nMovementStackSize = 1;
+
+	// Calculate the wish velocity and position.  The function returns false if 
+	// the velocity is zero, it returns true otherwise.
+	Vector vWishPos, vWishDir;
+	float flWishSpeed;
+	if ( !CalcWishVelocityAndPosition( vWishPos, vWishDir, flWishSpeed ) )
+		return;
+
+	// For physics player shadow.
+	mv->m_outWishVel += vWishDir * flWishSpeed;
+
+	// Lift up the players feet (bring the minimum z componenet up by the step
+	// size) and sweep.
+	TryPlayerMove2();
+
+	// Try to stand up at movement's end.
+	ResolveStanding();
+
+	// For physics player shadow.
+	float flStepHeight = mv->m_vecAbsOrigin.z - m_aMovementStack[0].m_vecPosition.z;
+	if ( flStepHeight > 0.0f )
+	{
+		mv->m_outStepHeight += flStepHeight;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SetMomentumList( float flValue )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return;
+
+	// Fill in the momentum list.
+	pTFMove->m_iMomentumHead = 0;
+	for ( int iMomentum = 0; iMomentum < CTFMoveData::MOMENTUM_MAXSIZE; iMomentum++ )
+	{
+		pTFMove->m_aMomentum[iMomentum] = flValue;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::AddToMomentumList( float flValue )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return;
+
+	// Insert the new gravity value into the list.
+	pTFMove->m_aMomentum[pTFMove->m_iMomentumHead] = flValue;
+	pTFMove->m_iMomentumHead = ( pTFMove->m_iMomentumHead + 1 ) % CTFMoveData::MOMENTUM_MAXSIZE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CTFGameMovement::GetMomentum( void )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return 1.0f;
+
+	float flTotal = 0.0f;
+	for ( int iMomentum = 0; iMomentum < CTFMoveData::MOMENTUM_MAXSIZE; iMomentum++ )
+	{
+		flTotal += pTFMove->m_aMomentum[iMomentum];
+	}
+	
+	flTotal /= CTFMoveData::MOMENTUM_MAXSIZE;
+
+	return flTotal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::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
+	}
+
+	if ( mv->m_nOldButtons & IN_JUMP )
+		return false;		// don't pogo stick
+
+	// In the air now.
+    SetGroundEntity( NULL );
+	
+	PlayStepSound( m_pSurfaceData, 1.0, true );
+	
+	MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
+
+	float flGroundFactor = 1.0f;
+	if (m_pSurfaceData)
+	{
+		flGroundFactor = m_pSurfaceData->game.jumpFactor; 
+	}
+
+	float flMul;
+	flMul = sqrt(2 * GetCurrentGravity() * 45.0);
+
+	// 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
+	}
+
+	FinishGravity();
+
+	mv->m_outJumpVel.z += mv->m_vecVelocity[2] - startz;
+	mv->m_outStepHeight += 0.1f;
+
+	// Flag that we jumped.
+	mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+	return true;
+}