source-engine/game/shared/tf/tf_weapon_passtime_gun.cpp

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

#include "cbase.h"
#include "tf_weapon_passtime_gun.h"
#include "passtime_convars.h"
#include "in_buttons.h"
#include "tf_gamerules.h"
#ifdef GAME_DLL
#include "tf_passtime_ball.h"
#include "tf_passtime_logic.h"
#include "tf_player.h"
#include "tf_playerclass.h"
#include "tf_team.h"
#include "tf_gamestats.h"
#else // !GAME_DLL
#include "c_tf_passtime_logic.h"
#include "c_tf_passtime_ball.h"
#include "tf_hud_passtime_reticle.h"
#include "tf_viewmodel.h"
#include "c_tf_player.h"
#include "prediction.h"
#endif
#include "tier0/memdbgon.h"

//-----------------------------------------------------------------------------
IMPLEMENT_NETWORKCLASS_ALIASED( PasstimeGun, DT_PasstimeGun )

//-----------------------------------------------------------------------------
BEGIN_NETWORK_TABLE( CPasstimeGun, DT_PasstimeGun )
#ifdef GAME_DLL
	SendPropInt( SENDINFO( m_eThrowState ) ),
	SendPropFloat( SENDINFO( m_fChargeBeginTime ) )
#else
	RecvPropInt( RECVINFO( m_eThrowState ) ),
	RecvPropFloat( RECVINFO( m_fChargeBeginTime ) )
#endif
END_NETWORK_TABLE()

//-----------------------------------------------------------------------------
BEGIN_PREDICTION_DATA( CPasstimeGun )
END_PREDICTION_DATA() // this has to be here because the client's precache code uses it to get the classname of this entity...

//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_weapon_passtime_gun, CPasstimeGun );
PRECACHE_WEAPON_REGISTER( tf_weapon_passtime_gun );

//-----------------------------------------------------------------------------
namespace
{
	static char const * const kChargeSound = "Passtime.GunCharge";
	static char const * const kTargetHightlightSound = "Passtime.TargetLock";
	static char const * const kShootOkSound = "Passtime.Throw";
	static char const * const kPassOkSound = "Passtime.Throw";
	static char const * const kHalloweenBallModel = "models/passtime/ball/passtime_ball_halloween.mdl";
}

//-----------------------------------------------------------------------------
CPasstimeGun::CPasstimeGun()
	: m_flTargetResetTime( 0 )
	, m_attack( IN_ATTACK )
	, m_attack2( IN_ATTACK2 )
{
	m_eThrowState = THROWSTATE_DISABLED;
#ifdef CLIENT_DLL
	m_pBounceReticle = 0;
#endif
}

//-----------------------------------------------------------------------------
void CPasstimeGun::Spawn()
{
	m_iClip1 = -1;
	m_flTargetResetTime = 0;
	BaseClass::Spawn();

#ifdef CLIENT_DLL
	SetNextClientThink( CLIENT_THINK_ALWAYS );
	if( !m_pBounceReticle )
		m_pBounceReticle = new C_PasstimeBounceReticle();
#endif
}

//-----------------------------------------------------------------------------
CPasstimeGun::~CPasstimeGun()
{
#ifdef CLIENT_DLL
	delete m_pBounceReticle;
#endif
}

//-----------------------------------------------------------------------------
void CPasstimeGun::Equip( CBaseCombatCharacter *pOwner )
{
	// NOTE: This is not called on the client.

	// IsMarkedForDeletion can happen if the gun deletes itself in Spawn
	if ( IsMarkedForDeletion() )
	{
		return;
	}

	BaseClass::Equip( pOwner );
}

//-----------------------------------------------------------------------------
void CPasstimeGun::Precache()
{
	PrecacheScriptSound( kTargetHightlightSound );
	PrecacheScriptSound( kShootOkSound );
	PrecacheScriptSound( kPassOkSound );
	PrecacheScriptSound( kChargeSound );
	m_iAttachmentIndex = PrecacheModel( tf_passtime_ball_model.GetString() );
	if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
	{
		m_iHalloweenAttachmentIndex = PrecacheModel( kHalloweenBallModel );
	}
	else
	{
		m_iHalloweenAttachmentIndex = -1;
	}

	BaseClass::Precache();
}

//-----------------------------------------------------------------------------
bool CPasstimeGun::CanHolster() const
{
	return !GetTFPlayerOwner()->m_Shared.HasPasstimeBall();
}

//-----------------------------------------------------------------------------
bool CPasstimeGun::Holster( CBaseCombatWeapon *pSwitchingTo )
{
	// WeaponReset will always be called too
	return BaseClass::Holster( pSwitchingTo );
}

//-----------------------------------------------------------------------------
void CPasstimeGun::WeaponReset()
{
	// this can happen when the weapon is holstered or not
	BaseClass::WeaponReset();

	if ( (m_eThrowState != THROWSTATE_DISABLED) && (m_eThrowState != THROWSTATE_IDLE) )
	{
		m_eThrowState = THROWSTATE_CANCELLED;
		m_attack2.LatchUp();
		m_attack.LatchUp();
	}

#ifdef CLIENT_DLL
	if ( m_pBounceReticle )
		m_pBounceReticle->Hide();
#endif

	CTFPlayer* pOwner = GetTFPlayerOwner();
	if ( pOwner )
		pOwner->m_Shared.SetPasstimePassTarget( 0 );

}

