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

#include "cbase.h"
#include "tier0/vprof.h"
#include "animation.h"
#include "studio.h"
#include "apparent_velocity_helper.h"
#include "utldict.h"
#include "tf_playeranimstate.h"
#include "base_playeranimstate.h"
#include "datacache/imdlcache.h"
#include "tf_gamerules.h"
#include "in_buttons.h"
#include "debugoverlay_shared.h"
#include "tf_weapon_passtime_gun.h"

#ifdef CLIENT_DLL
#include "c_tf_player.h"
#include "c_func_capture_zone.h"
#include "tf_gcmessages.h"

#define CCaptureZone C_CaptureZone
#else
#include "tf_player.h"
#include "func_capture_zone.h"
#endif

#define TF_RUN_SPEED			320.0f
#define TF_WALK_SPEED			75.0f
#define TF_CROUCHWALK_SPEED		110.0f

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
// Output : CMultiPlayerAnimState*
//-----------------------------------------------------------------------------
CTFPlayerAnimState* CreateTFPlayerAnimState( CTFPlayer *pPlayer )
{
	MDLCACHE_CRITICAL_SECTION();

	// Setup the movement data.
	MultiPlayerMovementData_t movementData;
	movementData.m_flBodyYawRate = 720.0f;
	movementData.m_flRunSpeed = TF_RUN_SPEED;
	movementData.m_flWalkSpeed = TF_WALK_SPEED;
	movementData.m_flSprintSpeed = -1.0f;

	// Create animation state for this player.
	CTFPlayerAnimState *pRet = new CTFPlayerAnimState( pPlayer, movementData );

	// Specific TF player initialization.
	pRet->InitTF( pPlayer );

	return pRet;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  :  - 
//-----------------------------------------------------------------------------
CTFPlayerAnimState::CTFPlayerAnimState()
{
	m_pTFPlayer = NULL;

	// Don't initialize TF specific variables here. Init them in InitTF()
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
//			&movementData - 
//-----------------------------------------------------------------------------
CTFPlayerAnimState::CTFPlayerAnimState( CBasePlayer *pPlayer, MultiPlayerMovementData_t &movementData )
: CMultiPlayerAnimState( pPlayer, movementData )
{
	m_pTFPlayer = NULL;

	// Don't initialize TF specific variables here. Init them in InitTF()
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  :  - 
//-----------------------------------------------------------------------------
CTFPlayerAnimState::~CTFPlayerAnimState()
{
}

//-----------------------------------------------------------------------------
// Purpose: Initialize Team Fortress specific animation state.
// Input  : *pPlayer - 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::InitTF( CTFPlayer *pPlayer )
{
	m_pTFPlayer = pPlayer;
	m_bInAirWalk = false;
	m_flHoldDeployedPoseUntilTime = 0.0f;
	m_flTauntMoveX = 0.f;
	m_flTauntMoveY = 0.f;
	m_vecSmoothedUp = Vector( 0.f, 0.f, 1.f );
	m_flVehicleLeanVel = 0.f;
	m_flVehicleLeanPos = 0.f;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::ClearAnimationState( void )
{
	m_bInAirWalk = false;

	BaseClass::ClearAnimationState();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : actDesired - 
// Output : Activity
//-----------------------------------------------------------------------------
Activity CTFPlayerAnimState::TranslateActivity( Activity actDesired )
{
	Activity translateActivity = BaseClass::TranslateActivity( actDesired );

	translateActivity = ActivityOverride( translateActivity, NULL );

	CBaseCombatWeapon *pWeapon = GetTFPlayer()->GetActiveWeapon();
	if ( pWeapon )
	{
		translateActivity = pWeapon->ActivityOverride( translateActivity, NULL );

		CEconItemView *pEconItemView = pWeapon->GetAttributeContainer()->GetItem();
		if ( pEconItemView )
		{
			translateActivity = pEconItemView->GetStaticData()->GetActivityOverride( GetTFPlayer()->GetTeamNumber(), translateActivity );
		}
	}

	CTFPlayer *pPlayer = GetTFPlayer();
	if ( pPlayer->m_Shared.InCond( TF_COND_COMPETITIVE_WINNER ) )
	{
		if ( translateActivity == ACT_MP_STAND_PRIMARY || 
		   ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && ( translateActivity == ACT_MP_STAND_MELEE ) ) || 
		   ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) && ( translateActivity == ACT_MP_STAND_SECONDARY ) ) )
		{
			translateActivity = ACT_MP_COMPETITIVE_WINNERSTATE;
		}
	}

	return translateActivity;
}


static acttable_t s_acttableKartState[] = 
{
	{ ACT_MP_STAND_IDLE,					ACT_KART_IDLE,			false },
	{ ACT_MP_RUN,							ACT_KART_IDLE,			false },
	{ ACT_MP_WALK,							ACT_KART_IDLE,			false },
	{ ACT_MP_AIRWALK,						ACT_KART_IDLE,			false },
	{ ACT_MP_ATTACK_STAND_PRIMARYFIRE,		ACT_KART_ACTION_SHOOT,	false },
	{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE,	ACT_KART_ACTION_SHOOT,	false },
	{ ACT_MP_JUMP_START,					ACT_KART_JUMP_START,	false },
	{ ACT_MP_JUMP_FLOAT,					ACT_KART_JUMP_FLOAT,	false },
	{ ACT_MP_JUMP_LAND,						ACT_KART_JUMP_LAND,		false },
};

static acttable_t s_acttableLoserState[] = 
{
	{ ACT_MP_STAND_IDLE,		ACT_MP_STAND_LOSERSTATE,			false },
	{ ACT_MP_CROUCH_IDLE,		ACT_MP_CROUCH_LOSERSTATE,			false },
	{ ACT_MP_RUN,				ACT_MP_RUN_LOSERSTATE,				false },
	{ ACT_MP_WALK,				ACT_MP_WALK_LOSERSTATE,				false },
	{ ACT_MP_AIRWALK,			ACT_MP_AIRWALK_LOSERSTATE,			false },
	{ ACT_MP_CROUCHWALK,		ACT_MP_CROUCHWALK_LOSERSTATE,		false },
	{ ACT_MP_JUMP,				ACT_MP_JUMP_LOSERSTATE,				false },
	{ ACT_MP_JUMP_START,		ACT_MP_JUMP_START_LOSERSTATE,		false },
	{ ACT_MP_JUMP_FLOAT,		ACT_MP_JUMP_FLOAT_LOSERSTATE,		false },
	{ ACT_MP_JUMP_LAND,			ACT_MP_JUMP_LAND_LOSERSTATE,		false },
	{ ACT_MP_SWIM,				ACT_MP_SWIM_LOSERSTATE,				false },
	{ ACT_MP_DOUBLEJUMP_CROUCH,	ACT_MP_DOUBLEJUMP_CROUCH_LOSERSTATE,false },
};

static acttable_t s_acttableCompetitiveLoserState[] =
{
	{ ACT_MP_STAND_IDLE, ACT_MP_COMPETITIVE_LOSERSTATE, false },
};

static acttable_t s_acttableBuildingDeployed[] = 
{
	{ ACT_MP_STAND_IDLE,		ACT_MP_STAND_BUILDING_DEPLOYED,			false },
	{ ACT_MP_CROUCH_IDLE,		ACT_MP_CROUCH_BUILDING_DEPLOYED,		false },
	{ ACT_MP_RUN,				ACT_MP_RUN_BUILDING_DEPLOYED,			false },
	{ ACT_MP_WALK,				ACT_MP_WALK_BUILDING_DEPLOYED,			false },
	{ ACT_MP_AIRWALK,			ACT_MP_AIRWALK_BUILDING_DEPLOYED,		false },
	{ ACT_MP_CROUCHWALK,		ACT_MP_CROUCHWALK_BUILDING_DEPLOYED,	false },
	{ ACT_MP_JUMP,				ACT_MP_JUMP_BUILDING_DEPLOYED,			false },
	{ ACT_MP_JUMP_START,		ACT_MP_JUMP_START_BUILDING_DEPLOYED,	false },
	{ ACT_MP_JUMP_FLOAT,		ACT_MP_JUMP_FLOAT_BUILDING_DEPLOYED,	false },
	{ ACT_MP_JUMP_LAND,			ACT_MP_JUMP_LAND_BUILDING_DEPLOYED,		false },
	{ ACT_MP_SWIM,				ACT_MP_SWIM_BUILDING_DEPLOYED,			false },

	{ ACT_MP_ATTACK_STAND_PRIMARYFIRE,		ACT_MP_ATTACK_STAND_BUILDING_DEPLOYED,		false },
	{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE,		ACT_MP_ATTACK_CROUCH_BUILDING_DEPLOYED,		false },
	{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE,		ACT_MP_ATTACK_SWIM_BUILDING_DEPLOYED,		false },
	{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE,	ACT_MP_ATTACK_AIRWALK_BUILDING_DEPLOYED,	false },

	{ ACT_MP_ATTACK_STAND_GRENADE,		ACT_MP_ATTACK_STAND_GRENADE_BUILDING_DEPLOYED,	false },
	{ ACT_MP_ATTACK_CROUCH_GRENADE,		ACT_MP_ATTACK_STAND_GRENADE_BUILDING_DEPLOYED,	false },
	{ ACT_MP_ATTACK_SWIM_GRENADE,		ACT_MP_ATTACK_STAND_GRENADE_BUILDING_DEPLOYED,	false },
	{ ACT_MP_ATTACK_AIRWALK_GRENADE,	ACT_MP_ATTACK_STAND_GRENADE_BUILDING_DEPLOYED,	false },

	{ ACT_MP_GESTURE_VC_HANDMOUTH,	ACT_MP_GESTURE_VC_HANDMOUTH_BUILDING,		false },
	{ ACT_MP_GESTURE_VC_FINGERPOINT,	ACT_MP_GESTURE_VC_FINGERPOINT_BUILDING,	false },
	{ ACT_MP_GESTURE_VC_FISTPUMP,	ACT_MP_GESTURE_VC_FISTPUMP_BUILDING,		false },
	{ ACT_MP_GESTURE_VC_THUMBSUP,	ACT_MP_GESTURE_VC_THUMBSUP_BUILDING,		false },
	{ ACT_MP_GESTURE_VC_NODYES,	ACT_MP_GESTURE_VC_NODYES_BUILDING,				false },
	{ ACT_MP_GESTURE_VC_NODNO,	ACT_MP_GESTURE_VC_NODNO_BUILDING,				false },
};

Activity CTFPlayerAnimState::ActivityOverride( Activity baseAct, bool *pRequired )
{
	acttable_t *pTable = NULL;
	int iActivityCount = 0;

	CTFPlayer *pPlayer = GetTFPlayer();

	// Override if we're in a kart
	if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		pTable = s_acttableKartState;
		iActivityCount = ARRAYSIZE( s_acttableKartState );
	}
	else
	{
		if ( pPlayer->m_Shared.InCond( TF_COND_COMPETITIVE_LOSER ) )
		{
			iActivityCount = ARRAYSIZE( s_acttableCompetitiveLoserState );
			pTable = s_acttableCompetitiveLoserState;
		}
		else if ( pPlayer->m_Shared.IsLoser() )
		{
			iActivityCount = ARRAYSIZE( s_acttableLoserState );
			pTable = s_acttableLoserState;
		}
		else if ( pPlayer->m_Shared.IsCarryingObject() )
		{
			iActivityCount = ARRAYSIZE( s_acttableBuildingDeployed );
			pTable = s_acttableBuildingDeployed;
		}
	}

	for ( int i = 0; i < iActivityCount; i++ )
	{
		const acttable_t& act = pTable[i];
		if ( baseAct == act.baseAct )
		{
			if (pRequired)
			{
				*pRequired = act.required;
			}
			return (Activity)act.weaponAct;
		}
	}

	return baseAct;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayerAnimState::ShouldUpdateAnimState( void )
{
	CTFPlayer *pTFPlayer = GetTFPlayer();
	if ( pTFPlayer )
	{
		// Stop animating if we have a custom player model that doesn't use the normal class animations
		if ( pTFPlayer->GetPlayerClass()->HasCustomModel() && !pTFPlayer->GetPlayerClass()->CustomModelUsesClassAnimations() )
			return false;
	}

	return BaseClass::ShouldUpdateAnimState();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::GetOuterAbsVelocity( Vector& vel )
{
#ifdef CLIENT_DLL
	if ( IsItemTestingBot() )
	{
		switch ( TFGameRules()->ItemTesting_GetBotAnim() )
		{
		default:
		case TI_BOTANIM_IDLE:
		case TI_BOTANIM_CROUCH:
		case TI_BOTANIM_JUMP:
			break;

		case TI_BOTANIM_CROUCH_WALK:
		case TI_BOTANIM_RUN:
			{
				QAngle angles( 0, 0, 0 );
				angles[YAW] = m_angRender[YAW];
				Vector vForward, vRight, vUp;
				AngleVectors( angles, &vForward, &vRight, &vUp );
				vel = vForward * GetCurrentMaxGroundSpeed();
			}
			break;
		}
		
		return;
	}
#endif

	BaseClass::GetOuterAbsVelocity( vel );
}

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

	// Get the TF player.
	CTFPlayer *pTFPlayer = GetTFPlayer();
	if ( !pTFPlayer )
		return;

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

	if ( pTFPlayer->GetPlayerClass()->HasCustomModel() )
	{
		if ( !pTFPlayer->GetPlayerClass()->CustomModelUsesClassAnimations() )
		{
			if ( pTFPlayer->GetPlayerClass()->CustomModelRotates() )
			{
				if ( pTFPlayer->GetPlayerClass()->CustomModelRotationSet() )
				{
					QAngle angRot = pTFPlayer->GetPlayerClass()->GetCustomModelRotation();
					m_angRender = angRot;
				}
				else
				{
					m_angRender = vec3_angle;
					m_angRender[YAW] = AngleNormalize( eyeYaw );
				}
			}

			// Restart our animation whenever we change models
			if ( pTFPlayer->GetPlayerClass()->CustomModelHasChanged() )
			{
				RestartMainSequence();
			}

			ClearAnimationState();
			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 );

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

	CTFPlayer *pTauntPartner = pTFPlayer->GetTauntPartner();

	Vector vPositionToFace = ( pTauntPartner ? pTauntPartner->GetAbsOrigin() : vec3_origin );
	bool bInTaunt = pTFPlayer->m_Shared.InCond( TF_COND_TAUNTING );
	bool bInKart = pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART );
	bool bIsImmobilized = bInTaunt || pTFPlayer->m_Shared.IsControlStunned();

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

		if ( bInTaunt )
		{
			// If you are forcing aim yaw, your code is almost definitely broken if you don't include a delay between 
			// teleporting and forcing yaw. This is due to an unfortunate interaction between the command lookback window,
			// and the fact that m_flEyeYaw is never propogated from the server to the client.
			// TODO: Fix this after Halloween 2014.
			m_bForceAimYaw = true;
			m_flEyeYaw = pTFPlayer->GetTauntYaw();

			Taunt_ComputePoseParam_MoveX( pStudioHdr );
			Taunt_ComputePoseParam_MoveY( pStudioHdr );
		}
		else if ( bInKart )
		{
			// If you are forcing aim yaw, your code is almost definitely broken if you don't include a delay between 
			// teleporting and forcing yaw. This is due to an unfortunate interaction between the command lookback window,
			// and the fact that m_flEyeYaw is never propogated from the server to the client.
			// TODO: Fix this after Halloween 2014.
			m_bForceAimYaw = true; // This makes it so our "legs" dont lag behind our eyes when standing still.
			Vehicle_ComputePoseParam_MoveYaw( pStudioHdr );
			Vehicle_ComputePoseParam_AccelLean( pStudioHdr );

			// Trace down a bit for the ground
			trace_t tr;
			//UTIL_TraceLine( pTFPlayer->GetAbsOrigin(), pTFPlayer->GetAbsOrigin() - Vector(0,0,20), MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
			UTIL_TraceLine( pTFPlayer->GetAbsOrigin(), pTFPlayer->GetAbsOrigin() - Vector(0,0,64), MASK_SOLID, pTFPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );

			// Use the ground normal if we hit, else abs up
			Vector vSurfaceNormal = tr.DidHit() ? tr.plane.normal : Vector( 0.f, 0.f, 1.f );

			// Have smoothed up approach the surface normal
			m_vecSmoothedUp[ 0 ] = Approach( vSurfaceNormal[ 0 ], m_vecSmoothedUp[ 0 ], 0.2f * gpGlobals->frametime );
			m_vecSmoothedUp[ 1 ] = Approach( vSurfaceNormal[ 1 ], m_vecSmoothedUp[ 1 ], 0.2f * gpGlobals->frametime );
			m_vecSmoothedUp[ 2 ] = Approach( vSurfaceNormal[ 2 ], m_vecSmoothedUp[ 2 ], 0.2f * gpGlobals->frametime );

			// Get player's forward
			Vector vOldForward;
			QAngle vTauntAngles = pTFPlayer->GetAbsAngles();
			vTauntAngles[ YAW ] = pTFPlayer->GetTauntYaw();
			AngleVectors( vTauntAngles, &vOldForward, NULL, NULL );

			// Construct basis
			Vector vRight = vOldForward.Cross( m_vecSmoothedUp );
			Vector vForward = m_vecSmoothedUp.Cross( vRight );
			// Set angles
			VectorAngles( vForward, m_vecSmoothedUp, m_angRender );

#if 0
			if ( tr.DidHit() )
			{
#ifdef GAME_DLL
				NDebugOverlay::Line( tr.endpos, tr.endpos + tr.plane.normal * 100, 255, 0, 0, true, 1.f );
				NDebugOverlay::Line( pTFPlayer->GetAbsOrigin(), pTFPlayer->GetAbsOrigin() + m_vecSmoothedUp * 100, 255, 0, 0, true, 1.f );
				NDebugOverlay::Line( pTFPlayer->GetAbsOrigin(), pTFPlayer->GetAbsOrigin() + vForward * 100, 255, 0, 0, true, 1.f );
#else
				NDebugOverlay::Line( tr.endpos, tr.endpos + tr.plane.normal * 100, 0, 0, 255, true, 1.f );
				NDebugOverlay::Line( pTFPlayer->GetAbsOrigin(), pTFPlayer->GetAbsOrigin() + m_vecSmoothedUp * 100, 0, 0, 255, true, 1.f );
				NDebugOverlay::Line( pTFPlayer->GetAbsOrigin(), pTFPlayer->GetAbsOrigin() + vForward * 100, 0, 0, 255, true, 1.f );
#endif
			}
#endif
		}
		else if ( TFGameRules()->PlayersAreOnMatchSummaryStage() )
		{
			m_bForceAimYaw = true;
			m_flEyeYaw = pTFPlayer->GetTauntYaw();
		}
		
		if ( !bIsImmobilized || bInTaunt || bInKart )
		{
			// Pose parameter - Torso aiming (up/down).
			ComputePoseParam_AimPitch( pStudioHdr );

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

#ifdef CLIENT_DLL 
	if ( C_BasePlayer::ShouldDrawLocalPlayer() )
	{
		GetBasePlayer()->SetPlaybackRate( 1.0f );
	}

	if ( IsItemTestingBot() )
	{
		GetBasePlayer()->SetPlaybackRate( TFGameRules()->ItemTesting_GetBotAnimSpeed() );
	}

#endif
}

//-----------------------------------------------------------------------------
// Updates animation state if we are throwing the passtime ball
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::CheckPasstimeThrowAnimation()
{
	CTFPlayer *pPlayer = GetTFPlayer();
	if ( !pPlayer )
	{
		return;
	}

	// FIXME: there must be a better way of doing this...
	CPasstimeGun *pGun = dynamic_cast< CPasstimeGun * >( pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_UTILITY ) );
	if ( !pGun )
	{
		return;
	}

	if ( pGun->GetCurrentCharge() > 0 ) 
	{
		if ( pPlayer->m_Shared.m_iPasstimeThrowAnimState == PASSTIME_THROW_ANIM_NONE )
		{
			int iSeq = pPlayer->SelectWeightedSequence( ACT_MP_PASSTIME_THROW_BEGIN );
			pPlayer->m_Shared.m_flPasstimeThrowAnimStateTime = gpGlobals->curtime + pPlayer->SequenceDuration( iSeq );
			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_PASSTIME_THROW_BEGIN );
			pPlayer->m_Shared.m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_LOOP;
		}
		else if ( pPlayer->m_Shared.m_iPasstimeThrowAnimState == PASSTIME_THROW_ANIM_LOOP )
		{
			if ( gpGlobals->curtime > pPlayer->m_Shared.m_flPasstimeThrowAnimStateTime )
			{
				int iSeq = pPlayer->SelectWeightedSequence( ACT_MP_PASSTIME_THROW_MIDDLE );
				pPlayer->m_Shared.m_flPasstimeThrowAnimStateTime = gpGlobals->curtime + pPlayer->SequenceDuration( iSeq );
				pPlayer->DoAnimationEvent( PLAYERANIMEVENT_PASSTIME_THROW_MIDDLE );
			}
		}
	}
	else // not charging
	{
		 if ( pPlayer->m_Shared.m_iPasstimeThrowAnimState == PASSTIME_THROW_ANIM_CANCEL )
		 {
			 pPlayer->DoAnimationEvent( PLAYERANIMEVENT_PASSTIME_THROW_CANCEL );
			 pPlayer->m_Shared.m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_NONE;
		 }
		 else if ( pPlayer->m_Shared.m_iPasstimeThrowAnimState == PASSTIME_THROW_ANIM_LOOP )
		 {
			 pPlayer->DoAnimationEvent( PLAYERANIMEVENT_PASSTIME_THROW_END );
			 int iSeq = pPlayer->SelectWeightedSequence( ACT_MP_PASSTIME_THROW_END );
			 pPlayer->m_Shared.m_flPasstimeThrowAnimStateTime = gpGlobals->curtime + pPlayer->SequenceDuration( iSeq );
			 pPlayer->m_Shared.m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_END;
		 }
		 else if ( pPlayer->m_Shared.m_iPasstimeThrowAnimState == PASSTIME_THROW_ANIM_END )
		 {
			 if ( gpGlobals->curtime > pPlayer->m_Shared.m_flPasstimeThrowAnimStateTime )
			 {
				 pPlayer->m_Shared.m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_NONE;
			 }
		 }
	}
}

//-----------------------------------------------------------------------------
// Purpose: Updates animation state if we're stunned.
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::CheckStunAnimation()
{
	CTFPlayer *pPlayer = GetTFPlayer();
	if ( !pPlayer )
		return;

	// do not play stun anims if in kart
	if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
		return;

	// State machine to determine the correct stun activity.
	if ( !pPlayer->m_Shared.IsControlStunned() && 
		 (pPlayer->m_Shared.m_iStunAnimState == STUN_ANIM_LOOP) )
	{
		// Clean up if the condition went away before we finished.
		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_STUN_END );
		pPlayer->m_Shared.m_iStunAnimState = STUN_ANIM_NONE;
	}
	else if ( pPlayer->m_Shared.IsControlStunned() &&
		      (pPlayer->m_Shared.m_iStunAnimState == STUN_ANIM_NONE) &&
		      (gpGlobals->curtime < pPlayer->m_Shared.GetStunExpireTime()) )
	{
		// Play the start up animation.
		int iSeq = pPlayer->SelectWeightedSequence( ACT_MP_STUN_BEGIN );
		pPlayer->m_Shared.m_flStunMid = gpGlobals->curtime + pPlayer->SequenceDuration( iSeq );
		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_STUN_BEGIN );
		pPlayer->m_Shared.m_iStunAnimState = STUN_ANIM_LOOP;
	}
	else if ( pPlayer->m_Shared.m_iStunAnimState == STUN_ANIM_LOOP )
	{
		// We are playing the looping part of the stun animation cycle.
		if ( gpGlobals->curtime > pPlayer->m_Shared.m_flStunFade )
		{
			// Gameplay is telling us to fade out. Time for the end anim.
			int iSeq = pPlayer->SelectWeightedSequence( ACT_MP_STUN_END );
			pPlayer->m_Shared.SetStunExpireTime( gpGlobals->curtime + pPlayer->SequenceDuration( iSeq ) );
			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_STUN_END );
			pPlayer->m_Shared.m_iStunAnimState = STUN_ANIM_END;
		}
		else if ( gpGlobals->curtime > pPlayer->m_Shared.m_flStunMid )
		{
			// Loop again.
			int iSeq = pPlayer->SelectWeightedSequence( ACT_MP_STUN_MIDDLE );
			pPlayer->m_Shared.m_flStunMid = gpGlobals->curtime + pPlayer->SequenceDuration( iSeq );
			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_STUN_MIDDLE );
		}
	}
	else if ( pPlayer->m_Shared.m_iStunAnimState == STUN_ANIM_END )
	{
		if ( gpGlobals->curtime > pPlayer->m_Shared.GetStunExpireTime() )
		{
			// The animation loop is over.
			pPlayer->m_Shared.m_iStunAnimState = STUN_ANIM_NONE;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Activity CTFPlayerAnimState::CalcMainActivity()
{
	CheckStunAnimation();
	CheckPasstimeThrowAnimation();

#ifdef CLIENT_DLL
	bool bIsAiming = m_pTFPlayer->m_Shared.IsAiming();

	if ( IsItemTestingBot() )
	{
		switch ( TFGameRules()->ItemTesting_GetBotAnim() )
		{
		default:
		case TI_BOTANIM_JUMP:
			break;

		case TI_BOTANIM_IDLE:
			if ( bIsAiming ) 
				return ACT_MP_DEPLOYED_IDLE;
			return ACT_MP_STAND_IDLE;

		case TI_BOTANIM_CROUCH:
			if ( bIsAiming ) 
				return ACT_MP_CROUCH_DEPLOYED_IDLE;
			return ACT_MP_CROUCH_IDLE;

		case TI_BOTANIM_CROUCH_WALK:
			if ( bIsAiming ) 
				return ACT_MP_CROUCH_DEPLOYED;
			return ACT_MP_CROUCHWALK;

		case TI_BOTANIM_RUN:
			if ( bIsAiming ) 
				return ACT_MP_DEPLOYED;
			return ACT_MP_RUN;
		}
	}
#endif

	return BaseClass::CalcMainActivity();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::ComputePoseParam_AimYaw( CStudioHdr *pStudioHdr )
{
	if ( IsItemTestingBot() )
	{
		if ( TFGameRules()->ItemTesting_GetBotViewScan() )
		{
			static float flDeltaYaw = 0.4f;
			static float flCurrentYaw = 0.0f;
			static float flDeltaPitch = 0.4f;
			static float flCurrentPitch = 0.0f;

			// Pan left & right
			flCurrentYaw = flCurrentYaw + ( flDeltaYaw * TFGameRules()->ItemTesting_GetBotAnimSpeed() );
			if ( fabs(flCurrentYaw) >= 45 )
			{
				flDeltaYaw *= -1;
			}
			flCurrentYaw = AngleNormalize( flCurrentYaw );
			GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimYaw, -flCurrentYaw );

			// Pan up & down
			flCurrentPitch = AngleNormalize( flCurrentPitch + ( flDeltaPitch * TFGameRules()->ItemTesting_GetBotAnimSpeed() ) );
			if ( fabs(flCurrentPitch) >= 150 )
			{
				flDeltaPitch *= -1;
			}
			flCurrentPitch = AngleNormalize( flCurrentPitch );
			flCurrentPitch = clamp(flCurrentPitch, -45.f, 90.f );
			GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimPitch, -flCurrentPitch );

			return;
		}

		// Rotating on the spot?
		if ( TFGameRules()->ItemTesting_GetBotTurntable() )
		{
			m_flGoalFeetYaw = m_flEyeYaw;
			m_flCurrentFeetYaw = m_flGoalFeetYaw;
			m_angRender[YAW] = m_flCurrentFeetYaw;
			float flAimYaw = m_flEyeYaw - m_flCurrentFeetYaw;
			flAimYaw = AngleNormalize( flAimYaw );
			GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimYaw, -flAimYaw );
			return;
		}
	}

	BaseClass::ComputePoseParam_AimYaw( pStudioHdr );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::Taunt_ComputePoseParam_MoveX( CStudioHdr *pStudioHdr )
{
	CTFPlayer *pTFPlayer = GetTFPlayer();
	if ( pTFPlayer->IsTaunting() && pTFPlayer->CanMoveDuringTaunt() )
	{
		int iMove = 0;
		iMove += pTFPlayer->m_nButtons & IN_FORWARD ? 1 : 0;
		iMove += pTFPlayer->m_nButtons & IN_BACK ? -1 : 0;

		float fl_move_x = 1.f;
		if ( pTFPlayer->GetTauntMoveAcceleration() > 0.f )
		{
			fl_move_x = Sign( iMove ) * ( gpGlobals->frametime / pTFPlayer->GetTauntMoveAcceleration() );
		}

		// turning?
		if ( iMove != 0.f )
		{
			m_flTauntMoveX = clamp( m_flTauntMoveX + fl_move_x, -1.f, 1.f );
		}
		else if ( m_flTauntMoveX != 0.f )
		{
			// smooth the value back to 0
			if ( m_flTauntMoveX < 0.f )
			{
				m_flTauntMoveX = clamp( m_flTauntMoveX + fabs( fl_move_x ), -1.f, 0.f );
			}
			if ( m_flTauntMoveX > 0.f )
			{
				m_flTauntMoveX = clamp( m_flTauntMoveX - fabs( fl_move_x ), 0.f, 1.f );
			}
		}
	}
	else
	{
		m_flTauntMoveX = 0.f;
	}

	pTFPlayer->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, Sign( m_flTauntMoveX ) * SimpleSpline( fabs( m_flTauntMoveX ) ) );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::Taunt_ComputePoseParam_MoveY( CStudioHdr *pStudioHdr )
{
	CTFPlayer *pTFPlayer = GetTFPlayer();
	if ( pTFPlayer->IsTaunting() && pTFPlayer->CanMoveDuringTaunt() )
	{
		float flTauntYawDiff = pTFPlayer->GetTauntYaw() - pTFPlayer->GetPrevTauntYaw();
		float fl_move_y = 1.f;
		if ( pTFPlayer->GetTauntTurnAccelerationTime() > 0.f )
		{
			fl_move_y = Sign( flTauntYawDiff ) * ( gpGlobals->frametime / pTFPlayer->GetTauntTurnAccelerationTime() );
		}

		// turning?
		if ( flTauntYawDiff != 0.f )
		{
			m_flTauntMoveY = clamp( m_flTauntMoveY + fl_move_y, -1.f, 1.f );
		}
		else if ( m_flTauntMoveY != 0.f )
		{
			// smooth the value back to 0
			if ( m_flTauntMoveY < 0.f )
			{
				m_flTauntMoveY = clamp( m_flTauntMoveY + fabs( fl_move_y ), -1.f, 0.f );
			}
			if ( m_flTauntMoveY > 0.f )
			{
				m_flTauntMoveY = clamp( m_flTauntMoveY - fabs( fl_move_y ), 0.f, 1.f );
			}
		}
	}
	else
	{
		m_flTauntMoveY = 0.f;
	}
	pTFPlayer->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, Sign( m_flTauntMoveY ) * SimpleSpline( fabs( m_flTauntMoveY ) ) );
}

