path: root/game/shared/dod/dod_playeranimstate.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "cbase.h"
#include "dod_playeranimstate.h"
#include "base_playeranimstate.h"
#include "tier0/vprof.h"
#include "animation.h"
#include "studio.h"
#include "apparent_velocity_helper.h"
#include "utldict.h"
#include "weapon_dodbase.h"
#include "dod_shareddefs.h"

#ifdef CLIENT_DLL
	#include "c_dod_player.h"
	#include "engine/ivdebugoverlay.h"
	#include "filesystem.h"

	ConVar anim_showmainactivity( "anim_showmainactivity", "0", FCVAR_CHEAT, "Show the idle, walk, run, and/or sprint activities." );
#else
	#include "dod_player.h"
#endif

ConVar anim_showstate( "anim_showstate", "-1", FCVAR_CHEAT | FCVAR_REPLICATED, "Show the (client) animation state for the specified entity (-1 for none)." );
ConVar anim_showstatelog( "anim_showstatelog", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "1 to output anim_showstate to Msg(). 2 to store in AnimState.log. 3 for both." );
ConVar dod_bodyheightoffset( "dod_bodyheightoffset", "4", FCVAR_CHEAT | FCVAR_REPLICATED, "Deploy height offset." );

#define ANIMPART_STAND "stand"
#define ANIMPART_PRONE "prone"
#define ANIMPART_CROUCH "crouch"
#define ANIMPART_SPRINT "sprint"
#define ANIMPART_SANDBAG "sandbag"
#define ANIMPART_BIPOD "bipod"

// When moving this fast, he plays run anim.
#define ARBITRARY_RUN_SPEED		300.0f
#define DOD_BODYYAW_RATE		720.0f

#define DOD_WALK_SPEED		60.0f
#define DOD_RUN_SPEED		120.0f
#define DOD_SPRINT_SPEED	260.0f

class CDODPlayerAnimState : public CBasePlayerAnimState, public IDODPlayerAnimState
{
public:

	DECLARE_CLASS( CDODPlayerAnimState, CBasePlayerAnimState );
	friend IDODPlayerAnimState* CreatePlayerAnimState( CDODPlayer *pPlayer );

	CDODPlayerAnimState();

	virtual void ShowDebugInfo( void );

	// This is called by both the client and the server in the same way to trigger events for
	// players firing, jumping, throwing grenades, etc.
	virtual void DoAnimationEvent( PlayerAnimEvent_t event, int nData );
	virtual void ClearAnimationState();
	virtual Activity CalcMainActivity();	
	virtual void Update( float eyeYaw, float eyePitch );

	virtual void DebugShowAnimState( int iStartLine );

	virtual int CalcAimLayerSequence( float *flCyle, float *flAimSequenceWeight, bool bForceIdle ) { return 0; }

	virtual float GetCurrentMaxGroundSpeed();
	virtual void ComputeSequences( CStudioHdr *pStudioHdr );
	virtual void ClearAnimationLayers();

	virtual void RestartMainSequence();
	virtual float CalcMovementPlaybackRate( bool *bIsMoving );

	Activity TranslateActivity( Activity actDesired );
	void CancelGestures( void );

protected:

	// Pose paramters.
	bool				SetupPoseParameters( CStudioHdr *pStudioHdr );
	virtual void		ComputePoseParam_MoveYaw( CStudioHdr *pStudioHdr );
	virtual void		ComputePoseParam_AimPitch( CStudioHdr *pStudioHdr );
	virtual void		ComputePoseParam_AimYaw( CStudioHdr *pStudioHdr );
	void				ComputePoseParam_BodyHeight( CStudioHdr *pStudioHdr );
	virtual void		EstimateYaw( void );
	void				ConvergeYawAngles( float flGoalYaw, float flYawRate, float flDeltaTime, float &flCurrentYaw );

	void ComputeFireSequence();
	void ComputeDeployedSequence();

	void ComputeGestureSequence( CStudioHdr *pStudioHdr );

	void RestartGesture( int iGestureType, Activity act, bool bAutoKill = true );

	void UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd, float flWeight = 1.0 );

	void				DebugShowAnimStateForPlayer( bool bIsServer );
	void				DebugShowEyeYaw( void );

// Client specific.
#ifdef CLIENT_DLL

	// Debug.
	void				DebugShowActivity( Activity activity );

#endif

private:

	void InitDOD( CDODPlayer *pPlayer );
	
	bool HandleJumping( Activity *idealActivity );
	bool HandleProne( Activity *idealActivity );
	bool HandleProneDown( CDODPlayer *pPlayer, Activity *idealActivity );
	bool HandleProneUp( CDODPlayer *pPlayer, Activity *idealActivity );
	bool HandleDucked( Activity *idealActivity );

	bool IsGettingDown( CDODPlayer *pPlayer );
	bool IsGettingUp( CDODPlayer *pPlayer );

	CDODPlayer* GetOuterDOD() const;

	bool IsPlayingGesture( int type )
	{
		return ( m_bPlayingGesture && m_iGestureType == type );
	}

private:
	// Current state variables.
	bool m_bJumping;			// Set on a jump event.
	float m_flJumpStartTime;	
	bool m_bFirstJumpFrame;

	// These control the prone state _achine.
	bool m_bGettingDown;
	bool m_bGettingUp;
	bool m_bWasGoingProne;
	bool m_bWasGettingUp;

	// The single Gesture layer
	bool m_bPlayingGesture;
	bool m_bAutokillGesture;
	int m_iGestureSequence;
	float m_flGestureCycle;

	int m_iGestureType;

	enum
	{
		GESTURE_NONE = -1,
		GESTURE_ATTACK1 = 0,
		GESTURE_ATTACK2,
		GESTURE_RELOAD,
		GESTURE_HAND_SIGNAL,
		GESTURE_FIDGET,
		GESTURE_PLANT,
		GESTURE_DEFUSE,
	};

	// Pose parameters.
	bool		m_bPoseParameterInit;
	float		m_flEstimateYaw;
	float		m_flEstimateVelocity;
	float		m_flLastAimPitch;
	float		m_flLastAimYaw;
	float		m_flLastBodyHeight;
	float		m_flLastAimTurnTime;
	Vector2D	m_vecLastMoveYaw;
	int			m_iMoveX;
	int			m_iMoveY;
	int			m_iAimYaw;
	int			m_iAimPitch;
	int			m_iBodyHeight;

	float m_flFireIdleTime;				// Time that we drop our gun

	bool m_bLastDeployState;		// true = last was deployed, false = last was not deployed

	DODWeaponID m_iLastWeaponID;			// remember the weapon we were last using

	// Our DOD player pointer.
	CDODPlayer *m_pOuterDOD;
};