//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
void CPasstimeGun::UpdateAttachmentModels()
{
	BaseClass::UpdateAttachmentModels();

	auto *pTFPlayer = GetTFPlayerOwner();
	if ( !pTFPlayer )
		return;

	if ( !pTFPlayer->IsLocalPlayer() )
		return;

	if ( !pTFPlayer->GetViewModel() )
		return;

	auto *pViewmodelBall = GetViewmodelAttachment();
	if ( !pViewmodelBall )
		return;

	auto iActiveIndex = pViewmodelBall->GetModelIndex();
	if ( m_iHalloweenAttachmentIndex != -1 ) 
	{
		if ( iActiveIndex != m_iHalloweenAttachmentIndex )
		{
			pViewmodelBall->SetModelIndex( m_iHalloweenAttachmentIndex );
			m_bAttachmentDirty = true;
		}
	}
	else if ( iActiveIndex != m_iAttachmentIndex )
	{
		pViewmodelBall->SetModelIndex( m_iAttachmentIndex );
		m_bAttachmentDirty = true;
	}
}
#endif

//-----------------------------------------------------------------------------
bool CPasstimeGun::CanCharge() // const
{
	return tf_passtime_experiment_instapass.GetBool()
		&& tf_passtime_experiment_instapass_charge.GetBool();
}

//-----------------------------------------------------------------------------
float CPasstimeGun::GetChargeBeginTime() 
{
	return m_fChargeBeginTime;
}

//-----------------------------------------------------------------------------
float CPasstimeGun::GetChargeMaxTime() 
{ 
	return (tf_passtime_experiment_instapass.GetBool() && tf_passtime_experiment_instapass_charge.GetBool())
		? 3.0f
		: 0.0f;
}

//-----------------------------------------------------------------------------
float CPasstimeGun::GetCurrentCharge()
{ 
	if ( (m_eThrowState == THROWSTATE_CHARGING) || (m_eThrowState == THROWSTATE_CHARGED) )
		return clamp((gpGlobals->curtime - GetChargeBeginTime()) / GetChargeMaxTime(), 0.0f, 1.0f);
	return 0;
}



//-----------------------------------------------------------------------------
void CPasstimeGun::UpdateOnRemove()
{
#ifdef CLIENT_DLL
	delete m_pBounceReticle;
	m_pBounceReticle = 0;
#endif
	BaseClass::UpdateOnRemove();
}

//-----------------------------------------------------------------------------
bool CPasstimeGun::VisibleInWeaponSelection() 
{
	return false;
}

static acttable_t s_acttablePasstime[] = 
{
	{ ACT_MP_STAND_IDLE,		ACT_MP_STAND_PASSTIME,			false },
	{ ACT_MP_RUN,				ACT_MP_RUN_PASSTIME,				false },
	{ ACT_MP_CROUCHWALK,		ACT_MP_CROUCHWALK_PASSTIME,		false },

	// the previous are the only actual unique ones
	
	// following is a copy from tf_weaponbase.cpp
	//acttable_t s_acttableMeleeAllclass[] = 
	//{
		//{ ACT_MP_STAND_IDLE,		ACT_MP_STAND_MELEE_ALLCLASS,				false },
	{ ACT_MP_CROUCH_IDLE,		ACT_MP_CROUCH_MELEE_ALLCLASS,			false },
		//{ ACT_MP_RUN,				ACT_MP_RUN_MELEE_ALLCLASS,				false },
	{ ACT_MP_WALK,				ACT_MP_WALK_MELEE_ALLCLASS,				false },
	{ ACT_MP_AIRWALK,			ACT_MP_AIRWALK_MELEE_ALLCLASS,			false },
		//{ ACT_MP_CROUCHWALK,		ACT_MP_CROUCHWALK_MELEE_ALLCLASS,		false },
	{ ACT_MP_JUMP,				ACT_MP_JUMP_MELEE_ALLCLASS,				false },
	{ ACT_MP_JUMP_START,		ACT_MP_JUMP_START_MELEE_ALLCLASS,		false },
	{ ACT_MP_JUMP_FLOAT,		ACT_MP_JUMP_FLOAT_MELEE_ALLCLASS,		false },
	{ ACT_MP_JUMP_LAND,			ACT_MP_JUMP_LAND_MELEE_ALLCLASS,			false },
	{ ACT_MP_SWIM,				ACT_MP_SWIM_MELEE_ALLCLASS,				false },
	{ ACT_MP_DOUBLEJUMP_CROUCH,	ACT_MP_DOUBLEJUMP_CROUCH_MELEE,	false },

	{ ACT_MP_ATTACK_STAND_PRIMARYFIRE,		ACT_MP_ATTACK_STAND_MELEE_ALLCLASS,		false },
	{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE,		ACT_MP_ATTACK_CROUCH_MELEE_ALLCLASS,		false },
	{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE,		ACT_MP_ATTACK_SWIM_MELEE_ALLCLASS,		false },
	{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE,	ACT_MP_ATTACK_AIRWALK_MELEE_ALLCLASS,	false },

	{ ACT_MP_ATTACK_STAND_SECONDARYFIRE,	ACT_MP_ATTACK_STAND_MELEE_SECONDARY, false },
	{ ACT_MP_ATTACK_CROUCH_SECONDARYFIRE,	ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY,false },
	{ ACT_MP_ATTACK_SWIM_SECONDARYFIRE,		ACT_MP_ATTACK_SWIM_MELEE_ALLCLASS,		false },
	{ ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE,	ACT_MP_ATTACK_AIRWALK_MELEE_ALLCLASS,	false },

	{ ACT_MP_GESTURE_FLINCH,	ACT_MP_GESTURE_FLINCH_MELEE, false },

	{ ACT_MP_GRENADE1_DRAW,		ACT_MP_MELEE_GRENADE1_DRAW,	false },
	{ ACT_MP_GRENADE1_IDLE,		ACT_MP_MELEE_GRENADE1_IDLE,	false },
	{ ACT_MP_GRENADE1_ATTACK,	ACT_MP_MELEE_GRENADE1_ATTACK,	false },
	{ ACT_MP_GRENADE2_DRAW,		ACT_MP_MELEE_GRENADE2_DRAW,	false },
	{ ACT_MP_GRENADE2_IDLE,		ACT_MP_MELEE_GRENADE2_IDLE,	false },
	{ ACT_MP_GRENADE2_ATTACK,	ACT_MP_MELEE_GRENADE2_ATTACK,	false },

	{ ACT_MP_GESTURE_VC_HANDMOUTH,	ACT_MP_GESTURE_VC_HANDMOUTH_MELEE,	false },
	{ ACT_MP_GESTURE_VC_FINGERPOINT,	ACT_MP_GESTURE_VC_FINGERPOINT_MELEE,	false },
	{ ACT_MP_GESTURE_VC_FISTPUMP,	ACT_MP_GESTURE_VC_FISTPUMP_MELEE,	false },
	{ ACT_MP_GESTURE_VC_THUMBSUP,	ACT_MP_GESTURE_VC_THUMBSUP_MELEE,	false },
	{ ACT_MP_GESTURE_VC_NODYES,	ACT_MP_GESTURE_VC_NODYES_MELEE,	false },
	{ ACT_MP_GESTURE_VC_NODNO,	ACT_MP_GESTURE_VC_NODNO_MELEE,	false },
};