extern ConVar tf_halloween_kart_slow_turn_accel_speed;
void CTFPlayerAnimState::Vehicle_ComputePoseParam_MoveYaw( CStudioHdr *pStudioHdr )
{
	float flValue = -m_pTFPlayer->m_Shared.GetVehicleTurnPoseAmount() / tf_halloween_kart_slow_turn_accel_speed.GetFloat();
	if ( m_pTFPlayer->GetTauntMoveSpeed() < 0.f )
	{
		flValue = -flValue;
	}

	flValue *= 0.5f;

#ifdef DEBUG
	#ifdef CLIENT_DLL
		engine->Con_NPrintf( 10, "CLIENT Pose: %3.2f", flValue );
	#else
		engine->Con_NPrintf( 11, "SERVER Pose: %3.2f", flValue );
	#endif
#endif

	m_pTFPlayer->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, flValue );
}

extern ConVar tf_halloween_kart_dash_speed;
extern ConVar tf_halloween_kart_brake_speed;

void CTFPlayerAnimState::Vehicle_ComputePoseParam_AccelLean( CStudioHdr *pStudioHdr )
{
	m_pTFPlayer->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, m_flVehicleLeanPos );
}

void CTFPlayerAnimState::Vehicle_LeanAccel( float flInAccel )
{
	// Accelerate our lean vel
	float flDiff = flInAccel - m_flVehicleLeanPos;
	float flAccel = 0.1f * flDiff - 1.5f * m_flVehicleLeanVel;
	m_flVehicleLeanVel += flAccel * gpGlobals->frametime;

	// Move our lean pos by our lean vel
	m_flVehicleLeanPos += m_flVehicleLeanVel * gpGlobals->frametime;
	// Decay it a bit
	m_flVehicleLeanPos -= m_flVehicleLeanPos * 0.1f;
	m_flVehicleLeanPos = clamp( m_flVehicleLeanPos, -1.f, 1.f );

#ifdef DEBUG
	#ifdef CLIENT_DLL
		engine->Con_NPrintf( 16, "CLIENT Acc: %.2f Vel: %.2f Pose: %.2f", flAccel, m_flVehicleLeanVel, m_flVehicleLeanPos );
	#else
		engine->Con_NPrintf( 17, "SERVER Acc: %.2f Vel: %.2f Pose: %.2f", flAccel, m_flVehicleLeanVel, m_flVehicleLeanPos );
	#endif
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::RestartGesture( int iGestureSlot, Activity iGestureActivity, bool bAutoKill )
{
	Activity translatedActivity = iGestureActivity;

	CTFPlayer *pPlayer = GetTFPlayer();
	if ( pPlayer )
	{
		// Allow the weapon to override the activity.
		CTFWeaponBase *pWeapon = pPlayer->GetActiveTFWeapon();

		if ( pWeapon )
		{
			CEconItemView *pWeaponEconItemView = pWeapon->GetAttributeContainer()->GetItem();
			if ( pWeaponEconItemView )
			{
				translatedActivity = pWeaponEconItemView->GetStaticData()->GetActivityOverride( pPlayer->GetTeamNumber(), translatedActivity );
			}
		}
	}

	BaseClass::RestartGesture( iGestureSlot, translatedActivity, bAutoKill );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : event - 
//-----------------------------------------------------------------------------
void CTFPlayerAnimState::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
	bool bInDuck = ( m_pTFPlayer->GetFlags() & FL_DUCKING ) ? true : false;
	if ( bInDuck && SelectWeightedSequence( TranslateActivity( ACT_MP_CROUCHWALK ) ) < 0 )
	{
		bInDuck = false;
	}

	Activity iGestureActivity = ACT_INVALID;

	switch( event )
	{
	case PLAYERANIMEVENT_ATTACK_PRIMARY:
		{
			CTFPlayer *pPlayer = GetTFPlayer();
			if ( !pPlayer )
				return;

			CTFWeaponBase *pWpn = pPlayer->GetActiveTFWeapon();
			bool bIsMinigun = ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_MINIGUN );
			bool bIsSniperRifle = ( pWpn && WeaponID_IsSniperRifleOrBow( pWpn->GetWeaponID() ) );

			// Heavy weapons primary fire.
			if ( bIsMinigun )
			{
				// Play standing primary fire.
				iGestureActivity = ACT_MP_ATTACK_STAND_PRIMARYFIRE;

				if ( m_bInSwim )
				{
					// Play swimming primary fire.
					iGestureActivity = ACT_MP_ATTACK_SWIM_PRIMARYFIRE;
				}
				else if ( bInDuck )
				{
					// Play crouching primary fire.
					iGestureActivity = ACT_MP_ATTACK_CROUCH_PRIMARYFIRE;
				}

				if ( !IsGestureSlotPlaying( GESTURE_SLOT_ATTACK_AND_RELOAD, TranslateActivity(iGestureActivity) ) )
				{
					RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, iGestureActivity );
				}
			}
			else if ( bIsSniperRifle && pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
			{
				// Weapon primary fire, zoomed in
				if ( bInDuck )
				{
					RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_ATTACK_CROUCH_PRIMARYFIRE_DEPLOYED );
				}
				else
				{
					RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_ATTACK_STAND_PRIMARYFIRE_DEPLOYED );
				}

				iGestureActivity = ACT_VM_PRIMARYATTACK;

				// Hold our deployed pose for a few seconds
				m_flHoldDeployedPoseUntilTime = gpGlobals->curtime + 2.0;
			}
			else
			{
				Activity baseActivity = bInDuck ? ACT_MP_ATTACK_CROUCH_PRIMARYFIRE : ACT_MP_ATTACK_STAND_PRIMARYFIRE;

				RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, baseActivity );
//				iGestureActivity = ACT_VM_PRIMARYATTACK;
			}

			break;
		}

	case PLAYERANIMEVENT_ATTACK_PRIMARY_SUPER:
		{
			Activity baseActivity = bInDuck ? ACT_MP_ATTACK_CROUCH_PRIMARY_SUPER : ACT_MP_ATTACK_STAND_PRIMARY_SUPER;

			if ( m_bInSwim )
				baseActivity = ACT_MP_ATTACK_SWIM_PRIMARY_SUPER;

			RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, baseActivity );
