Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1445 lines
44 KiB

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