//-----------------------------------------------------------------------------
acttable_t* CPasstimeGun::ActivityList(int &iActivityCount)
{
	iActivityCount = ARRAYSIZE(s_acttablePasstime);
	return GetTFPlayerOwner() 
		? s_acttablePasstime 
		: BaseClass::ActivityList(iActivityCount);
}

//-----------------------------------------------------------------------------
void CPasstimeGun::AttackInputState::Update( int held, int pressed, int released )
{
	if ( eButtonState == BUTTONSTATE_DISABLED )
	{
		return;
	}

	// this exists so i don't have to do lots of confusing "if button pressed and my 
	// charge timer is < curtime and some other bullshit then do this thing unless some
	// other variable says do something else".
	// note: can go directly from RELEASED to PRESSED without visiting UP along the way

	const bool bPressed = (pressed & iButton) == iButton;
	const bool bReleased = (released & iButton) == iButton;
	const bool bHeld = (held & iButton) == iButton;

	// if it's latched up, just keep reporting UP until the player releases the button
	if ( bLatchedUp )
	{
		if ( !bReleased )
		{
			eButtonState = BUTTONSTATE_UP;
			return;
		}
		else 
		{
			bLatchedUp = false;
		}
	}

	if ( bPressed )
	{
		eButtonState = BUTTONSTATE_PRESSED;
	}
	else if ( bReleased )
	{
		eButtonState = BUTTONSTATE_RELEASED;
	}
	else if ( bHeld ) 
	{
		eButtonState = BUTTONSTATE_DOWN;
	}
	else 
	{
		eButtonState = BUTTONSTATE_UP;
	}
}

//-----------------------------------------------------------------------------
void CPasstimeGun::AttackInputState::LatchUp()
{
	// can't use input->ClearButton here because we need this to apply on the server
	bLatchedUp = true;
	if ( eButtonState != BUTTONSTATE_UP )
		eButtonState = BUTTONSTATE_RELEASED;
}

//-----------------------------------------------------------------------------
void CPasstimeGun::AttackInputState::UnlatchUp()
{
	bLatchedUp = false;
}

//-----------------------------------------------------------------------------
bool CPasstimeGun::SendWeaponAnim( int actBase )
{
	switch ( actBase )
	{
	case ACT_VM_IDLE: 
		actBase = ACT_BALL_VM_IDLE;
		break;
	}

	return BaseClass::SendWeaponAnim( actBase );
}

//-----------------------------------------------------------------------------
void CPasstimeGun::ItemPostFrame()
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
	{
		return;
	}

	bool bCanAttack2Cancel = !tf_passtime_experiment_autopass.GetBool();