//			iGestureActivity = ACT_VM_PRIMARYATTACK;
		}
		break;

	case PLAYERANIMEVENT_VOICE_COMMAND_GESTURE:
		{
			if ( !IsGestureSlotActive( GESTURE_SLOT_ATTACK_AND_RELOAD ) )
			{
				RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, (Activity)nData );
			}
			break;
		}
	case PLAYERANIMEVENT_ATTACK_SECONDARY:
		{
			Activity baseActivity = bInDuck ? ACT_MP_ATTACK_CROUCH_SECONDARYFIRE : ACT_MP_ATTACK_STAND_SECONDARYFIRE;
			if ( GetBasePlayer()->GetWaterLevel() >= WL_Waist )
			{
				baseActivity = ACT_MP_ATTACK_SWIM_SECONDARYFIRE;
			}
			
			RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, baseActivity );
			iGestureActivity = ACT_VM_SECONDARYATTACK;
			break;
		}
	case PLAYERANIMEVENT_ATTACK_PRE:
		{
			CTFPlayer *pPlayer = GetTFPlayer();
			if ( !pPlayer )
				return;

			CTFWeaponBase *pWpn = pPlayer->GetActiveTFWeapon();
			bool bIsMinigun  = ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_MINIGUN );

			bool bAutoKillPreFire = false;
			if ( bIsMinigun )
			{
				bAutoKillPreFire = true;
			}

			if ( m_bInSwim && bIsMinigun )
			{
				// Weapon pre-fire. Used for minigun windup while swimming
				iGestureActivity = ACT_MP_ATTACK_SWIM_PREFIRE;
			}
			else if ( bInDuck ) 
			{
				// Weapon pre-fire. Used for minigun windup, sniper aiming start, etc in crouch.
				iGestureActivity = ACT_MP_ATTACK_CROUCH_PREFIRE;
			}
			else
			{
				// Weapon pre-fire. Used for minigun windup, sniper aiming start, etc.
				iGestureActivity = ACT_MP_ATTACK_STAND_PREFIRE;
			}

			RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, iGestureActivity, bAutoKillPreFire );

			break;
		}
	case PLAYERANIMEVENT_ATTACK_POST:
		{
			CTFPlayer *pPlayer = GetTFPlayer();
			if ( !pPlayer )
				return;

			CTFWeaponBase *pWpn = pPlayer->GetActiveTFWeapon();
			bool bIsMinigun  = ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_MINIGUN );

			if ( m_bInSwim && bIsMinigun )
			{
				// Weapon pre-fire. Used for minigun winddown while swimming
				iGestureActivity = ACT_MP_ATTACK_SWIM_POSTFIRE;
			}
			else if ( bInDuck ) 
			{
				// Weapon post-fire. Used for minigun winddown in crouch.
				iGestureActivity = ACT_MP_ATTACK_CROUCH_POSTFIRE;
			}
			else
			{
				// Weapon post-fire. Used for minigun winddown.
				iGestureActivity = ACT_MP_ATTACK_STAND_POSTFIRE;
			}

			RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, iGestureActivity );

			break;
		}

	case PLAYERANIMEVENT_RELOAD:
		{
			// Weapon reload.
			if ( m_bInAirWalk )
			{
				RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_AIRWALK );
			}
			else
			{
				BaseClass::DoAnimationEvent( event, nData );
			}
			break;
		}
	case PLAYERANIMEVENT_RELOAD_LOOP:
		{
			// Weapon reload.
			if ( m_bInAirWalk )
			{
				RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_AIRWALK_LOOP );
			}
			else
			{
				BaseClass::DoAnimationEvent( event, nData );
			}
			break;
		}
	case PLAYERANIMEVENT_RELOAD_END:
		{
			// Weapon reload.
			if ( m_bInAirWalk )
			{
				RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_AIRWALK_END );
			}
			else
			{
				BaseClass::DoAnimationEvent( event, nData );
			}
			break;
		}
	case PLAYERANIMEVENT_DOUBLEJUMP:
		{
			CTFPlayer *pPlayer = GetTFPlayer();
			if ( !pPlayer )
				return;

			// Check to see if we are jumping!
			if ( !m_bJumping )
			{
				m_bJumping = true;
				m_bFirstJumpFrame = true;
				m_flJumpStartTime = gpGlobals->curtime;
				RestartMainSequence();
			}

			// Force the air walk off.
			m_bInAirWalk = false;

			// Player the air dash gesture.
			if ( pPlayer->m_Shared.IsLoser() )
			{
				RestartGesture( GESTURE_SLOT_JUMP, ACT_MP_DOUBLEJUMP_LOSERSTATE );
			}
			else
			{
				RestartGesture( GESTURE_SLOT_JUMP, ACT_MP_DOUBLEJUMP );
			}
			break;
		}
	case PLAYERANIMEVENT_DOUBLEJUMP_CROUCH:
//		RestartGesture( GESTURE_SLOT_JUMP, ACT_MP_DOUBLEJUMP_CROUCH );
//		m_aGestureSlots[GESTURE_SLOT_JUMP].m_pAnimLayer->m_flBlendIn = 0.4f;
//		m_aGestureSlots[GESTURE_SLOT_JUMP].m_pAnimLayer->m_flBlendOut = 0.4f;
#ifdef CLIENT_DLL
//		m_aGestureSlots[GESTURE_SLOT_JUMP].m_pAnimLayer->m_bClientBlend = true;
#endif
		break;
	case PLAYERANIMEVENT_STUN_BEGIN:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_STUN_BEGIN, false );
		break;
	case PLAYERANIMEVENT_STUN_MIDDLE:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_STUN_MIDDLE, false );
		break;
	case PLAYERANIMEVENT_STUN_END:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_STUN_END );
		break;
	case PLAYERANIMEVENT_PASSTIME_THROW_BEGIN:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_PASSTIME_THROW_BEGIN, false );
		break;
	case PLAYERANIMEVENT_PASSTIME_THROW_MIDDLE:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_PASSTIME_THROW_MIDDLE, false );
		break;
	case PLAYERANIMEVENT_PASSTIME_THROW_END:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_PASSTIME_THROW_END );
		break;
	case PLAYERANIMEVENT_PASSTIME_THROW_CANCEL:
		RestartGesture( GESTURE_SLOT_CUSTOM, ACT_MP_PASSTIME_THROW_CANCEL );
		break;
	default:
		{
			BaseClass::DoAnimationEvent( event, nData );
			break;
		}
	}