IDODPlayerAnimState* CreatePlayerAnimState( CDODPlayer *pPlayer )
{
	CDODPlayerAnimState *pState = new CDODPlayerAnimState;
	pState->InitDOD( pPlayer );
	return pState;
}


// -------------------------------------------------------------------------------- //
// CDODPlayerAnimState implementation.
// -------------------------------------------------------------------------------- //
											
CDODPlayerAnimState::CDODPlayerAnimState()
{
	m_bGettingDown = false;
	m_bGettingUp = false;
	m_bWasGoingProne = false;
	m_bWasGettingUp = false;

	m_pOuterDOD = NULL;

	m_bPoseParameterInit = false;
	m_flEstimateYaw = 0.0f;
	m_flLastAimPitch = 0.0f;
	m_flLastAimYaw = 0.0f;
	m_flLastBodyHeight = 0.0f;
	m_flLastAimTurnTime = 0.0f;
	m_vecLastMoveYaw.Init();
	m_iMoveX = -1;
	m_iMoveY = -1;
	m_iAimYaw = -1;
	m_iAimPitch = -1;
	m_iBodyHeight = -1;
}

void CDODPlayerAnimState::InitDOD( CDODPlayer *pPlayer )
{
	m_pOuterDOD = pPlayer;
	
	CModAnimConfig config;
	config.m_flMaxBodyYawDegrees = 45;
	config.m_LegAnimType = LEGANIM_GOLDSRC;
	config.m_bUseAimSequences = false;
	
	BaseClass::Init( pPlayer, config );
}


void CDODPlayerAnimState::ClearAnimationState()
{
	m_bJumping = false;
	m_flFireIdleTime = 0;
	m_bLastDeployState = false;
	m_iLastWeaponID = WEAPON_NONE;
	CancelGestures();
	BaseClass::ClearAnimationState();
}

void CDODPlayerAnimState::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
	if ( event == PLAYERANIMEVENT_FIRE_GUN )
	{
		RestartGesture( GESTURE_ATTACK1, ACT_RANGE_ATTACK1, false );

		if( GetOuterDOD()->m_Shared.IsBazookaDeployed() )
		{
			m_flFireIdleTime = gpGlobals->curtime + 0.1;	// don't hold this pose after firing
		}
		else
		{
			// hold last frame of fire pose for 2 seconds ( if we are moving )
			m_flFireIdleTime = gpGlobals->curtime + 2;	
		}
	}
	if ( event == PLAYERANIMEVENT_SECONDARY_ATTACK )
	{
		CancelGestures();
		RestartGesture( GESTURE_ATTACK2, ACT_RANGE_ATTACK2 );
	}
	else if ( event == PLAYERANIMEVENT_RELOAD )
	{
		CancelGestures();
		RestartGesture( GESTURE_RELOAD, ACT_RELOAD );
	}
	else if ( event == PLAYERANIMEVENT_THROW_GRENADE )
	{
		CancelGestures();
		RestartGesture( GESTURE_ATTACK1, ACT_RANGE_ATTACK1 );
	}
	else if ( event == PLAYERANIMEVENT_ROLL_GRENADE )
	{
		CancelGestures();
		RestartGesture( GESTURE_ATTACK2, ACT_RANGE_ATTACK2 );
	}
	else if ( event == PLAYERANIMEVENT_JUMP )
	{
		// Play the jump animation.
		m_bJumping = true;
		m_bFirstJumpFrame = true;
		RestartMainSequence();
		m_flJumpStartTime = gpGlobals->curtime;
	}
	else if ( event == PLAYERANIMEVENT_HANDSIGNAL )
	{
		CDODPlayer *pPlayer = GetOuterDOD();
		if ( pPlayer && !( pPlayer->m_Shared.IsBazookaDeployed() || pPlayer->m_Shared.IsProne() || pPlayer->m_Shared.IsProneDeployed() || pPlayer->m_Shared.IsSniperZoomed() || pPlayer->m_Shared.IsSandbagDeployed() ) )
		{
			CancelGestures();
			RestartGesture( GESTURE_HAND_SIGNAL, ACT_DOD_HS_IDLE );
		}
	}
	else if ( event == PLAYERANIMEVENT_PLANT_TNT )
	{
		CancelGestures();
		RestartGesture( GESTURE_PLANT, ACT_DOD_PLANT_TNT );
	}
	else if ( event == PLAYERANIMEVENT_DEFUSE_TNT )
	{
		CancelGestures();
		RestartGesture( GESTURE_DEFUSE, ACT_DOD_DEFUSE_TNT );
	}
}

void CDODPlayerAnimState::ShowDebugInfo( void )
{
	if ( anim_showstate.GetInt() == m_pOuter->entindex() )
	{
		DebugShowAnimStateForPlayer( m_pOuter->IsServer() );
	}
}


void CDODPlayerAnimState::RestartMainSequence()
{
	CancelGestures();

	BaseClass::RestartMainSequence();
}