#ifdef GAME_DLL

	//
	// Update pass target
	//
	if ( pOwner->m_Shared.HasPasstimeBall() )
	{
		VMatrix mWorldToView( SetupMatrixIdentity() );
		Vector vecEyePos;
		{
			Vector vecEyeDir;
			pOwner->EyePositionAndVectors( &vecEyePos, &vecEyeDir, 0, 0 );
			const QAngle &angEye = pOwner->EyeAngles();
			const VMatrix mTemp( SetupMatrixOrgAngles( vecEyePos, angEye ) );
			MatrixInverseTR( mTemp, mWorldToView );
		}

		//
		// If the current target is behind me, forget it immediately
		//
		auto *pCurrentTarget = ToTFPlayer( pOwner->m_Shared.GetPasstimePassTarget() );
		if ( pCurrentTarget )
		{
			Vector vLocalCurrentTarget( 0, 0, 0 ); // current target in local space
			Vector3DMultiplyPosition( mWorldToView, pCurrentTarget->WorldSpaceCenter(), vLocalCurrentTarget );
			if ( vLocalCurrentTarget.x < 0 ) // behind me
			{
				// clear the target
				pOwner->m_Shared.SetPasstimePassTarget( 0 );
				m_flTargetResetTime = 0;
			}
		}

		//
		// Look for a pass target
		//
		auto bAutoPassing = tf_passtime_experiment_autopass.GetBool() && m_attack2.Is( EButtonState::BUTTONSTATE_DOWN );
		auto flBestTargetDist = bAutoPassing ? FLT_MAX : 0.1f;
		CTFPlayer *pNewTarget = nullptr;
		auto flMaxPassDistSqr = g_pPasstimeLogic->GetMaxPassRange();
		flMaxPassDistSqr *= flMaxPassDistSqr;
		if ( !bCanAttack2Cancel || !m_attack2.Is( BUTTONSTATE_DOWN ) ) // right click prevents pass lock
		{
			//
			// Find a valid pass target that's close to the center of the screen
			// When autopassing is happening, it's just world distance instead of viewspace distance
			//
			for( int i = 1; i <= MAX_PLAYERS; i++ )
			{
				auto *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
				if ( pPlayer == pOwner )
					continue; // skip self

				if ( !BValidPassTarget( pOwner, pPlayer ) )
					continue;

				// Check world distance
				const auto &vTargetPos = pPlayer->WorldSpaceCenter();
				auto flThisTargetDist = vTargetPos.DistToSqr(vecEyePos);
				if ( flThisTargetDist > flMaxPassDistSqr ) 
					continue;

				// Check viewspace distance from crosshair when not autopassing
				if ( !bAutoPassing )
				{
					Vector vLocalTarget;
					Vector3DMultiplyPosition( mWorldToView, vTargetPos, vLocalTarget );

					if ( vLocalTarget.x < 0 )
						continue; // behind me

					flThisTargetDist = Vector( -vLocalTarget.y / vLocalTarget.x, -vLocalTarget.z / vLocalTarget.x, 0 ).Length(); // not aspect-correct
				}

				// check if closer than best
				if ( flThisTargetDist >= flBestTargetDist )
					continue; // too far 

				// pretend that people who are asking for the ball are closer, so they get priority
				// do this after the distance check 
				if ( pPlayer->m_Shared.AskForBallTime() > gpGlobals->curtime )
					flThisTargetDist /= 50.0f;

				// check for line of sight
				trace_t tr;
				UTIL_TraceLine( vecEyePos,	vTargetPos, MASK_PLAYERSOLID, pOwner, COLLISION_GROUP_PROJECTILE, &tr );
				if ( tr.m_pEnt != pPlayer )
					continue; // obstructed

				// success - new target
				flBestTargetDist = flThisTargetDist;
				pNewTarget = pPlayer;
			}
		}

		//
		// Replace the current pass target with a better one
		//
		if ( pNewTarget )
		{
			// Always bump the target reset time when the target is valid.
			// When the target isn't under the cursor anymore, the reset time will try to 
			// keep the lock for a short amount of time.
			m_flTargetResetTime = gpGlobals->curtime + tf_passtime_mode_homing_lock_sec.GetFloat();

			if ( pNewTarget != pCurrentTarget )
			{
				pOwner->m_Shared.SetPasstimePassTarget( pNewTarget );
				pCurrentTarget = pNewTarget;

				// play the lock-on sound for the player
				CRecipientFilter filter;
				filter.AddRecipient( pOwner );
				EmitSound( filter, pOwner->entindex(), kTargetHightlightSound );

				// now play it for the target
				filter.RemoveAllRecipients();
				filter.AddRecipient( pCurrentTarget );
				EmitSound( filter, pCurrentTarget->entindex(), kTargetHightlightSound );
			}
		}
		//
		// See if the current pass target is still valid
		//
		else if ( pCurrentTarget 
			&& (!BValidPassTarget( pOwner, pCurrentTarget ) 
				|| (bCanAttack2Cancel && m_attack2.Is( BUTTONSTATE_DOWN )) // right click prevents pass lock
				|| ((m_flTargetResetTime > 0 ) && (m_flTargetResetTime < gpGlobals->curtime))
				|| (pCurrentTarget->WorldSpaceCenter().DistToSqr( vecEyePos ) >= flMaxPassDistSqr) )
			&& !m_attack.Is( BUTTONSTATE_DOWN ) ) // left click prevents pass unlock
		{
			pOwner->m_Shared.SetPasstimePassTarget( 0 );
			m_flTargetResetTime = 0;
		}

		// autopass
		if ( tf_passtime_experiment_autopass.GetBool() 
			&& m_attack2.Is( EButtonState::BUTTONSTATE_DOWN ) 
			&& pOwner->m_Shared.GetPasstimePassTarget() )
		{
			// NOTE: change state after calling Throw
			Throw( pOwner );
			m_eThrowState = THROWSTATE_THROWN;
			m_attack2.LatchUp();
			m_attack.LatchUp();
		}
	}
	else
	{
		//
		// Not carrying the ball
		//
		pOwner->m_Shared.SetPasstimePassTarget( 0 );
		m_flTargetResetTime = 0;
	}