#ifdef CLIENT_DLL
	// Make the weapon play the animation as well
	if ( iGestureActivity != ACT_INVALID )
	{
		CBaseCombatWeapon *pWeapon = GetTFPlayer()->GetActiveWeapon();
		if ( pWeapon )
		{
			pWeapon->SendWeaponAnim( iGestureActivity );
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *idealActivity - 
//-----------------------------------------------------------------------------
bool CTFPlayerAnimState::HandleSwimming( Activity &idealActivity )
{
	bool bInWater = BaseClass::HandleSwimming( idealActivity );

	if ( bInWater )
	{
		if ( m_pTFPlayer->m_Shared.IsAiming() )
		{
			CTFWeaponBase *pWpn = m_pTFPlayer->GetActiveTFWeapon();
			if ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_MINIGUN )
			{
				idealActivity = ACT_MP_SWIM_DEPLOYED;
			}
			// Check for sniper deployed underwater - should only be when standing on something
			else if ( pWpn && WeaponID_IsSniperRifle( pWpn->GetWeaponID() ) )
			{
				if ( m_pTFPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
				{
					idealActivity = ACT_MP_SWIM_DEPLOYED;
				}
			}
		}
	}

	return bInWater;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *idealActivity - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFPlayerAnimState::HandleMoving( Activity &idealActivity )
{
	float flSpeed = GetOuterXYSpeed();

	// If we move, cancel the deployed anim hold
	if ( flSpeed > MOVING_MINIMUM_SPEED )
	{
		m_flHoldDeployedPoseUntilTime = 0.0;
	}

	if ( m_pTFPlayer->m_Shared.IsLoser() )
	{
		return BaseClass::HandleMoving( idealActivity );
	}

	if ( m_pTFPlayer->m_Shared.IsAiming() ) 
	{
		if ( flSpeed > MOVING_MINIMUM_SPEED )
		{
			idealActivity = ACT_MP_DEPLOYED;
		}
		else
		{
			idealActivity = ACT_MP_DEPLOYED_IDLE;
		}
	}
	else if ( m_flHoldDeployedPoseUntilTime > gpGlobals->curtime )
	{
		// Unless we move, hold the deployed pose for a number of seconds after being deployed
		idealActivity = ACT_MP_DEPLOYED_IDLE;
	}
	else 
	{
		return BaseClass::HandleMoving( idealActivity );
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *idealActivity - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFPlayerAnimState::HandleDucking( Activity &idealActivity )
{
	bool bInDuck = ( m_pTFPlayer->GetFlags() & FL_DUCKING ) ? true : false;
	if ( bInDuck && SelectWeightedSequence( TranslateActivity( ACT_MP_CROUCHWALK ) ) < 0 && !m_pTFPlayer->m_Shared.IsLoser() )
	{
		bInDuck = false;
	}

	if ( bInDuck )
	{
		if ( GetOuterXYSpeed() < MOVING_MINIMUM_SPEED || m_pTFPlayer->m_Shared.IsLoser() )
		{
			idealActivity = ACT_MP_CROUCH_IDLE;		
			if ( m_pTFPlayer->m_Shared.IsAiming() || m_flHoldDeployedPoseUntilTime > gpGlobals->curtime )
			{
				idealActivity = ACT_MP_CROUCH_DEPLOYED_IDLE;
			}
		}
		else
		{
			if ( m_pTFPlayer->m_Shared.GetAirDash() > 0 )
			{
				idealActivity = ACT_MP_DOUBLEJUMP_CROUCH;
			}
			else
			{
				idealActivity = ACT_MP_CROUCHWALK;		
			}

			if ( m_pTFPlayer->m_Shared.IsAiming() )
			{
				// Don't do this for the heavy! we don't usually let him deployed crouch walk
				bool bIsMinigun = false;

				CTFPlayer *pPlayer = GetTFPlayer();
				if ( pPlayer && pPlayer->GetActiveTFWeapon() )
				{
					bIsMinigun = ( pPlayer->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_MINIGUN );
				}

				if ( !bIsMinigun )
				{
					idealActivity = ACT_MP_CROUCH_DEPLOYED;
				}
			}
		}

		return true;
	}
	
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayerAnimState::GetCurrentMaxGroundSpeed()
{
	float flSpeed = BaseClass::GetCurrentMaxGroundSpeed();

	if ( m_pTFPlayer->m_Shared.GetAirDash() > 0 )
	{
		return 1.f;
	}
	else
	{
		return flSpeed;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayerAnimState::GetGesturePlaybackRate( void )
{
	if ( IsItemTestingBot() )
		return TFGameRules()->ItemTesting_GetBotAnimSpeed();

	float flPlaybackRate = 1.f;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pTFPlayer, flPlaybackRate, mult_gesture_time );
	return flPlaybackRate;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayerAnimState::HandleJumping( Activity &idealActivity )
{
	bool bInDuck = ( m_pTFPlayer->GetFlags() & FL_DUCKING ) ? true : false;
	if ( bInDuck && SelectWeightedSequence( TranslateActivity( ACT_MP_CROUCHWALK ) ) < 0 )
	{
		bInDuck = false;
	}

	Vector vecVelocity;
	GetOuterAbsVelocity( vecVelocity );

	// Don't allow a firing heavy to jump or air walk.
	if ( m_pTFPlayer->GetPlayerClass()->IsClass( TF_CLASS_HEAVYWEAPONS ) && m_pTFPlayer->m_Shared.InCond( TF_COND_AIMING ) )
		return false;
		
	// Handle air walking before handling jumping - air walking supersedes jump
	TFPlayerClassData_t *pData = m_pTFPlayer->GetPlayerClass()->GetData();
	bool bValidAirWalkClass = ( pData && pData->m_bDontDoAirwalk == false );

	if ( bValidAirWalkClass && ( vecVelocity.z > 300.0f || m_bInAirWalk || m_pTFPlayer->GetGrapplingHookTarget() != NULL ) && !bInDuck )
	{
		// Check to see if we were in an airwalk and now we are basically on the ground.
		if ( ( GetBasePlayer()->GetFlags() & FL_ONGROUND ) && m_bInAirWalk )
		{				
			m_bInAirWalk = false;
			RestartMainSequence();
			RestartGesture( GESTURE_SLOT_JUMP, ACT_MP_JUMP_LAND );	
		}
		else if ( GetBasePlayer()->GetWaterLevel() >= WL_Waist )
		{
			// Turn off air walking and reset the animation.
			m_bInAirWalk = false;
			RestartMainSequence();
		}
		else if ( ( GetBasePlayer()->GetFlags() & FL_ONGROUND ) == 0 )
		{
			// In an air walk.
			idealActivity = ACT_MP_AIRWALK;
			m_bInAirWalk = true;
		}
	}
	// Jumping.
	else
	{
		if ( m_bJumping )
		{
			// Remove me once all classes are doing the new jump
			TFPlayerClassData_t *pDataJump = m_pTFPlayer->GetPlayerClass()->GetData();
			bool bNewJump = (pDataJump && pDataJump->m_bDontDoNewJump == false );

			if ( m_bFirstJumpFrame )
			{
				m_bFirstJumpFrame = false;
				RestartMainSequence();	// Reset the animation.
			}

			// Reset if we hit water and start swimming.
			if ( GetBasePlayer()->GetWaterLevel() >= WL_Waist )
			{
				m_bJumping = false;
				RestartMainSequence();
			}
			// 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.
			else if ( gpGlobals->curtime - m_flJumpStartTime > 0.2f )
			{
				if ( GetBasePlayer()->GetFlags() & FL_ONGROUND )
				{
					m_bJumping = false;
					RestartMainSequence();

					if ( bNewJump )
					{
						RestartGesture( GESTURE_SLOT_JUMP, ACT_MP_JUMP_LAND );					
					}
				}
			}

			// if we're still jumping
			if ( m_bJumping )
			{
				if ( bNewJump )
				{
					if ( gpGlobals->curtime - m_flJumpStartTime > 0.5 )
					{
						idealActivity = ACT_MP_JUMP_FLOAT;
					}
					else
					{
						idealActivity = ACT_MP_JUMP_START;
					}
				}
				else
				{
					idealActivity = ACT_MP_JUMP;
				}
			}
		}	
	}

	if ( m_bJumping || m_bInAirWalk )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayerAnimState::IsItemTestingBot( void )
{
	if ( TFGameRules()->IsInItemTestingMode() )
	{
		// Clients don't know what's a bot. Assume the first player is the non-bat.
		return ( m_pTFPlayer->entindex() > 1 );
	}
	return false;
}