path: root/game/shared/tf2/tf_gamemovement.cpp

//========= 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;
}