#endif

	//
	// Update throw state
	// Client and server both run this code; client predicts everything ideally, but there are some 
	// sketchy bits in here that probably don't predict right.
	//
	if ( pOwner->m_Shared.HasPasstimeBall() )
	{
		if ( (m_eThrowState == THROWSTATE_DISABLED) || (m_flNextPrimaryAttack > gpGlobals->curtime) || !CanAttack() )
		{
			// disable the attack input so the state will be correct when 
			// throwstate changes to not disabled
			m_attack.Disable();
			m_attack2.Disable();
		}
		else 
		{
			// update input
			m_attack.Enable();
			m_attack.Update( pOwner->m_nButtons, pOwner->m_afButtonPressed, pOwner->m_afButtonReleased );
			m_attack2.Enable();
			m_attack2.Update( pOwner->m_nButtons, pOwner->m_afButtonPressed, pOwner->m_afButtonReleased );

			if ( bCanAttack2Cancel && m_attack2.Is( BUTTONSTATE_PRESSED ) )
			{
				// check for cancelling attack by pressing attack2
				if ( (m_eThrowState == THROWSTATE_CHARGING) || (m_eThrowState == THROWSTATE_CHARGED) )
				{
#ifdef GAME_DLL
					++CTF_GameStats.m_passtimeStats.summary.nTotalThrowCancels;
#endif
					m_eThrowState = THROWSTATE_CANCELLED;
					m_attack2.LatchUp();
					m_attack.LatchUp();
				}
				else 
				{
					pOwner->DoClassSpecialSkill();
				}
			}

			switch( m_eThrowState )
			{
			case THROWSTATE_IDLE:
			{
				if ( m_attack.Is( BUTTONSTATE_PRESSED ) )
				{
					// note: should transition to CHARGING even if it will immediately finish charging
					m_eThrowState = THROWSTATE_CHARGING;
					m_fChargeBeginTime = gpGlobals->curtime;
					if ( GetChargeMaxTime() != 0 )
					{
						EmitSound( kChargeSound );
					}
					SendWeaponAnim( ACT_BALL_VM_THROW_START );
					m_flThrowLoopStartTime = gpGlobals->curtime + SequenceDuration();
				}
				else
				{
					m_fChargeBeginTime = 0;
					WeaponIdle();
				}
				break;
			}

			case THROWSTATE_CHARGING: 
			{
				if ( m_attack.Is( BUTTONSTATE_RELEASED ) )
				{
					// NOTE: change state after calling Throw
					Throw( pOwner );
					m_eThrowState = THROWSTATE_THROWN;
					break;
				}

				if ( m_flThrowLoopStartTime < gpGlobals->curtime )
				{
					m_flThrowLoopStartTime = FLT_MAX;
					SendWeaponAnim( ACT_BALL_VM_THROW_LOOP );
				}

				if ( (m_fChargeBeginTime <= 0) || (GetCurrentCharge() >= 1) )
				{
					m_eThrowState = THROWSTATE_CHARGED;
				}
				break;
			}

			case THROWSTATE_CHARGED:
			{
				if ( m_attack.Is( BUTTONSTATE_RELEASED ) )
				{
					// NOTE: change state after calling Throw
					Throw( pOwner );
					m_eThrowState = THROWSTATE_THROWN;
				}

				if ( m_flThrowLoopStartTime < gpGlobals->curtime )
				{
					m_flThrowLoopStartTime = FLT_MAX;
					SendWeaponAnim( ACT_BALL_VM_THROW_LOOP );
				}
				break;
			}

			case THROWSTATE_CANCELLED:
			{
				m_eThrowState = THROWSTATE_IDLE;
				SendWeaponAnim( ACT_BALL_VM_THROW_END );
				m_flThrowLoopStartTime = FLT_MAX;
				StopSound( kChargeSound );
#ifdef GAME_DLL
				CPASAttenuationFilter filter( pOwner );
				pOwner->EmitSound( filter, pOwner->entindex(), kShootOkSound );
#endif
				break;
			}

			case THROWSTATE_THROWN: 
			{
				// This means you got the ball between throwing it and holstering the gun.
				// Just do what Deploy does, roughly.
				m_eThrowState = THROWSTATE_IDLE;
				m_attack2.LatchUp();
				m_attack.LatchUp();
				break; 
			}

			case THROWSTATE_DISABLED: // should never get here
			default:
				Warning( "Invalid EThrowState value" );
			};
		}
	}

	//
	// If the player doesn't have the ball, switch to the previous
	// weapon at an appropriate time
	// if the ball was thrown, wait a bit for animation to look better
	//
	if ( !pOwner->m_Shared.HasPasstimeBall()
		&& ((m_eThrowState != THROWSTATE_THROWN) || (m_flNextPrimaryAttack <= gpGlobals->curtime)) )
	{
		// Setting m_eThrowState here fixes players getting stuck in the throw 
		// anim when they lose the ball while charging to throw. See GetChargeBeginTime
		// and CTFPlayerAnimState::CheckPasstimeThrowAnimation to see why.
		m_eThrowState = THROWSTATE_IDLE; 

		if ( !m_hStoredLastWpn || !pOwner->Weapon_Switch( m_hStoredLastWpn ) )
		{
			pOwner->SwitchToNextBestWeapon( this );
		}
	}

	// this SetWeaponVisible should go away once we have real animations. if you remove this, 
	// update the EF_NODRAW hack in CTFWeaponBase::OnDataChanged too
	SetWeaponVisible( pOwner->m_Shared.HasPasstimeBall() );