bool CDODPlayerAnimState::HandleJumping( Activity *idealActivity )
{
	if ( m_bJumping )
	{
		if ( m_bFirstJumpFrame )
		{
			m_bFirstJumpFrame = false;
			RestartMainSequence();	// Reset the animation.
		}

		// Don't check if he's on the ground for a sec.. sometimes the client still has the
		// on-ground flag set right when the message comes in.
		if ( gpGlobals->curtime - m_flJumpStartTime > 0.2f )
		{
			if ( m_pOuter->GetFlags() & FL_ONGROUND )
			{
				m_bJumping = false;
				RestartMainSequence();
			}
		}
	}
	if ( m_bJumping )
	{
		*idealActivity = ACT_HOP;
		return true;
	}
	else
	{
		return false;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle the prone up animation.
//-----------------------------------------------------------------------------
bool CDODPlayerAnimState::HandleProneDown( CDODPlayer *pPlayer, Activity *idealActivity )
{
	if ( ( pPlayer->GetCycle() > 0.99f ) || ( pPlayer->m_Shared.IsProne() ) )
	{
		*idealActivity = ACT_PRONE_IDLE;
		if ( GetOuterXYSpeed() > MOVING_MINIMUM_SPEED )
		{
			*idealActivity = ACT_PRONE_FORWARD;
		}
		RestartMainSequence();

		m_bGettingDown = false;
	}
	else
	{
		*idealActivity = ACT_GET_DOWN_STAND;
		if ( pPlayer->GetFlags() & FL_DUCKING )
		{
			*idealActivity = ACT_GET_DOWN_CROUCH;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Handle the prone up animation.
//-----------------------------------------------------------------------------
bool CDODPlayerAnimState::HandleProneUp( CDODPlayer *pPlayer, Activity *idealActivity )
{
	if ( ( m_pOuter->GetCycle() > 0.99f ) || ( !pPlayer->m_Shared.IsGettingUpFromProne() ) )
	{
		m_bGettingUp = false;
		RestartMainSequence();

		return false;
	}

	*idealActivity = ACT_GET_UP_STAND;
	if ( pPlayer->GetFlags() & FL_DUCKING )
	{
		*idealActivity = ACT_GET_UP_CROUCH;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Handle the prone animations.
//-----------------------------------------------------------------------------
bool CDODPlayerAnimState::HandleProne( Activity *idealActivity )
{
	// Get the player.
	CDODPlayer *pPlayer = GetOuterDOD();
	if ( !pPlayer )
		return false;

	// Find the leading edge on going prone.
	bool bChange = pPlayer->m_Shared.IsGoingProne() && !m_bWasGoingProne;
	m_bWasGoingProne = pPlayer->m_Shared.IsGoingProne();
	if ( bChange )
	{
		m_bGettingDown = true;
		RestartMainSequence();
	}

	// Find the leading edge on getting up.
	bChange = pPlayer->m_Shared.IsGettingUpFromProne() && !m_bWasGettingUp;
	m_bWasGettingUp = pPlayer->m_Shared.IsGettingUpFromProne();
	if ( bChange )
	{
		m_bGettingUp = true;
		RestartMainSequence();
	}

	// Handle the transitions.
	if ( m_bGettingDown )
	{
		return HandleProneDown( pPlayer, idealActivity );
	}
	else if ( m_bGettingUp )
	{
		return HandleProneUp( pPlayer, idealActivity );
	}

	// Handle the prone state.
	if ( pPlayer->m_Shared.IsProne() )
	{
		*idealActivity = ACT_PRONE_IDLE;
		if ( GetOuterXYSpeed() > MOVING_MINIMUM_SPEED )
		{
			*idealActivity = ACT_PRONE_FORWARD;
		}

		return true;
	}

	return false;
}

bool CDODPlayerAnimState::HandleDucked( Activity *idealActivity )
{
	if ( m_pOuter->GetFlags() & FL_DUCKING )
	{
		if ( GetOuterXYSpeed() > MOVING_MINIMUM_SPEED )
			*idealActivity = ACT_RUN_CROUCH;
		else
			*idealActivity = ACT_CROUCHIDLE;
		
		return true;
	}
	else
	{
		return false;
	}
}

Activity CDODPlayerAnimState::CalcMainActivity()
{
	Activity idealActivity = ACT_IDLE;

	float flSpeed = GetOuterXYSpeed();

	if ( HandleJumping( &idealActivity ) || 
		HandleProne( &idealActivity ) ||
		HandleDucked( &idealActivity ) )
	{
		// intentionally blank
	}
	else
	{
		if ( flSpeed > MOVING_MINIMUM_SPEED )
		{
			if( flSpeed >= DOD_SPRINT_SPEED )
			{
				idealActivity = ACT_SPRINT;
				
				// If we sprint, cancel the fire idle time
				CancelGestures();
			}
			else if( flSpeed >= DOD_WALK_SPEED )
				idealActivity = ACT_RUN;
			else
				idealActivity = ACT_WALK;
		}
	}

	// Shouldn't be here but we need to ship - bazooka deployed reload/running check.
	if ( IsPlayingGesture( GESTURE_RELOAD ) )
	{
		if ( flSpeed >= DOD_RUN_SPEED && m_pOuterDOD->m_Shared.IsBazookaOnlyDeployed() )
		{
			CancelGestures();
		}
	}

	ShowDebugInfo();

	// Client specific.
#ifdef CLIENT_DLL

	if ( anim_showmainactivity.GetBool() )
	{
		DebugShowActivity( idealActivity );
	}

#endif

	return idealActivity;
}

void CDODPlayerAnimState::CancelGestures( void )
{
	m_bPlayingGesture = false;
	m_iGestureType = GESTURE_NONE;

#ifdef CLIENT_DLL	
	m_iGestureSequence = -1;
#else
	m_pOuter->RemoveAllGestures();
#endif 
}

void CDODPlayerAnimState::RestartGesture( int iGestureType, Activity act, bool bAutoKill /* = true */ )
{
	Activity idealActivity = TranslateActivity( act );
	m_bPlayingGesture = true;
	m_iGestureType = iGestureType;

#ifdef CLIENT_DLL
	m_iGestureSequence = m_pOuter->SelectWeightedSequence( idealActivity );

	if( m_iGestureSequence == -1 )
	{
		m_bPlayingGesture = false;
	}

	m_flGestureCycle = 0.0f;
	m_bAutokillGesture = bAutoKill;
#else
	m_pOuterDOD->RestartGesture( idealActivity, true, bAutoKill );
#endif
}

Activity CDODPlayerAnimState::TranslateActivity( Activity actDesired )
{
	Activity idealActivity = actDesired;

	if ( m_pOuterDOD->m_Shared.IsSandbagDeployed() )
	{
		switch( idealActivity )
		{
		case ACT_IDLE:
			idealActivity = ACT_DOD_DEPLOYED;
			break;
		case ACT_RANGE_ATTACK1:
			idealActivity = ACT_DOD_PRIMARYATTACK_DEPLOYED;
			break;
		case ACT_RELOAD:
			idealActivity = ACT_DOD_RELOAD_DEPLOYED;
			break;
		default:
			break;
		}
	} 
	else if ( m_pOuterDOD->m_Shared.IsProneDeployed() )
	{
		switch( idealActivity )
		{
		case ACT_PRONE_IDLE:
			idealActivity = ACT_DOD_PRONE_DEPLOYED;
			break;
		case ACT_RANGE_ATTACK1:
			idealActivity = ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED;
			break;
		case ACT_RELOAD:
			idealActivity = ACT_DOD_RELOAD_PRONE_DEPLOYED;
			break;
		default:
			break;
		}
	} 
	else if ( m_pOuterDOD->m_Shared.IsSniperZoomed() || m_pOuterDOD->m_Shared.IsBazookaDeployed() )
	{
		switch( idealActivity )
		{
		case ACT_IDLE:
			idealActivity = ACT_DOD_IDLE_ZOOMED;
			break;
		case ACT_WALK:
			idealActivity = ACT_DOD_WALK_ZOOMED;
			break;
		case ACT_CROUCHIDLE:
			idealActivity = ACT_DOD_CROUCH_ZOOMED;
			break;
		case ACT_RUN_CROUCH:
			idealActivity = ACT_DOD_CROUCHWALK_ZOOMED;
			break;
		case ACT_PRONE_IDLE:
			idealActivity = ACT_DOD_PRONE_ZOOMED;
			break;
		case ACT_PRONE_FORWARD:
			idealActivity = ACT_DOD_PRONE_FORWARD_ZOOMED;
			break;
		case ACT_RANGE_ATTACK1:
			if ( m_pOuterDOD->m_Shared.IsSniperZoomed() )
			{
				if( m_pOuterDOD->m_Shared.IsProne() )
					idealActivity = ACT_DOD_PRIMARYATTACK_PRONE;
			}
			break;
		case ACT_RELOAD:
			if ( m_pOuterDOD->m_Shared.IsBazookaDeployed() )
			{
				if( m_pOuterDOD->m_Shared.IsProne() )
				{
					idealActivity = ACT_DOD_RELOAD_PRONE_DEPLOYED;
				}
				else
				{
					idealActivity = ACT_DOD_RELOAD_DEPLOYED;
				}
			}
			break;
		default:
			break;
		}
	}
	else if ( m_pOuterDOD->m_Shared.IsProne() )
	{
		// translate prone shooting, reload, handsignal

		switch( idealActivity )
		{
		case ACT_RANGE_ATTACK1:
			idealActivity = ACT_DOD_PRIMARYATTACK_PRONE;
			break;
		case ACT_RANGE_ATTACK2:
			idealActivity = ACT_DOD_SECONDARYATTACK_PRONE;
			break;
		case ACT_RELOAD:			
			idealActivity = ACT_DOD_RELOAD_PRONE;
			break;
		default:
			break;
		}
	}
	else if ( m_pOuter->GetFlags() & FL_DUCKING )
	{
		switch( idealActivity )
		{
		case ACT_RANGE_ATTACK1:
			idealActivity = ACT_DOD_PRIMARYATTACK_CROUCH;
			break;
		case ACT_RANGE_ATTACK2:
			idealActivity = ACT_DOD_SECONDARYATTACK_CROUCH;
			break;
		case ACT_DOD_HS_IDLE:
			idealActivity = ACT_DOD_HS_CROUCH;
			break;
		}
	}

	// Are our guns at fire or rest?
	if ( m_flFireIdleTime > gpGlobals->curtime )
	{
		switch( idealActivity )
		{
		case ACT_IDLE:			idealActivity = ACT_DOD_STAND_AIM; break;
		case ACT_CROUCHIDLE:	idealActivity = ACT_DOD_CROUCH_AIM; break;
		case ACT_RUN_CROUCH:	idealActivity = ACT_DOD_CROUCHWALK_AIM; break;
		case ACT_WALK:			idealActivity = ACT_DOD_WALK_AIM; break;
		case ACT_RUN:			idealActivity = ACT_DOD_RUN_AIM; break;
		default: break;
		}
	}
	else
	{
		switch( idealActivity )
		{
		case ACT_IDLE:			idealActivity = ACT_DOD_STAND_IDLE; break;
		case ACT_CROUCHIDLE:	idealActivity = ACT_DOD_CROUCH_IDLE; break;
		case ACT_RUN_CROUCH:	idealActivity = ACT_DOD_CROUCHWALK_IDLE; break;
		case ACT_WALK:			idealActivity = ACT_DOD_WALK_IDLE; break;
		case ACT_RUN:			idealActivity = ACT_DOD_RUN_IDLE; break;
		default: break;
		}
	}

	return m_pOuterDOD->TranslateActivity( idealActivity );
}

CDODPlayer* CDODPlayerAnimState::GetOuterDOD() const
{
	return m_pOuterDOD;
}

float CDODPlayerAnimState::GetCurrentMaxGroundSpeed()
{
	return PLAYER_SPEED_SPRINT; 
}

float CDODPlayerAnimState::CalcMovementPlaybackRate( bool *bIsMoving )
{
	if( ( GetCurrentMainSequenceActivity() == ACT_GET_UP_STAND ) || ( GetCurrentMainSequenceActivity() == ACT_GET_DOWN_STAND ) ||
		( GetCurrentMainSequenceActivity() == ACT_GET_UP_CROUCH ) || ( GetCurrentMainSequenceActivity() == ACT_GET_DOWN_CROUCH ) )
	{
		// We don't want to change the playback speed of these, even if we move.
		*bIsMoving = false;
		return 1.0;
	}

	// it would be a good idea to ramp up from 0.5 to 1.0 as they go from stop to moveing, it looks more natural.
	*bIsMoving = true;
	return 1.0;
}

void CDODPlayerAnimState::DebugShowAnimState( int iStartLine )
{
#ifdef CLIENT_DLL
	engine->Con_NPrintf( iStartLine++, "getting down: %s\n", m_bGettingDown ? "yes" : "no" );
	engine->Con_NPrintf( iStartLine++, "getting up: %s\n", m_bGettingUp ? "yes" : "no" );
#endif

	BaseClass::DebugShowAnimState( iStartLine );
}

void CDODPlayerAnimState::ComputeSequences( CStudioHdr *pStudioHdr )
{
	// Reset some things if we're changed weapons
	// do this before ComputeSequences
	CWeaponDODBase *pWeapon = GetOuterDOD()->m_Shared.GetActiveDODWeapon();
	if ( pWeapon )
	{	
		if( pWeapon->GetWeaponID() != m_iLastWeaponID )
		{
			CancelGestures();
			m_iLastWeaponID = pWeapon->GetWeaponID();
			m_flFireIdleTime = 0;
		}
	}

	BaseClass::ComputeSequences( pStudioHdr );

	if( !m_bGettingDown && !m_bGettingUp )
	{
		ComputeFireSequence();
	
#ifdef CLIENT_DLL

		ComputeGestureSequence( pStudioHdr );

		// get the weapon's swap criteria ( reload? attack? deployed? deployed reload? )
		// and determine whether we should use alt model or not

		CWeaponDODBase *pWeapon = GetOuterDOD()->m_Shared.GetActiveDODWeapon();
		if ( pWeapon )
		{	
			int iCurrentState = ALTWPN_CRITERIA_NONE;

			if( m_bPlayingGesture && m_iGestureType == GESTURE_ATTACK1 )
				iCurrentState |= ALTWPN_CRITERIA_FIRING;

			else if( m_bPlayingGesture && m_iGestureType == GESTURE_RELOAD )
				iCurrentState |= ALTWPN_CRITERIA_RELOADING;

			if( m_pOuterDOD->m_Shared.IsProne() )
				iCurrentState |= ALTWPN_CRITERIA_PRONE;

			// always use default model while proning or hand signal
			if( !IsPlayingGesture( GESTURE_HAND_SIGNAL ) &&
				!IsPlayingGesture( GESTURE_FIDGET ) &&
				!m_bGettingDown &&
				!m_bGettingUp )
			{
				pWeapon->CheckForAltWeapon( iCurrentState );
			}
			else
			{
				pWeapon->SetUseAltModel( false );
			}
		}
#endif
	}
}

#define GESTURE_LAYER			AIMSEQUENCE_LAYER
#define NUM_LAYERS_WANTED		(GESTURE_LAYER + 1)

void CDODPlayerAnimState::ClearAnimationLayers()
{
	if ( !m_pOuter )
		return;

	m_pOuter->SetNumAnimOverlays( NUM_LAYERS_WANTED );
	for ( int i=0; i < m_pOuter->GetNumAnimOverlays(); i++ )
	{
		m_pOuter->GetAnimOverlay( i )->SetOrder( CBaseAnimatingOverlay::MAX_OVERLAYS );
	}
}

void CDODPlayerAnimState::ComputeFireSequence( void )
{
	// Hold the shoot pose for a time after firing, unless we stand still
	if( m_flFireIdleTime < gpGlobals->curtime &&
		IsPlayingGesture( GESTURE_ATTACK1 ) &&
		GetOuterXYSpeed() > MOVING_MINIMUM_SPEED )
	{
		CancelGestures();
	}

	if( GetOuterDOD()->m_Shared.IsInMGDeploy() != m_bLastDeployState )
	{
		CancelGestures();

		m_bLastDeployState = GetOuterDOD()->m_Shared.IsInMGDeploy();
	}
}

void CDODPlayerAnimState::ComputeGestureSequence( CStudioHdr *pStudioHdr )
{
	UpdateLayerSequenceGeneric( pStudioHdr, GESTURE_LAYER, m_bPlayingGesture, m_flGestureCycle, m_iGestureSequence, !m_bAutokillGesture );
}

void CDODPlayerAnimState::UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd, float flWeight /* = 1.0 */ )
{
	if ( !bEnabled )
		return;

	if( flCurCycle > 1.0 )
		flCurCycle = 1.0;

	// Increment the fire sequence's cycle.
	flCurCycle += m_pOuter->GetSequenceCycleRate( pStudioHdr, iSequence ) * gpGlobals->frametime;
	if ( flCurCycle > 1 )
	{
		if ( bWaitAtEnd )
		{
			flCurCycle = 1;
		}
		else
		{
			// Not firing anymore.
			bEnabled = false;
			iSequence = 0;
			return;
		}
	}

	CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( iLayer );

	pLayer->m_flCycle = flCurCycle;
	pLayer->m_nSequence = iSequence;

	pLayer->m_flPlaybackRate = 1.0;
	pLayer->m_flWeight = flWeight;
	pLayer->m_nOrder = iLayer;
	
}

extern ConVar mp_facefronttime;
extern ConVar mp_feetyawrate;

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::Update( float eyeYaw, float eyePitch )
{
	// Profile the animation update.
	VPROF( "CDODPlayerAnimState::Update" );

	// Get the studio header for the player.
	CStudioHdr *pStudioHdr = GetOuterDOD()->GetModelPtr();
	if ( !pStudioHdr )
		return;

	// Check to see if we should be updating the animation state - dead, ragdolled?
	if ( !ShouldUpdateAnimState() )
	{
		ClearAnimationState();
		return;
	}

	// Store the eye angles.
	m_flEyeYaw = AngleNormalize( eyeYaw );
	m_flEyePitch = AngleNormalize( eyePitch );

	// Clear animation overlays because we're about to completely reconstruct them.
	ClearAnimationLayers();

	// Compute the player sequences.
	ComputeSequences( pStudioHdr );

	if ( SetupPoseParameters( pStudioHdr ) )
	{
		// Pose parameter - what direction are the player's legs running in.
		ComputePoseParam_MoveYaw( pStudioHdr );

		// Pose parameter - Torso aiming (up/down).
		ComputePoseParam_AimPitch( pStudioHdr );

		// Pose parameter - Torso aiming (rotation).
		ComputePoseParam_AimYaw( pStudioHdr );

		// Pose parameter - Body Height (torso elevation).
		ComputePoseParam_BodyHeight( pStudioHdr );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CDODPlayerAnimState::SetupPoseParameters( CStudioHdr *pStudioHdr )
{
	// Check to see if this has already been done.
	if ( m_bPoseParameterInit )
		return true;

	// Save off the pose parameter indices.
	if ( !pStudioHdr )
		return false;

	// Look for the movement blenders.
	m_iMoveX = GetOuterDOD()->LookupPoseParameter( pStudioHdr, "move_x" );
	m_iMoveY = GetOuterDOD()->LookupPoseParameter( pStudioHdr, "move_y" );
	if ( ( m_iMoveX < 0 ) || ( m_iMoveY < 0 ) )
		return false;

	// Look for the aim pitch blender.
	m_iAimPitch = GetOuterDOD()->LookupPoseParameter( pStudioHdr, "body_pitch" );
	if ( m_iAimPitch < 0 )
		return false;

	// Look for aim yaw blender.
	m_iAimYaw = GetOuterDOD()->LookupPoseParameter( pStudioHdr, "body_yaw" );
	if ( m_iAimYaw < 0 )
		return false;

	// Look for the body height blender.
	m_iBodyHeight = GetOuterDOD()->LookupPoseParameter( pStudioHdr, "body_height" );
	if ( m_iBodyHeight < 0 )
		return false;

	m_bPoseParameterInit = true;

	return true;
}

#define DOD_MOVEMENT_ERROR_LIMIT  1.0

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::ComputePoseParam_MoveYaw( CStudioHdr *pStudioHdr )
{
	// Check to see if we are deployed or prone.
	if( GetOuterDOD()->m_Shared.IsInMGDeploy() || GetOuterDOD()->m_Shared.IsProne() )
	{
		// Set the 9-way blend movement pose parameters.
		Vector2D vecCurrentMoveYaw( 0.0f, 0.0f );
		GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveX, vecCurrentMoveYaw.x );
		GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveY, vecCurrentMoveYaw.y );

		m_vecLastMoveYaw = vecCurrentMoveYaw;

#if 0
		// Rotate the entire body instantly.
		m_flGoalFeetYaw = AngleNormalize( m_flEyeYaw );
		m_flCurrentFeetYaw = m_flGoalFeetYaw;
		m_flLastTurnTime = gpGlobals->curtime;

		// Rotate entire body into position.
		m_angRender[YAW] = m_flCurrentFeetYaw;
		m_angRender[PITCH] = m_angRender[ROLL] = 0;

		SetOuterBodyYaw( m_flCurrentFeetYaw );
		g_flLastBodyYaw = m_flCurrentFeetYaw;
#endif
	}
	else
	{
		// Get the estimated movement yaw.
		EstimateYaw();

		// Get the view yaw.
		float flAngle = AngleNormalize( m_flEyeYaw );

		// rotate movement into local reference frame
		float flYaw = flAngle - m_flEstimateYaw;
		flYaw = AngleNormalize( -flYaw );

		// Get the current speed the character is running.
		Vector vecEstVelocity;
		vecEstVelocity.x = cos( DEG2RAD( flYaw ) ) * m_flEstimateVelocity;
		vecEstVelocity.y = sin( DEG2RAD( flYaw ) ) * m_flEstimateVelocity;

		Vector2D vecCurrentMoveYaw( 0.0f, 0.0f );
		// set the pose parameters to the correct direction, but not value
		if ( vecEstVelocity.x != 0.0f && fabs( vecEstVelocity.x ) > fabs( vecEstVelocity.y ) )
		{
			vecCurrentMoveYaw.x = (vecEstVelocity.x < 0.0) ? -1.0 : 1.0;
			vecCurrentMoveYaw.y = vecEstVelocity.y / fabs( vecEstVelocity.x );
		}
		else if (vecEstVelocity.y != 0.0f)
		{
			vecCurrentMoveYaw.y = (vecEstVelocity.y < 0.0) ? -1.0 : 1.0;
			vecCurrentMoveYaw.x = vecEstVelocity.x / fabs( vecEstVelocity.y );
		}

#ifndef CLIENT_DLL
		GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveX, vecCurrentMoveYaw.x );
		GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveY, vecCurrentMoveYaw.y );
#else

		// refine pose parameters to be more accurate
		int i = 0;
		float dx, dy;
		Vector vecAnimVelocity;

		/*
		if ( m_pOuter->entindex() == 2 )
		{
			GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveX, vecCurrentMoveYaw.x );
			GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveY, vecCurrentMoveYaw.y );
			GetOuterDOD()->GetBlendedLinearVelocity( &vecAnimVelocity );
			DevMsgRT("(%.2f) %.3f : (%.2f) %.3f\n", vecAnimVelocity.x, vecCurrentMoveYaw.x, vecAnimVelocity.y, vecCurrentMoveYaw.y );
		}
		*/

		bool retry = true;
		do 
		{
			// Set the 9-way blend movement pose parameters.
			GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveX, vecCurrentMoveYaw.x );
			GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveY, vecCurrentMoveYaw.y );

			GetOuterDOD()->GetBlendedLinearVelocity( &vecAnimVelocity );

			// adjust X pose parameter based on movement error
			if (fabs( vecAnimVelocity.x ) > 0.001)
			{
				vecCurrentMoveYaw.x *= vecEstVelocity.x / vecAnimVelocity.x;
			}
			else
			{
				vecCurrentMoveYaw.x = 0;
				GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveX, vecCurrentMoveYaw.x );
			}
			// adjust Y pose parameter based on movement error
			if (fabs( vecAnimVelocity.y ) > 0.001)
			{
				vecCurrentMoveYaw.y *= vecEstVelocity.y / vecAnimVelocity.y;
			}
			else
			{
				vecCurrentMoveYaw.y = 0;
				GetOuter()->SetPoseParameter( pStudioHdr, m_iMoveY, vecCurrentMoveYaw.y );
			}

			dx =  vecEstVelocity.x - vecAnimVelocity.x;
			dy =  vecEstVelocity.y - vecAnimVelocity.y;

			retry = (vecCurrentMoveYaw.x < 1.0 && vecCurrentMoveYaw.x > -1.0) && (dx < -DOD_MOVEMENT_ERROR_LIMIT || dx > DOD_MOVEMENT_ERROR_LIMIT);
			retry = retry || ((vecCurrentMoveYaw.y < 1.0 && vecCurrentMoveYaw.y > -1.0) && (dy < -DOD_MOVEMENT_ERROR_LIMIT || dy > DOD_MOVEMENT_ERROR_LIMIT));

		} while (i++ < 5 && retry);

		/*
		if ( m_pOuter->entindex() == 2 )
		{
			DevMsgRT("%d(%.2f : %.2f) %.3f : (%.2f : %.2f) %.3f\n", 
				i,
				vecEstVelocity.x, vecAnimVelocity.x, vecCurrentMoveYaw.x, 
				vecEstVelocity.y, vecAnimVelocity.y, vecCurrentMoveYaw.y );
		}
		*/
#endif

		m_vecLastMoveYaw = vecCurrentMoveYaw;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::EstimateYaw( void )
{
	// Get the frame time.
	float flDeltaTime = gpGlobals->frametime;
	if ( flDeltaTime == 0.0f )
	{
		// FIXME: why does this short circuit?
		m_flEstimateVelocity = 0.0;
		m_flEstimateYaw = 0.0;
		return;
	}

	// Get the player's velocity and angles.
	Vector vecEstVelocity;
	GetOuterAbsVelocity( vecEstVelocity );
	QAngle angles = GetOuterDOD()->GetLocalAngles();

	// If we are not moving, sync up the feet and eyes slowly.
	if ( vecEstVelocity.x == 0.0f && vecEstVelocity.y == 0.0f )
	{
		float flYawDelta = angles[YAW] - m_flEstimateYaw;
		flYawDelta = AngleNormalize( flYawDelta );

		if ( flDeltaTime < 0.25f )
		{
			flYawDelta *= ( flDeltaTime * 4.0f );
		}
		else
		{
			flYawDelta *= flDeltaTime;
		}

		m_flEstimateVelocity = 0.0;
		m_flEstimateYaw += flYawDelta;
		AngleNormalize( m_flEstimateYaw );
	}
	else
	{
		m_flEstimateVelocity = vecEstVelocity.Length2D();
		m_flEstimateYaw = ( atan2( vecEstVelocity.y, vecEstVelocity.x ) * 180.0f / M_PI );
		m_flEstimateYaw = clamp( m_flEstimateYaw, -180.0f, 180.0f );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::ComputePoseParam_AimPitch( CStudioHdr *pStudioHdr )
{
	// Get the view pitch.
	float flAimPitch = m_flEyePitch;

	// Lock pitch at 0 if a reload gesture is playing
#ifdef CLIENT_DLL
	if ( IsPlayingGesture( GESTURE_RELOAD ) )
		flAimPitch = 0;
#else
	Activity idealActivity = TranslateActivity( ACT_RELOAD );

	if ( m_pOuter->IsPlayingGesture( idealActivity ) )
		flAimPitch = 0;
#endif

	// Set the aim pitch pose parameter and save.
	GetOuter()->SetPoseParameter( pStudioHdr, m_iAimPitch, -flAimPitch );
	m_flLastAimPitch = flAimPitch;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::ComputePoseParam_AimYaw( CStudioHdr *pStudioHdr )
{
	// Get the movement velocity.
	Vector vecVelocity;
	GetOuterAbsVelocity( vecVelocity );

	// Check to see if we are moving.
	bool bMoving = ( vecVelocity.Length() > 1.0f ) ? true : false;

	// Check our prone and deployed state.
	bool bDeployed = GetOuterDOD()->m_Shared.IsSandbagDeployed() || GetOuterDOD()->m_Shared.IsProneDeployed();
	bool bProne = GetOuterDOD()->m_Shared.IsProne();

	// If we are moving or are prone and undeployed.
	if ( bMoving || ( bProne && !bDeployed ) )
	{
		// The feet match the eye direction when moving - the move yaw takes care of the rest.
		m_flGoalFeetYaw = m_flEyeYaw;
	}
	// Else if we are not moving.
	else
	{
		// Initialize the feet.
		if ( m_flLastAimTurnTime <= 0.0f )
		{
			m_flGoalFeetYaw	= m_flEyeYaw;
			m_flCurrentFeetYaw = m_flEyeYaw;
			m_flLastAimTurnTime = gpGlobals->curtime;
		}
		// Make sure the feet yaw isn't too far out of sync with the eye yaw.
		// TODO: Do something better here!
		else
		{
			float flYawDelta = AngleNormalize(  m_flGoalFeetYaw - m_flEyeYaw );

			if ( bDeployed )
			{
				if ( fabs( flYawDelta ) > 20.0f )
				{
					float flSide = ( flYawDelta > 0.0f ) ? -1.0f : 1.0f;
					m_flGoalFeetYaw += ( 20.0f * flSide );
				}
			}
			else
			{
				if ( fabs( flYawDelta ) > m_AnimConfig.m_flMaxBodyYawDegrees )
				{
					float flSide = ( flYawDelta > 0.0f ) ? -1.0f : 1.0f;
					m_flGoalFeetYaw += ( m_AnimConfig.m_flMaxBodyYawDegrees * flSide );
				}
			}
		}
	}

	// Fix up the feet yaw.
	m_flGoalFeetYaw = AngleNormalize( m_flGoalFeetYaw );
	if ( m_flGoalFeetYaw != m_flCurrentFeetYaw )
	{
		ConvergeYawAngles( m_flGoalFeetYaw, DOD_BODYYAW_RATE, gpGlobals->frametime, m_flCurrentFeetYaw );
		m_flLastAimTurnTime = gpGlobals->curtime;
	}

	// Rotate the body into position.
	m_angRender[YAW] = m_flCurrentFeetYaw;

	// Find the aim(torso) yaw base on the eye and feet yaws.
	float flAimYaw = m_flEyeYaw - m_flCurrentFeetYaw;
	flAimYaw = AngleNormalize( flAimYaw );

	// Set the aim yaw and save.
	GetOuter()->SetPoseParameter( pStudioHdr, m_iAimYaw, -flAimYaw );
	m_flLastAimYaw	= flAimYaw;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::ConvergeYawAngles( float flGoalYaw, float flYawRate, float flDeltaTime, float &flCurrentYaw )
{
#define FADE_TURN_DEGREES 60.0f

	// Find the yaw delta.
	float flDeltaYaw = flGoalYaw - flCurrentYaw;
	float flDeltaYawAbs = fabs( flDeltaYaw );
	flDeltaYaw = AngleNormalize( flDeltaYaw );

	// Always do at least a bit of the turn (1%).
	float flScale = 1.0f;
	flScale = flDeltaYawAbs / FADE_TURN_DEGREES;
	flScale = clamp( flScale, 0.01f, 1.0f );

	float flYaw = flYawRate * flDeltaTime * flScale;
	if ( flDeltaYawAbs < flYaw )
	{
		flCurrentYaw = flGoalYaw;
	}
	else
	{
		float flSide = ( flDeltaYaw < 0.0f ) ? -1.0f : 1.0f;
		flCurrentYaw += ( flYaw * flSide );
	}

	flCurrentYaw = AngleNormalize( flCurrentYaw );

#undef FADE_TURN_DEGREES
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::ComputePoseParam_BodyHeight( CStudioHdr *pStudioHdr )
{
	if( m_pOuterDOD->m_Shared.IsSandbagDeployed() )
	{
//		float flHeight = m_pOuterDOD->m_Shared.GetDeployedHeight() - 4.0f;
		float flHeight = m_pOuterDOD->m_Shared.GetDeployedHeight() - dod_bodyheightoffset.GetFloat();
		GetOuter()->SetPoseParameter( pStudioHdr, m_iBodyHeight, flHeight );
		m_flLastBodyHeight = flHeight;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Anim_StateLog( const char *pMsg, ... )
{
	// Format the string.
	char str[4096];
	va_list marker;
	va_start( marker, pMsg );
	Q_vsnprintf( str, sizeof( str ), pMsg, marker );
	va_end( marker );

	// Log it?	
	if ( anim_showstatelog.GetInt() == 1 || anim_showstatelog.GetInt() == 3 )
	{
		Msg( "%s", str );
	}

	if ( anim_showstatelog.GetInt() > 1 )
	{
//		static FileHandle_t hFile = filesystem->Open( "AnimState.log", "wt" );
//		filesystem->FPrintf( hFile, "%s", str );
//		filesystem->Flush( hFile );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Anim_StatePrintf( int iLine, const char *pMsg, ... )
{
	// Format the string.
	char str[4096];
	va_list marker;
	va_start( marker, pMsg );
	Q_vsnprintf( str, sizeof( str ), pMsg, marker );
	va_end( marker );

	// Show it with Con_NPrintf.
	engine->Con_NPrintf( iLine, "%s", str );

	// Log it.
	Anim_StateLog( "%s\n", str );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::DebugShowAnimStateForPlayer( bool bIsServer )
{
	// Get the player's velocity.
	Vector vecVelocity;
	GetOuterAbsVelocity( vecVelocity );

	// Start animation state logging.
	int iLine = 5;
	if ( bIsServer )
	{
		iLine = 12;
	}
//	Anim_StateLog( "-------------%s: frame %d -----------------\n", bIsServer ? "Server" : "Client", gpGlobals->framecount );
	Anim_StatePrintf( iLine++, "-------------%s: frame %d -----------------\n", bIsServer ? "Server" : "Client", gpGlobals->framecount );

	// Write out the main sequence and its data.
	Anim_StatePrintf( iLine++, "Main: %s, Cycle: %.2f\n", GetSequenceName( GetOuter()->GetModelPtr(), GetOuter()->GetSequence() ), GetOuter()->GetCycle() );

	// Write out the layers and their data.
	for ( int iAnim = 0; iAnim < GetOuter()->GetNumAnimOverlays(); ++iAnim )
	{
		CAnimationLayer *pLayer = GetOuter()->GetAnimOverlay( iAnim );
		if ( pLayer && ( pLayer->m_nOrder != CBaseAnimatingOverlay::MAX_OVERLAYS ) )
		{
			Anim_StatePrintf( iLine++, "Layer %s: Weight: %.2f, Cycle: %.2f", GetSequenceName( GetOuter()->GetModelPtr(), pLayer->m_nSequence ), (float)pLayer->m_flWeight, (float)pLayer->m_flCycle );
		}
	}

	// Write out the speed data.
	Anim_StatePrintf( iLine++, "Time: %.2f, Speed: %.2f, MaxSpeed: %.2f", gpGlobals->curtime, vecVelocity.Length2D(), GetCurrentMaxGroundSpeed() );

	// Write out the 9-way blend data.
	Anim_StatePrintf( iLine++, "EntityYaw: %.2f, AimYaw: %.2f, AimPitch: %.2f, MoveX: %.2f, MoveY: %.2f Body: %.2f", m_angRender[YAW], m_flLastAimYaw, m_flLastAimPitch, m_vecLastMoveYaw.x, m_vecLastMoveYaw.y, m_flLastBodyHeight );

//	Anim_StateLog( "--------------------------------------------\n\n" );
	Anim_StatePrintf( iLine++, "--------------------------------------------\n\n" );

	DebugShowEyeYaw();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::DebugShowEyeYaw( void )
{
#ifdef _NDEBUG

	float flBaseSize = 10;
	float flHeight = 80;

	Vector vecPos = GetOuter()->GetAbsOrigin() + Vector( 0.0f, 0.0f, 3.0f );
	QAngle angles( 0.0f, 0.0f, 0.0f );

	angles[YAW] = m_flEyeYaw;

	Vector vecForward, vecRight, vecUp;
	AngleVectors( angles, &vecForward, &vecRight, &vecUp );

	// Draw a red triangle on the ground for the eye yaw.
	debugoverlay->AddTriangleOverlay( ( vecPos + vecRight * flBaseSize / 2.0f ), 
		( vecPos - vecRight * flBaseSize / 2.0f ), 
		( vecPos + vecForward * flHeight, 255, 0, 0, 255, false, 0.01f );

#endif
}

// Client specific debug functions.
#ifdef CLIENT_DLL

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODPlayerAnimState::DebugShowActivity( Activity activity )
{
#ifdef _DEBUG

	const char *pszActivity = "other";

	switch( activity )
	{
	case ACT_IDLE:
		{
			pszActivity = "idle";
			break;
		}
	case ACT_SPRINT:
		{
			pszActivity = "sprint";
			break;
		}
	case ACT_WALK:
		{
			pszActivity = "walk";
			break;
		}
	case ACT_RUN:
		{
			pszActivity = "run";
			break;
		}
	}

	Msg( "Activity: %s\n", pszActivity );

#endif
}

#endif