#ifdef CLIENT_DLL
	if ( m_attack.Is( BUTTONSTATE_DOWN ) )
	{
		pOwner->SetFiredWeapon( true ); // not sure what this does, exactly, but it seems important
	}
#endif
}

//-----------------------------------------------------------------------------
#ifdef GAME_DLL
static const char* IncomingSoundForClass( const CTFPlayerClass* pClass, char (&pszSound)[64] )
{
	// note: this will probably need to be replaced with response rules
	pszSound[0] = 0;
	switch ( pClass->GetClassIndex() )
	{
	case TF_CLASS_SCOUT: 
		V_sprintf_safe( pszSound, "Scout.Incoming0%i", RandomInt(1,3) );
		return pszSound;

    case TF_CLASS_SNIPER:
		V_sprintf_safe( pszSound, "Sniper.Incoming0%i", RandomInt(1,4) );
		return pszSound;

    case TF_CLASS_SOLDIER:
		V_sprintf_safe( pszSound, "Soldier.Incoming01" );
		return pszSound;

	case TF_CLASS_DEMOMAN:
		V_sprintf_safe( pszSound, "Demoman.Incoming0%i", RandomInt(1,3) );
		return pszSound;

	case TF_CLASS_MEDIC:
		V_sprintf_safe( pszSound, "Medic.Incoming0%i", RandomInt(1,3) );
		return pszSound;

	case TF_CLASS_HEAVYWEAPONS:
		V_sprintf_safe( pszSound, "Heavy.Incoming0%i", RandomInt(1,3) );
		return pszSound;

	case TF_CLASS_PYRO:
		V_sprintf_safe( pszSound, "Pyro.Incoming01" );
		return pszSound;

	case TF_CLASS_SPY:
		V_sprintf_safe( pszSound, "Spy.Incoming0%i", RandomInt(1,3) );
		return pszSound;

	case TF_CLASS_ENGINEER:		
		V_sprintf_safe( pszSound, "Engineer.Incoming0%i", RandomInt(1,3) );
		return pszSound;
	};

	return pszSound;
}
#endif

//-----------------------------------------------------------------------------
void CPasstimeGun::Throw( CTFPlayer *pOwner )
{
	StopSound( kChargeSound );
	pOwner->SetAnimation( PLAYER_ATTACK1 );
	pOwner->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRIMARY );
	SendWeaponAnim( ACT_BALL_VM_THROW_END );
	m_flThrowLoopStartTime = FLT_MAX;

	m_flLastFireTime = gpGlobals->curtime;
	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration(); // this prevents weapon switch until anim finishes
	m_flNextSecondaryAttack = m_flNextPrimaryAttack;

#ifdef GAME_DLL
	pOwner->NoteWeaponFired(); // not sure what this does, exactly, but it seems important 
	CTFPlayer *pPassTarget = pOwner->m_Shared.GetPasstimePassTarget();
	const LaunchParams& launch = CalcLaunch( pOwner, pPassTarget != 0 );
	g_pPasstimeLogic->LaunchBall( pOwner, launch.startPos, launch.startVel );

	CPASAttenuationFilter pasFilter( pOwner );
	pOwner->EmitSound( pasFilter, pOwner->entindex(), kShootOkSound );
	if ( pPassTarget )
	{
		++CTF_GameStats.m_passtimeStats.summary.nTotalPassesStarted;
		m_ballController.SetTargetSpeed( tf_passtime_mode_homing_speed.GetFloat() );
		auto isCharged = (m_fChargeBeginTime > 0) && (GetCurrentCharge() >= 1);
		m_ballController.StartHoming( g_pPasstimeLogic->GetBall(), pPassTarget, isCharged );
		if ( CTFPlayer *pPlayerPassTarget = ToTFPlayer( pPassTarget ) )
		{
			char pszSound[64];
			IncomingSoundForClass( pOwner->GetPlayerClass(), pszSound );
			{
				// for the thrower
				CRecipientFilter filter;
				filter.MakeReliable();
				filter.AddRecipient( pOwner );
				filter.AddRecipientsByTeam( TFTeamMgr()->GetTeam( TEAM_SPECTATOR ) );
				pOwner->EmitSound( filter, pOwner->entindex(), pszSound );
			}
			{
				// for the catcher
				CRecipientFilter filter;
				filter.MakeReliable();
				filter.AddRecipient( pPlayerPassTarget );
				pPlayerPassTarget->EmitSound( filter, pPlayerPassTarget->entindex(), pszSound );
			}
		}
	}
	else
	{
		++CTF_GameStats.m_passtimeStats.summary.nTotalTosses;
	}
#else
	pOwner->m_Shared.SetHasPasstimeBall( 0 ); // predict throwing
#endif

	pOwner->m_Shared.SetPasstimePassTarget( 0 );
}

//-----------------------------------------------------------------------------
void CPasstimeGun::ItemHolsterFrame()
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( pOwner && pOwner->m_Shared.HasPasstimeBall() )
	{
		m_hStoredLastWpn = GetTFPlayerOwner()->GetActiveWeapon();
		pOwner->Weapon_Switch( this );
	}
}

//-----------------------------------------------------------------------------
const char *CPasstimeGun::GetWorldModel() const
{
	if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
	{
		return kHalloweenBallModel;
	}
	return tf_passtime_ball_model.GetString();
}

//-----------------------------------------------------------------------------
bool CPasstimeGun::Deploy()
{
	// This is not called on the client because the client can't predict it.
	if ( !BaseClass::Deploy() )
	{
		return false;
	}
	
	m_eThrowState = THROWSTATE_IDLE;
	m_attack2.UnlatchUp();
	m_attack.UnlatchUp();
	return true;
}


//-----------------------------------------------------------------------------
bool CPasstimeGun::CanDeploy()
{
	CTFPlayer *pOwner = GetTFPlayerOwner();
	return pOwner && pOwner->m_Shared.HasPasstimeBall() && BaseClass::CanDeploy();
}

//-----------------------------------------------------------------------------
// static
bool CPasstimeGun::BValidPassTarget( CTFPlayer *pSource, CTFPlayer *pTarget, HudNotification_t *pReason )
{
	if ( pReason ) *pReason = (HudNotification_t) 0;

	if ( !pTarget || (pTarget == pSource) )
	{
		return false;
	}

	bool bTargetDisguised = pTarget->m_Shared.InCond( TF_COND_DISGUISED );
	int iTargetTeam = pTarget->GetTeamNumber();
	int iSourceTeam = pSource ? pSource->GetTeamNumber() : iTargetTeam;
	bool bSameTeam = iTargetTeam == iSourceTeam;
	bool bTargetableEnemySpy = !bSameTeam && bTargetDisguised && (pTarget->m_Shared.GetDisguiseTeam() == iSourceTeam);

	if ( !bSameTeam && !bTargetableEnemySpy )
	{
		// can't pass to enemies
		return false; 
	}
	else if ( bSameTeam && bTargetDisguised )
	{
		// can't pass to disguised friendly spies
		if ( bTargetDisguised && pReason )
		{
			*pReason = HUD_NOTIFY_PASSTIME_NO_DISGUISE;
		}
		return false;
	}

#ifdef CLIENT_DLL
	return g_pPasstimeLogic->BCanPlayerPickUpBall( pTarget );
#else
	return g_pPasstimeLogic->BCanPlayerPickUpBall( pTarget, pReason );
#endif
}

//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
void CPasstimeGun::UpdateThrowArch()
{
	C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
	if ( !pOwner )
	{
		return;
	}

	if ( !m_pBounceReticle )
	{
		m_pBounceReticle = new C_PasstimeBounceReticle();
	}

	if ( pOwner->m_Shared.GetPasstimePassTarget() )
	{
		m_pBounceReticle->Hide();
		return;
	}

	const LaunchParams& launchParams = CalcLaunch( pOwner, false );

	// Simple euler integration.
	// This seems to approximate what havok does reasonably accurately as long as there's no impact.
	Vector vecPos = launchParams.startPos;
	Vector vecVel = launchParams.startVel;

	const int iNumSuperSamples = 8;
	const float flDt = 1.0f / 16.0f / iNumSuperSamples;
	const Vector vecGravity_dt = flDt * Vector( 0, 0, -800 ); 
	const float flDamping_dt = flDt * tf_passtime_ball_damping_scale.GetFloat();

	Vector vecStart, vecEnd;
	trace_t tr;
	CTraceFilterSimple traceFilter( pOwner, COLLISION_GROUP_NONE );
	const int iMaxTraces = 100; // is this insane?
	for ( int iPoint = 0; iPoint < iMaxTraces; ++iPoint )
	{
		vecStart = vecPos;
		for ( int iSuperSample = 0; iSuperSample < iNumSuperSamples; ++iSuperSample )
		{
			vecVel += vecGravity_dt;
			vecVel -= vecVel * flDamping_dt;
			vecPos += vecVel * flDt;
		}
		vecEnd = vecPos;

		UTIL_TraceHull( vecStart, vecEnd, 
			-launchParams.traceHullSize, launchParams.traceHullSize, 
			MASK_PLAYERSOLID, &traceFilter, &tr );

		if ( tr.DidHit() )
		{	
			m_pBounceReticle->Show( tr.endpos, tr.plane.normal );
			break;

			// commented out code trying to guess bounce
			//vecVel = Lerp( tr.fraction, oldVel, vecVel ); // what vecVel was at point of impact, very roughly
			//vecPos = tr.endpos + tr.plane.normal; // move away from wall a bit
			//float speed = vecVel.NormalizeInPlace();
			//vecVel = -2 * vecVel.Dot( tr.plane.normal ) * tr.plane.normal + vecVel;
			//vecVel *= speed;
		}
	}

	if ( !tr.DidHit() )
	{
		m_pBounceReticle->Hide();
	}
}
#endif

//-----------------------------------------------------------------------------
//static 
CPasstimeGun::LaunchParams 
CPasstimeGun::LaunchParams::Default( CTFPlayer *pPlayer )
{
	LaunchParams p;
	pPlayer->EyePositionAndVectors( &p.eyePos, &p.viewFwd, &p.viewRight, &p.viewUp );
	const float size = tf_passtime_ball_sphere_radius.GetFloat() / 3.0f;
	p.traceHullSize = Vector( size, size, size );
	p.traceHullDistance = 8;
	p.startPos = pPlayer->Weapon_ShootPosition();
	p.startDir = p.viewFwd;
	p.startVel = p.startDir;
	return p;
}

//-----------------------------------------------------------------------------
static ConVar *s_pThrowSpeedConvars[TF_LAST_NORMAL_CLASS] = {
	nullptr, // TF_CLASS_UNDEFINED
	&tf_passtime_throwspeed_scout,
	&tf_passtime_throwspeed_sniper,
	&tf_passtime_throwspeed_soldier,
	&tf_passtime_throwspeed_demoman,
	&tf_passtime_throwspeed_medic,
	&tf_passtime_throwspeed_heavy,
	&tf_passtime_throwspeed_pyro,
	&tf_passtime_throwspeed_spy,
	&tf_passtime_throwspeed_engineer,
};

//-----------------------------------------------------------------------------
static ConVar *s_pThrowArcConvars[TF_LAST_NORMAL_CLASS] = {
	nullptr, // TF_CLASS_UNDEFINED
	&tf_passtime_throwarc_scout,
	&tf_passtime_throwarc_sniper,
	&tf_passtime_throwarc_soldier,
	&tf_passtime_throwarc_demoman,
	&tf_passtime_throwarc_medic,
	&tf_passtime_throwarc_heavy,
	&tf_passtime_throwarc_pyro,
	&tf_passtime_throwarc_spy,
	&tf_passtime_throwarc_engineer,
};

//-----------------------------------------------------------------------------
static void GetThrowParams( CTFPlayer *pPlayer, float *speed, float *arc )
{
	Assert( pPlayer && speed && arc );
	if ( !pPlayer ) return;

	auto iClass = pPlayer->GetPlayerClass()->GetClassIndex();
	if ( iClass <= TF_CLASS_UNDEFINED || iClass >= TF_LAST_NORMAL_CLASS ) 
	{
		if ( speed ) *speed = 1000.0f;
		if ( arc ) *arc = 0.3f;
	}
	else 
	{
		if ( speed ) *speed = s_pThrowSpeedConvars[iClass]->GetFloat();
		if ( arc ) *arc = s_pThrowArcConvars[iClass]->GetFloat();
	}
}

//-----------------------------------------------------------------------------
// static
CPasstimeGun::LaunchParams CPasstimeGun::CalcLaunch( CTFPlayer *pPlayer, bool bHoming )
{
	auto params = LaunchParams::Default( pPlayer );
	params.startPos = params.eyePos;

	if ( !bHoming )
	{
		float speed, arc;
		GetThrowParams( pPlayer, &speed, &arc );
		params.startVel = VectorLerp( params.startDir, Vector(0,0,1), arc );
		params.startVel.NormalizeInPlace();
		params.startVel *= speed;
	}
	else if ( !tf_passtime_experiment_autopass.GetBool() )
	{
		params.startVel = params.startDir * tf_passtime_mode_homing_speed.GetFloat();
	}
	else
	{
		params.startVel = Vector(0,0,0);
	}

	// mix in some amount of forward velocity
	auto fwdspeed = tf_passtime_throwspeed_velocity_scale.GetFloat() 
		* params.viewFwd.Dot( pPlayer->GetAbsVelocity() );
	VectorMAInline( params.startVel, fwdspeed, params.viewFwd, params.startVel );

	return params;
}

#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
void CPasstimeGun::ClientThink()
{
	if ( !IsActiveByLocalPlayer() && !IsLocalPlayerSpectator() )
	{
		if ( m_pBounceReticle )
		{
			m_pBounceReticle->Hide();
		}
		return;
	}

	// doing this in ItemPostFrame makes the position jittery for some reason, 
	// and doing it in ClientThink works better. Not entirely sure why, but I 
	// assume it's something to do with order of operations, or possibly prediction.
	if ( !IsLocalPlayerSpectator() && ((m_eThrowState == THROWSTATE_CHARGING) || (m_eThrowState == THROWSTATE_CHARGED)) )
	{
		UpdateThrowArch();
	}
	else if ( (IsLocalPlayerSpectator() || (m_eThrowState != THROWSTATE_THROWN)) && m_pBounceReticle )
	{
		m_pBounceReticle->Hide();
	}
}

#endif