source-engine/game/server/tf/tf_passtime_logic.cpp

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

#include "cbase.h"
#include "tf_passtime_logic.h"
#include "countdown_announcer.h"
#include "entity_passtime_ball_spawn.h"
#include "func_passtime_goal.h"
#include "func_passtime_no_ball_zone.h"
#include "tf_passtime_ball.h"
#include "passtime_ballcontroller.h"
#include "passtime_convars.h"
#include "passtime_game_events.h"
#include "func_passtime_goalie_zone.h"
#include "tf_player.h"
#include "tf_team.h"
#include "tf_gamestats.h"
#include "tf_gamerules.h"
#include "pathtrack.h"
#include "tf_fx.h"
#include "tf_weapon_passtime_gun.h"
#include "team_objectiveresource.h"
#include "mapentities.h"
#include "soundenvelope.h"
#include "eventqueue.h"
#include "hl2orange.spa.h" // achievement defines from tf_shareddefs depend on this
#include "tier0/memdbgon.h"

CTFPasstimeLogic *g_pPasstimeLogic;

#ifdef _DEBUG
#define SECRETROOM_LOG Warning
#else
#define SECRETROOM_LOG (void)
#endif

//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( passtime_logic, CTFPasstimeLogic );
PRECACHE_REGISTER( passtime_logic );
IMPLEMENT_SERVERCLASS_ST( CTFPasstimeLogic, DT_TFPasstimeLogic )
	SendPropEHandle( SENDINFO( m_hBall ) ),
	SendPropArray( SendPropVector( SENDINFO_ARRAY( m_trackPoints ), -1, SPROP_COORD_MP_INTEGRAL ), m_trackPoints ),
	SendPropInt( SENDINFO( m_iNumSections ) ),
	SendPropInt( SENDINFO( m_iCurrentSection ) ),
	SendPropFloat( SENDINFO( m_flMaxPassRange ) ),
	SendPropInt( SENDINFO( m_iBallPower ), 8 ),
	SendPropFloat( SENDINFO( m_flPackSpeed ) ),
	SendPropArray3( SENDINFO_ARRAY3( m_bPlayerIsPackMember ), SendPropInt( SENDINFO_ARRAY( m_bPlayerIsPackMember ), 1, SPROP_UNSIGNED ) ),
END_SEND_TABLE()

//-----------------------------------------------------------------------------
BEGIN_DATADESC( CTFPasstimeLogic )
	DEFINE_KEYFIELD( m_iNumSections, FIELD_INTEGER, "num_sections" ),
	DEFINE_KEYFIELD( m_iBallSpawnCountdownSec, FIELD_INTEGER, "ball_spawn_countdown" ),
	DEFINE_KEYFIELD( m_flMaxPassRange, FIELD_FLOAT, "max_pass_range" ),

	DEFINE_INPUTFUNC( FIELD_VOID, "SpawnBall", InputSpawnBall ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetSection", InputSetSection ),
	DEFINE_INPUTFUNC( FIELD_VOID, "TimeUp", InputTimeUp ),
	DEFINE_INPUTFUNC( FIELD_VOID, "SpeedBoostUsed", InputSpeedBoostUsed ),
	DEFINE_INPUTFUNC( FIELD_VOID, "JumpPadUsed", InputJumpPadUsed ),
	
	// secret room inputs
	// these strings are obfuscated for fun, not for protection
	DEFINE_INPUTFUNC( FIELD_VOID, "statica", statica ), // SecretRoom_InputStartTouchPlayerSlot NOTE: intentionally not in FGD
	DEFINE_INPUTFUNC( FIELD_VOID, "staticb", staticb ), // SecretRoom_InputEndTouchPlayerSlot NOTE: intentionally not in FGD
	DEFINE_INPUTFUNC( FIELD_VOID, "staticc", staticc ), // SecretRoom_InputPlugDamaged NOTE: intentionally not in FGD
	DEFINE_INPUTFUNC( FIELD_VOID, "RoomTriggerOnTouch", InputRoomTriggerOnTouch ),

	DEFINE_OUTPUT( m_onBallFree, "OnBallFree" ),
	DEFINE_OUTPUT( m_onBallGetBlu, "OnBallGetBlu" ),
	DEFINE_OUTPUT( m_onBallGetRed, "OnBallGetRed" ),
	DEFINE_OUTPUT( m_onBallGetAny, "OnBallGetAny" ),
	DEFINE_OUTPUT( m_onBallRemoved, "OnBallRemoved" ),
	DEFINE_OUTPUT( m_onScoreBlu, "OnScoreBlu" ),
	DEFINE_OUTPUT( m_onScoreRed, "OnScoreRed" ),
	DEFINE_OUTPUT( m_onScoreAny, "OnScoreAny" ),
	DEFINE_OUTPUT( m_onBallPowerUp, "OnBallPowerUp" ),
	DEFINE_OUTPUT( m_onBallPowerDown, "OnBallPowerDown" ),
END_DATADESC()

//-----------------------------------------------------------------------------
static const CCountdownAnnouncer::TimeSounds sCountdownSoundsRoundBegin = {
	"Announcer.RoundBegins60seconds",
	"Announcer.RoundBegins30seconds",
	"Announcer.RoundBegins10seconds",
	"Announcer.RoundBegins5seconds",
	"Announcer.RoundBegins4seconds",
	"Announcer.RoundBegins3seconds",
	"Announcer.RoundBegins2seconds",
	"Announcer.RoundBegins1seconds",
};

//-----------------------------------------------------------------------------
static const CCountdownAnnouncer::TimeSounds sCountdownSoundsRoundBeginMerasmus = {
	"Announcer.RoundBegins60seconds",
	"Announcer.RoundBegins30seconds",
	"Announcer.RoundBegins10seconds",
	"Merasmus.RoundBegins5seconds",
	"Merasmus.RoundBegins4seconds",
	"Merasmus.RoundBegins3seconds",
	"Merasmus.RoundBegins2seconds",
	"Merasmus.RoundBegins1seconds",
};

//-----------------------------------------------------------------------------
static bool IsGamestatePlayable()
{
	gamerules_roundstate_t state = TFGameRules()->State_Get();
	return (state == GR_STATE_RND_RUNNING) || (state == GR_STATE_STALEMATE);
}

//-----------------------------------------------------------------------------
CPasstimeBall *CTFPasstimeLogic::GetBall() const { return m_hBall; }

//-----------------------------------------------------------------------------
CTFPasstimeLogic::CTFPasstimeLogic() 
{ 
	m_SecretRoom_pTv = nullptr;
	m_SecretRoom_pTvSound = nullptr;
	m_SecretRoom_state = SecretRoomState::None;
	memset( m_SecretRoom_slottedPlayers, 0, sizeof( m_SecretRoom_slottedPlayers ) );

	m_flNextCrowdReactionTime = 0.0f;
	m_nPackMemberBits = 0;
	m_nPrevPackMemberBits = 0;
}

//-----------------------------------------------------------------------------
CTFPasstimeLogic::~CTFPasstimeLogic() 
{
	// note:
	// it doesn't seem possible on the server that this destructor would be called
	// after a new CTFPasstimeLogic is spawned, and it's worked fine so far, but
	// this has been a problem in the client code.
	g_pPasstimeLogic = NULL;
	delete m_pRespawnCountdown;
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Spawn()
{
	g_pPasstimeLogic = this;
	m_iBallSpawnCountdownSec = MAX( 1, m_iBallSpawnCountdownSec );
	if ( m_flMaxPassRange == 0 )
	{
		m_flMaxPassRange = FLT_MAX;
	}

	for ( int i = 0; i < m_bPlayerIsPackMember.Count(); ++i )
	{
		m_bPlayerIsPackMember.Set( i, 0 );
	}

	for ( int i = 0; i < m_trackPoints.Count(); ++i )
	{
		m_trackPoints.GetForModify(i).Zero();
	}

	const auto *pCountdownSounds = TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween )
		? &sCountdownSoundsRoundBeginMerasmus
		: &sCountdownSoundsRoundBegin;
	m_pRespawnCountdown = new CCountdownAnnouncer( pCountdownSounds );

	SetContextThink( &CTFPasstimeLogic::PostSpawn, gpGlobals->curtime, "postspawn" );
	SetContextThink( &CTFPasstimeLogic::BallPower_PackHealThink, gpGlobals->curtime + 1, "packheal" );

	ListenForGameEvent( "teamplay_round_stalemate" );
	ListenForGameEvent( "teamplay_setup_finished" );
}

//------------------------------------------------------------------------------
// Purpose: Utility function for hooking up entity connections from code.
// Would belong in BaseEnity, but this this hacky so I'm just hiding it here.
//------------------------------------------------------------------------------
static CBaseEntityOutput *FindOutput( CBaseEntity *pEnt, const char *pOutputName )
{
	if ( !pEnt || !pOutputName || !pOutputName[0] )
	{
		return nullptr;
	}

	// loop taken from ValidateEntityConnections
	datamap_t *dmap = pEnt->GetDataDescMap();
	while ( dmap )
	{
		int fields = dmap->dataNumFields;
		for ( int i = 0; i < fields; i++ )
		{
			typedescription_t *dataDesc = &dmap->dataDesc[i];
			if ( ( dataDesc->fieldType == FIELD_CUSTOM ) 
				&& ( dataDesc->flags & FTYPEDESC_OUTPUT ) 
				&& !strcmp( dataDesc->externalName, pOutputName ) )
			{
				return (CBaseEntityOutput *)((intptr_t)pEnt + (int)dataDesc->fieldOffset[0]);
			}
		}
		dmap = dmap->baseMap;
	}

	return nullptr;
}

//------------------------------------------------------------------------------
// Purpose: Utility function for hooking up entity connections from code.
// Would belong in BaseEnity, but this this hacky so I'm just hiding it here.
//------------------------------------------------------------------------------
static void HookOutput( const char *pSourceName, string_t pTargetName, 
	const char *pOutputName, const char *pInputName, 
	const char *pParameter = nullptr, int nTimesToFire = EVENT_FIRE_ALWAYS )
{
	Assert( pSourceName && pSourceName[0] );
	Assert( pTargetName.ToCStr() && pTargetName.ToCStr()[0] );
	CBaseEntity *pEnt = gEntList.FindEntityByName( nullptr, pSourceName );
	if ( !pEnt )
	{
		Warning( "Entity %s missing", pSourceName );
		return;
	}

	CBaseEntityOutput *pOut = FindOutput( pEnt, pOutputName );
	if ( !pOut )
	{
		Warning( "Entity %s missing output %s", pSourceName, pOutputName );
		return;
	}

	CEventAction *pAction = new CEventAction();
	pAction->m_iTarget = pTargetName;
	pAction->m_iTargetInput = AllocPooledString( pInputName );
	pAction->m_nTimesToFire = nTimesToFire;
	pAction->m_iParameter = pParameter 
		? AllocPooledString( pParameter ) 
		: string_t();
	pOut->AddEventAction( pAction );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::PostSpawn()
{
	// This can't be done in spawn because GetTeamNumber doesn't return the
	// correct value for any entity until after it's been Activate()d, which
	// happens after all the Spawns. And it can't be done in Activate() because
	// the order of Activation seems kinda non-deterministic.
	const auto &goals = CFuncPasstimeGoal::GetAutoList();

	if ( ( m_iNumSections == 0 ) && ( goals.Count() == 2 ) )
	{
		// FIXME support > 2 goals properly
		CFuncPasstimeGoal *pRed = static_cast<CFuncPasstimeGoal *>( goals[0] );
		CFuncPasstimeGoal *pBlu = static_cast<CFuncPasstimeGoal *>( goals[1] );
		if ( pRed->GetTeamNumber() != TF_TEAM_BLUE ) // goal's color is who can score there
		{
			V_swap( pRed, pBlu );
		}
		m_trackPoints.Set( 0, pBlu->GetAbsOrigin() );
		m_trackPoints.Set( 1, pRed->GetAbsOrigin() );
		m_iNumSections = 1;
	}

	//
	// Determine goal type for stats
	//
	int nTotalEndzone = 0;
	int nTotalBasket = 0;
	for ( const auto *pGoalNode : goals )
	{
		const auto *pGoal = (const CFuncPasstimeGoal *)pGoalNode;
		if ( !pGoal->BDisableBallScore() )
		{
			++nTotalBasket;
		}
		if ( pGoal->BEnablePlayerScore() )
		{
			++nTotalEndzone;
		}
	}
	if ( nTotalBasket && !nTotalEndzone )
	{
		CTF_GameStats.m_passtimeStats.summary.nGoalType = 1;
	}
	else if ( !nTotalBasket && nTotalEndzone )
	{
		CTF_GameStats.m_passtimeStats.summary.nGoalType = 2;
	}
	else
	{
		CTF_GameStats.m_passtimeStats.summary.nGoalType = 3;
	}

	CTF_GameStats.m_passtimeStats.summary.nRoundMaxSec = TFGameRules()->GetActiveRoundTimer()->GetTimerInitialLength();

	// These used to happen from teamplay_setup_ended, but that event doesn't happen if there's no setup time
	// These functions should be able to determine whether or not to actually do anything based on game state
	SetContextThink( &CTFPasstimeLogic::BallHistSampleThink, gpGlobals->curtime, "BallHistSampleThink" );
	SetContextThink( &CTFPasstimeLogic::OneSecStatsUpdateThink, gpGlobals->curtime, "OneSecStatsUpdateThink" );

	BallPower_PowerThink();
	BallPower_PackThink();

	// secret room puzzle
	if ( !V_stricmp( gpGlobals->mapname.ToCStr(), "pass_brickyard" ) )
	{
		SecretRoom_Spawn();
	}
}

//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::AddBallPower( int iPower )
{
	int iThreshold = tf_passtime_powerball_threshold.GetInt();
	bool bWasAboveThreshold = m_iBallPower > iThreshold;
	m_iBallPower = clamp( m_iBallPower + iPower, 0, 100 );
	bool bIsAboveThreshold = m_iBallPower > iThreshold;
	if ( bWasAboveThreshold && !bIsAboveThreshold ) 
	{
		m_onBallPowerDown.FireOutput( this, this );
		TFGameRules()->BroadcastSound( 255, "Powerup.Reflect.Reflect" );
		return true;
	}
	else if ( !bWasAboveThreshold && bIsAboveThreshold )
	{
		m_onBallPowerUp.FireOutput( this, this );
		TFGameRules()->BroadcastSound( 255, "Powerup.Volume.Use" );

		// reschedule think so that decay stops for a while
		SetContextThink( &CTFPasstimeLogic::BallPower_PowerThink, 
			gpGlobals->curtime + tf_passtime_powerball_decay_delay.GetFloat(),
			"BallPower_PowerThink" );

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::ClearBallPower()
{
	AddBallPower( -m_iBallPower );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::BallPower_PowerThink()
{
	CPasstimeBall *pBall = GetBall();
	if ( !IsGamestatePlayable() || !pBall )
	{
		SetContextThink( &CTFPasstimeLogic::BallPower_PowerThink, 
			gpGlobals->curtime, "BallPower_PowerThink" );
		return;
	}

	float flTickTime = (pBall->GetTeamNumber() == TEAM_UNASSIGNED)
		? tf_passtime_powerball_decaysec_neutral.GetFloat()
		: tf_passtime_powerball_decaysec.GetFloat();

	SetContextThink( &CTFPasstimeLogic::BallPower_PowerThink,
		gpGlobals->curtime + flTickTime, "BallPower_PowerThink" );


	if ( !pBall->GetHomingTarget() )
	{
		AddBallPower( -tf_passtime_powerball_decayamount.GetInt() );
	}
}

//-----------------------------------------------------------------------------
static uint64 CalcPackMemberBits( CTFPlayer *pBallCarrier ) 
{
	if ( !pBallCarrier || !pBallCarrier->IsAlive() ) 
	{
		return 0;
	}

	float flPackRangeSqr = tf_passtime_pack_range.GetFloat();
	flPackRangeSqr *= flPackRangeSqr;
	int iCarrierTeam = pBallCarrier->GetTeamNumber();
	Vector vecCarrierPos = pBallCarrier->GetAbsOrigin();
	uint64 nNewPackMemberBits = 0;
	uint64 nMask = 1;
	for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
	{
		CTFPlayer *pPlayer = (CTFPlayer*) UTIL_PlayerByIndex( i );

		// must be a valid team member within range
		if ( !pPlayer
			|| !pPlayer->IsAlive()
			|| ( pPlayer->GetTeamNumber() != iCarrierTeam )
			|| ( pPlayer->GetAbsOrigin().DistToSqr( vecCarrierPos ) > flPackRangeSqr ) )
		{
			continue;
		}

		// must not be aiming (heavy spin, sniper scope, etc)
		if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) )
		{
			continue;
		}

		nNewPackMemberBits |= nMask;
	}
	return nNewPackMemberBits;
}

//-----------------------------------------------------------------------------
static void SetSpeedOnFlaggedPlayers( uint64 playerBits )
{
	if ( playerBits == 0 )
	{
		return;
	}

	uint64 nMask = 1;
	for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
	{
		if ( playerBits & nMask )
		{
			CTFPlayer *pPlayer = (CTFPlayer*)UTIL_PlayerByIndex( i );
			if ( pPlayer && pPlayer->IsAlive() )
			{
				pPlayer->TeamFortress_SetSpeed();
			}
		}
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::ReplicatePackMemberBits()
{
	uint64 nMask = 1;
	for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
	{
		m_bPlayerIsPackMember.Set( i, ( m_nPackMemberBits & nMask ) ? 1 : 0 );
	}
}

//-----------------------------------------------------------------------------
// solo carrier is marked for death
// any close teammate (2x cart distance) removes marked for death
// close teammates are sped up to fastest teammate speed
void CTFPasstimeLogic::BallPower_PackThink()
{
	SetContextThink( &CTFPasstimeLogic::BallPower_PackThink, 
		gpGlobals->curtime, "BallPower_PackThink" );

	m_flPackSpeed = 0.0f;
	m_nPrevPackMemberBits = m_nPackMemberBits;
	m_nPackMemberBits = 0;

	CTFPlayer *pCarrier = GetBallCarrier();

	// Check if pack speed is active
	if ( !tf_passtime_pack_speed.GetBool() || !IsGamestatePlayable() || !pCarrier )
	{
		m_nPackMemberBits = 0; // redundant assignment for clarity
		ReplicatePackMemberBits();
		SetSpeedOnFlaggedPlayers( m_nPrevPackMemberBits );
		return;
	}

	// Find the pack members
	m_nPackMemberBits = CalcPackMemberBits( pCarrier );
	ReplicatePackMemberBits();
	
	// Find the maximum MaxSpeed of the pack
	bool bHasNearbyTeammate = false;
	float flMaxMaxSpeed = -1;
	uint64 nMask = 1;
	for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
	{
		if ( m_nPackMemberBits & nMask )
		{
			CTFPlayer *pPlayer = (CTFPlayer*)UTIL_PlayerByIndex( i );
			if ( pPlayer && pPlayer->IsAlive() )
			{
				bHasNearbyTeammate = bHasNearbyTeammate || ( pPlayer != pCarrier );
				flMaxMaxSpeed = MAX( flMaxMaxSpeed, pPlayer->TeamFortress_CalculateMaxSpeed() );
			}
		}
	}

	// Apply marked for death if no teammates
	if ( !bHasNearbyTeammate )
	{
		pCarrier->m_Shared.AddCond( TF_COND_PASSTIME_PENALTY_DEBUFF, TICK_INTERVAL * 2 );
	}
	else
	{
		m_flPackSpeed = flMaxMaxSpeed;
	}

	// Now tell all the relevant players to refresh their maxspeed
	SetSpeedOnFlaggedPlayers( m_nPackMemberBits | m_nPrevPackMemberBits );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::BallPower_PackHealThink()
{
	SetContextThink( &CTFPasstimeLogic::BallPower_PackHealThink, gpGlobals->curtime + 1, "packheal" );

	CTFPlayer *pCarrier = GetBallCarrier();
	if ( !pCarrier )
	{
		return;
	}

	uint64 nMask = 1;
	uint64 nPackMemberBits = m_nPackMemberBits;
	float flHealAmount = tf_passtime_pack_hp_per_sec.GetFloat();
	for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
	{
		if ( ( nPackMemberBits & nMask ) == 0 )
		{
			continue;
		}

		CTFPlayer *pPlayer = (CTFPlayer*)UTIL_PlayerByIndex( i );
		if ( !pPlayer || ( pPlayer == pCarrier ) || !pPlayer->IsAlive() )
		{
			continue;
		}

		int iActualHealAmount = pPlayer->TakeHealth( flHealAmount, DMG_GENERIC );
		if ( iActualHealAmount <= 0 )
		{
			continue;
		}

		// I'm abusing the player_healonhit event because it does the visual fx I want
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_healonhit" );
		if ( pEvent )
		{
			pEvent->SetInt( "amount", iActualHealAmount );
			pEvent->SetInt( "entindex", pPlayer->entindex() );
			gameeventmanager->FireEvent( pEvent ); 
		}
	}
}

//-----------------------------------------------------------------------------
float CTFPasstimeLogic::GetPackSpeed( CTFPlayer *pPlayer ) const
{
	if ( pPlayer )
	{
		uint64 nMask = (uint64)1 << ( pPlayer->entindex() - 1 );
		if ( m_nPackMemberBits & nMask )
		{
			return m_flPackSpeed;
		}
	}
	return 0;
}


//-----------------------------------------------------------------------------
void CTFPasstimeLogic::FireGameEvent( IGameEvent *pEvent ) 
{
	const char *pEventName = pEvent->GetName();
	if ( !V_strcmp( pEventName, "teamplay_round_stalemate" ) )
	{
		// this only happens when mp_stalemate_enable is on
		CTF_GameStats.m_passtimeStats.summary.nRoundMaxSec = 
			TFGameRules()->GetActiveRoundTimer()->GetTimeRemaining();
		RespawnBall();
	}
	else if ( !V_strcmp( pEventName, "teamplay_setup_finished" ) )
	{
		// respawn the ball even though it already exists so that it doesn't
		// catch any rotation from any spawn box it might be sitting in that
		// hasn't opened yet.
		SpawnBallAtRandomSpawner();
	}
}

//-----------------------------------------------------------------------------
// FIXME copypasta with tf_hud_passtime.cpp
// For stats
float CTFPasstimeLogic::CalcProgressFrac() const
{
	if ( !GetBall() || (m_iNumSections == 0) )
	{
		return 0;
	}

	//
	// Which point are we trying to classify?
	//
	Vector vecOrigin;
	{
		CPasstimeBall *pBall = GetBall();
		CTFPlayer *pCarrier = pBall->GetCarrier();
		vecOrigin = pCarrier 
			? pCarrier->GetAbsOrigin()
			: pBall->GetAbsOrigin();
	}

	// 
	// Find distance along track from first goal to last goal
	//
	float flBestLen = 0;
	float flTotalLen = 1; // don't set 0 so div by zero is impossible
	{
		float flBestDist = FLT_MAX;

		Vector vecThisPoint;
		Vector vecPointOnLine;
		Vector vecPrevPoint = m_trackPoints[0];
		float flThisFrac = 0;
		float flThisLen = 0;
		float flThisDist = 0;
		for ( int i = 1; i < 16; ++i )
		{
			vecThisPoint = m_trackPoints[i];
			if ( vecThisPoint.IsZero() )
			{
				break;
			}
			flThisLen = (vecThisPoint - vecPrevPoint).Length();
			flTotalLen += flThisLen;
			CalcClosestPointOnLineSegment( vecOrigin, vecPrevPoint, vecThisPoint, vecPointOnLine, &flThisFrac );
			flThisDist = (vecPointOnLine - vecOrigin).Length();
			if ( flThisDist < flBestDist )
			{
				flBestDist = flThisDist;
				flBestLen = flTotalLen - (flThisLen * (1.0f - flThisFrac));
			}
			vecPrevPoint = vecThisPoint;
		}
	}

	return (float)(flBestLen / flTotalLen);
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::BallHistSampleThink()
{
	CPasstimeBall *pBall = m_hBall;
	if ( IsGamestatePlayable() && pBall && !pBall->BOutOfPlay() )
	{
		CTF_GameStats.m_passtimeStats.AddBallFracSample( CalcProgressFrac() );
	}

	SetContextThink( &CTFPasstimeLogic::BallHistSampleThink, gpGlobals->curtime + 0.125f, "BallHistSampleThink" );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OneSecStatsUpdateThink()
{
	CTFTeam *pBlue = GetGlobalTFTeam( TF_TEAM_BLUE );
	CTFTeam *pRed = GetGlobalTFTeam( TF_TEAM_RED );

	// FIXME this is a hack but it'll work for now
	CTF_GameStats.m_passtimeStats.summary.nPlayersBlueMax = MAX( CTF_GameStats.m_passtimeStats.summary.nPlayersBlueMax, pBlue->GetNumPlayers() );
	CTF_GameStats.m_passtimeStats.summary.nPlayersRedMax = MAX( CTF_GameStats.m_passtimeStats.summary.nPlayersRedMax, pRed->GetNumPlayers() );
	
	SetContextThink( &CTFPasstimeLogic::OneSecStatsUpdateThink, gpGlobals->curtime + 1, "OneSecStatsUpdateThink" );
}

//-----------------------------------------------------------------------------
static void MapEventStat( CBaseEntity *pActivator, CPasstimeBall *pBall, int *pTotal, int *pCarrierTotal )
{
	CTFPlayer *pPlayer = ToTFPlayer( pActivator );
	if ( pPlayer )
	{
		++(*pTotal);
		if ( pBall && (pBall->GetCarrier() == pPlayer) )
		{
			++(*pCarrierTotal);
		}
	}
}

//-----------------------------------------------------------------------------
CTFPlayer *CTFPasstimeLogic::GetBallCarrier() const
{
	const CPasstimeBall *pBall = m_hBall.Get();
	if ( !pBall )
	{
		return nullptr;
	}
	return pBall->GetCarrier();
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputSpeedBoostUsed( inputdata_t &input )
{
	MapEventStat( input.pActivator, GetBall(), 
		&CTF_GameStats.m_passtimeStats.summary.nTotalSpeedBoosts,
		&CTF_GameStats.m_passtimeStats.summary.nTotalCarrierSpeedBoosts );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputJumpPadUsed( inputdata_t &input )
{
	MapEventStat( input.pActivator, GetBall(), 
		&CTF_GameStats.m_passtimeStats.summary.nTotalJumpPads,
		&CTF_GameStats.m_passtimeStats.summary.nTotalCarrierJumpPads );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Precache()
{
	PrecacheScriptSound( "Passtime.BallIntercepted" );
	PrecacheScriptSound( "Passtime.BallStolen" );
	PrecacheScriptSound( "Passtime.BallDropped" );
	PrecacheScriptSound( "Passtime.BallCatch" );
	PrecacheScriptSound( "Passtime.BallSpawn" );

	PrecacheScriptSound( "Passtime.Crowd.Boo" );
	PrecacheScriptSound( "Passtime.Crowd.Cheer" );
	PrecacheScriptSound( "Passtime.Crowd.React.Neg" );
	PrecacheScriptSound( "Passtime.Crowd.React.Pos" );

	PrecacheScriptSound( "Powerup.Reflect.Reflect" ); // for powerball
	PrecacheScriptSound( "Powerup.Volume.Use" );

	PrecacheScriptSound( "Announcer.RoundBegins60seconds");
	PrecacheScriptSound( "Announcer.RoundBegins30seconds");
	PrecacheScriptSound( "Announcer.RoundBegins10seconds");

	if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) ) 
	{
		PrecacheScriptSound( "Merasmus.RoundBegins5seconds");
		PrecacheScriptSound( "Merasmus.RoundBegins4seconds");
		PrecacheScriptSound( "Merasmus.RoundBegins3seconds");
		PrecacheScriptSound( "Merasmus.RoundBegins2seconds");
		PrecacheScriptSound( "Merasmus.RoundBegins1seconds");

		PrecacheScriptSound( "sf14.Merasmus.Soccer.GoalRed" );
		PrecacheScriptSound( "sf14.Merasmus.Soccer.GoalBlue" );
		PrecacheScriptSound( "Passtime.Merasmus.Laugh" );
	}
	else
	{
		PrecacheScriptSound( "Announcer.RoundBegins5seconds");
		PrecacheScriptSound( "Announcer.RoundBegins4seconds");
		PrecacheScriptSound( "Announcer.RoundBegins3seconds");
		PrecacheScriptSound( "Announcer.RoundBegins2seconds");
		PrecacheScriptSound( "Announcer.RoundBegins1seconds");
	}

	PrecacheScriptSound( "Game.Overtime");
	PrecacheScriptSound( "Passtime.AskForBall" );

	// secret room stuff
	if ( !V_stricmp( gpGlobals->mapname.ToCStr(), "pass_brickyard" ) )
	{
		PrecacheScriptSound( "Passtime.Tv1" );
		PrecacheScriptSound( "Passtime.Tv2" );
		PrecacheScriptSound( "Passtime.Tv3" );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnEnterGoal( CPasstimeBall *pBall, CFuncPasstimeGoal *pGoal )
{
	if ( pGoal->BDisableBallScore() || !IsGamestatePlayable() )
	{
		return;
	}

	// -1 iPoints is a special hacked value that means "kill zone"
	if ( pGoal->Points() == -1 ) 
	{
		m_onBallRemoved.FireOutput( pGoal, pGoal );
		SetContextThink( &CTFPasstimeLogic::RespawnBall, gpGlobals->curtime, "spawnball" );
		return;
	}

	if ( (pBall->GetCollisionCount() > 0) || (pBall->GetTeamNumber() == TEAM_UNASSIGNED) )
	{
		return;
	}

	CTFPlayer *pOwner = pBall->GetThrower();
	if ( pOwner && (pBall->GetTeamNumber() == pGoal->GetTeamNumber()) )
	{
		Score( pBall, pGoal );
	}
}


//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnEnterGoal( CTFPlayer *pPlayer, CFuncPasstimeGoal *pGoal )
{
	if ( IsGamestatePlayable() 
		&& pGoal->BEnablePlayerScore()
		&& pPlayer->m_Shared.HasPasstimeBall() 
		&& (pPlayer->GetTeamNumber() == pGoal->GetTeamNumber()) )
	{
		Score( pPlayer, pGoal );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnExitGoal( CPasstimeBall *pBall, CFuncPasstimeGoal *pGoal )
{
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnStayInGoal( CTFPlayer *pPlayer, CFuncPasstimeGoal *pGoal ) 
{
	OnEnterGoal( pPlayer, pGoal );
}

//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::OnBallCollision( CPasstimeBall *pBall, int index, gamevcollisionevent_t *pEvent )
{
	if ( !IsGamestatePlayable() )
	{
		return false;
	}

	// FIXME
	//if ( pBall && pBall->BAnyControllerApplied() )
	//{
	//	return false;
	//}

	return true;
}

//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::BCanPlayerPickUpBall( CTFPlayer *pPlayer, HudNotification_t *pReason ) const
{
	if ( pReason ) *pReason = (HudNotification_t) 0;

	const auto *pBall = m_hBall.Get();
	if ( !pBall ) 
	{ 
		return false; 
	}

	if ( !pPlayer || !IsGamestatePlayable() )
	{
		return false;
	}

	if ( pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE ) 
		|| pPlayer->m_Shared.InCond( TF_COND_PHASE ) 
		|| pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_INVULN;
		return false;
	}

	if ( pPlayer->m_Shared.IsStealthed() )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_CLOAK;
		return false;
	}

	// let disguised spies pick up enemy ball, which amounts to interception and fake passes
	auto bEnemyBall = ( pBall->GetTeamNumber() != TEAM_UNASSIGNED )
		&& ( pBall->GetTeamNumber() != pPlayer->GetTeamNumber() );
	if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && !bEnemyBall )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_DISGUISE;
		return false;
	}

	if ( pPlayer->m_Shared.IsCarryingObject() ) 
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_CARRY;
		return false;
	}

	if ( pPlayer->m_Shared.InCond( TF_COND_SELECTED_TO_TELEPORT ) )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_TELE;
		return false;
	}

	if ( pPlayer->IsTaunting() )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_TAUNT;
		return false;
	}

	if ( !pPlayer->IsAllowedToPickUpFlag()
		|| !pPlayer->IsAlive() // NOTE: it's possible to be !alive and !dead at the same time
		|| pPlayer->IsAwayFromKeyboard()
		|| pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE )
		|| pPlayer->m_Shared.IsControlStunned() )
	{
		return false;
	}

	if ( pPlayer->m_bIsTeleportingUsingEurekaEffect )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_TELE;
		return false;
	}

	CTFWeaponBase *pActiveWeapon = pPlayer->GetActiveTFWeapon();
	if ( pActiveWeapon )
	{
		bool bCanHolster = pActiveWeapon->CanHolster()
			&& !( pActiveWeapon->IsReloading() && pActiveWeapon->ReloadsSingly() && pActiveWeapon->CanOverload() ); // semihack to fix beggars bazooka problems
		if ( pActiveWeapon && ( pActiveWeapon->GetWeaponID() != TF_WEAPON_PASSTIME_GUN ) && !bCanHolster )
		{
			if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_HOLSTER;
			return false;
		}
	}

	if ( EntityIsInNoBallZone( pPlayer ) )
	{
		if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_OOB;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
int CTFPasstimeLogic::UpdateTransmitState()
{
	return SetTransmitState( FL_EDICT_ALWAYS );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::RespawnBall()
{
	Assert( m_hBall );
	if ( !m_hBall ) // paranoia
	{
		return;
	}

	ClearBallPower();

	// TFGameRules only checks capture limit once per second, so this code can't rely on game state changing
	int iScoreLimit = tf_passtime_scores_per_round.GetInt();
	bool bGameOver = ( TFTeamMgr()->GetFlagCaptures( TF_TEAM_RED ) >= iScoreLimit )
		|| ( TFTeamMgr()->GetFlagCaptures( TF_TEAM_BLUE ) >= iScoreLimit );

	gamerules_roundstate_t state = TFGameRules()->State_Get();
	if ( bGameOver || (state == GR_STATE_GAME_OVER) || (state == GR_STATE_TEAM_WIN) || (state == GR_STATE_RESTART) )
	{
		m_hBall->SetStateOutOfPlay();
		MoveBallToSpawner();
	}
	else if ( (state == GR_STATE_RND_RUNNING) || (state == GR_STATE_STALEMATE) )
	{
		// TODO just end the game if there's not enough time to respawn the ball
		m_hBall->SetStateOutOfPlay();
		MoveBallToSpawner();
		CTeamRoundTimer *pTimer = TFGameRules()->GetActiveRoundTimer();
		if ( !pTimer || ( pTimer->GetTimeRemaining() > m_iBallSpawnCountdownSec ) )
		{
			m_pRespawnCountdown->Start( m_iBallSpawnCountdownSec );
			SpawnBallAtRandomSpawnerThink();
		}
	}
	else // pre-round etc
	{
		SpawnBallAtRandomSpawner(); 
	}

	m_ballLastHeldTimes.RemoveAll();
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SpawnBallAtRandomSpawnerThink()
{
	if ( TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
	{
		m_hBall->SetStateOutOfPlay();
		m_pRespawnCountdown->Disable();
	}
	else if ( m_pRespawnCountdown->Tick( 1 ) )
	{
		SpawnBallAtRandomSpawner();
	}
	else
	{
		SetContextThink( &CTFPasstimeLogic::SpawnBallAtRandomSpawnerThink, gpGlobals->curtime + 1, "spawnball" );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SpawnBallAtRandomSpawner()
{
	const auto &allSpawns = IPasstimeBallSpawnAutoList::AutoList();
	int i = RandomInt( 0, allSpawns.Count() - 1 );
	CPasstimeBallSpawn *pSpawner = static_cast< CPasstimeBallSpawn *>( allSpawns[i] );	
	SpawnBallAtSpawner( pSpawner );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::MoveBallToSpawner()
{
	const auto &allSpawns = IPasstimeBallSpawnAutoList::AutoList();
	int i = RandomInt( 0, allSpawns.Count() - 1 );
	CPasstimeBallSpawn *pSpawner = static_cast< CPasstimeBallSpawn *>( allSpawns[i] );	
	m_hBall->MoveTo( pSpawner->GetAbsOrigin(), Vector( 0, 0, 0 ) );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SpawnBallAtSpawner( CPasstimeBallSpawn *pSpawner )
{
	if ( !m_hBall )
	{
		// NOTE: this is the first place where the ball is created - on first spawn
		m_hBall = CPasstimeBall::Create( pSpawner->GetAbsOrigin(), QAngle(0,0,0) );
	}

	StopAskForBallEffects();
	m_hBall->SetStateFree();
	m_hBall->MoveToSpawner( pSpawner->GetAbsOrigin() );
	m_hBall->ChangeTeam( pSpawner->GetTeamNumber() );
	m_onBallFree.FireOutput( m_hBall, this );
	pSpawner->m_onSpawnBall.FireOutput( pSpawner, pSpawner );

	TFGameRules()->BroadcastSound( 255, "Passtime.BallSpawn" );
	if ( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
	{
		TFGameRules()->BroadcastSound( 255, "Passtime.Merasmus.Laugh" );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::StopAskForBallEffects()
{
	for( int i = 1; i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer )
		{
			pPlayer->m_Shared.SetAskForBallTime( 0 );
		}
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnBallCarrierMeleeHit( CTFPlayer *pPlayer, CTFPlayer *pAttacker ) 
{
	// TODO refactor OnBallCarrierMeleeHit and OnBallCarrierDamaged for less copypasta

	if ( !pPlayer || !pAttacker || (pPlayer == pAttacker) || !TFGameRules() )
	{
		// shouldn't happen, but who knows
		return;
	}

	Assert( pPlayer->m_Shared.HasPasstimeBall() );
	if ( !pPlayer->m_Shared.HasPasstimeBall() ) 
	{ 
		return; 
	}

	if ( !pPlayer->InSameTeam( pAttacker) )
	{
		// currently handled by OnBallCarrierDamaged
		return;
	}

	Assert( m_hBall );
	if( !m_hBall )
	{
		return;
	}

	bool bTooLong = (m_hBall->GetCarryDuration() > tf_passtime_teammate_steal_time.GetFloat());
	if ( pPlayer->m_bPasstimeBallSlippery || bTooLong )
	{
		// once a player has held the ball too long, mark them as a jerk
		// so they can't hoard the ball ever again
		StealBall( pPlayer, pAttacker );
		pPlayer->m_bPasstimeBallSlippery = true;
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnBallCarrierDamaged( CTFPlayer *pPlayer, CTFPlayer *pAttacker, 
	const CTakeDamageInfo& info ) 
{
	// TODO refactor OnBallCarrierMeleeHit and OnBallCarrierDamaged for less copypasta

	// NOTE: it's possible that neither player has the ball if the attacker
	// killed the carrier, which would cause EjectBall to happen before
	// this call. There's no good way around it.

	if ( !pPlayer || !pAttacker || (pPlayer == pAttacker) || !TFGameRules() )
	{
		// happens from world damage
		return;
	}

	//
	// Only care about melee damage
	//
	// DMG_CLUB is demo charge
	if ( !tf_passtime_steal_on_melee.GetBool() || !(info.GetDamageType() & (DMG_MELEE | DMG_CLUB)) ) 
	{
		return;
	}

	Assert( m_hBall );
	if ( !m_hBall )
	{
		return;
	}

	if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BASEBALL )
	{
		auto launch = CPasstimeGun::CalcLaunch( pPlayer, false );
		LaunchBall(pPlayer, launch.startPos, launch.startVel );
	}
	else
	{
		StealBall( pPlayer, pAttacker );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::CrowdReactionSound( int iTeam ) 
{
	if ( m_flNextCrowdReactionTime <= gpGlobals->curtime ) 
	{
		TFGameRules()->BroadcastSound( iTeam, "Passtime.Crowd.React.Pos" );
		TFGameRules()->BroadcastSound( GetEnemyTeam( iTeam ), "Passtime.Crowd.React.Neg" );
		m_flNextCrowdReactionTime = gpGlobals->curtime + 10.0f;
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::StealBall( CTFPlayer *pFrom, CTFPlayer *pTo ) 
{
	if ( pFrom->m_Shared.HasPasstimeBall() )
	{
		EjectBall( pFrom, pTo );
	}

	HudNotification_t cantPickUpReason;
	if ( BCanPlayerPickUpBall( pTo, &cantPickUpReason ) )
	{
		if ( !pFrom->m_bPasstimeBallSlippery )
		{
			CTF_GameStats.Event_PlayerAwardBonusPoints( pTo, pTo, 10 );
		}

		TFGameRules()->BroadcastSound( 255, "Passtime.BallStolen" );

		++CTF_GameStats.m_passtimeStats.summary.nTotalSteals;

		m_hBall->SetStateCarried( pTo );
		OnBallGet();
		pTo->m_Shared.AddCond( TF_COND_PASSTIME_INTERCEPTION, tf_passtime_speedboost_on_get_ball_time.GetFloat() );

		int pointsToAward = 5;
		if ( CFuncPasstimeGoalieZone::BPlayerInAny( pTo ) )
		{
			++CTF_GameStats.m_passtimeStats.summary.nTotalStealsNearGoal;
			pointsToAward = 10; // Extra points for last second defend.
		}

		if ( !pFrom->m_bPasstimeBallSlippery )
		{
			CTF_GameStats.Event_PlayerAwardBonusPoints( pTo, 0, pointsToAward );
		}

		PasstimeGameEvents::BallStolen( pFrom->entindex(), pTo->entindex() ).Fire();
		CrowdReactionSound( pTo->GetTeamNumber() );
	}
	else if ( cantPickUpReason )
	{
		CSingleUserReliableRecipientFilter filter( pTo );
		TFGameRules()->SendHudNotification( filter, cantPickUpReason );
	}
}

//-----------------------------------------------------------------------------
float CTFPasstimeLogic::GetLastHeldTime( CTFPlayer* pPlayer )
{
	float lastHeldTime = 0.0f;
	for ( int i = 0; i < m_ballLastHeldTimes.Count(); i++ )
	{
		if ( m_ballLastHeldTimes[i].first == pPlayer )
		{
			lastHeldTime = m_ballLastHeldTimes[i].second;
			break;
		}
	}

	return lastHeldTime;
}

//-----------------------------------------------------------------------------
float CTFPasstimeLogic::GetLastPassTime( CTFPlayer* pPlayer )
{
	float lastPassTime = 0.0f;
	for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
	{
		if ( m_ballLastPassTimes[i].first == pPlayer )
		{
			lastPassTime = m_ballLastPassTimes[i].second;
			break;
		}
	}

	return lastPassTime;
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SetLastPassTime( CTFPlayer* pPlayer )
{
	std::pair<CTFPlayer*, float> toAdd( pPlayer, gpGlobals->realtime );
	bool skipTheRest = false;
	for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
	{
		if ( m_ballLastPassTimes[i].first == pPlayer )
		{
			m_ballLastPassTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
			skipTheRest = true;
			break;
		}
	}

	if ( !skipTheRest )
	{
		m_ballLastPassTimes.AddToTail( toAdd );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::EjectBall( CTFPlayer *pPlayer, CTFPlayer *pAttacker )
{
	if ( !m_hBall )
	{
		// I'm not sure how this is possible, but if I'm recording with hltv in
		// a listen server that has bots in it (which requires a hack in the bot
		// concommand) and I restart the game while a bot is holding the ball...
		// then m_hBall is invalid.
		if ( pPlayer )
		{
			// This has to be true to get into this function for the case I just
			// described above, and since the ball has been deleted somehow during
			// the round restart, it probably isn't necessary to set this to 0
			// because the player's going to be reset anyway. But I want to make
			// sure it's correct.
			pPlayer->m_Shared.SetHasPasstimeBall( 0 );
		}
		return;
	}

	m_hBall->SetStateFree();
	m_hBall->ChangeTeam( TEAM_UNASSIGNED );
	
	Vector vecEjectVel( 0, 0, 600 );
	vecEjectVel += pPlayer->GetAbsVelocity() * 0.1f;
	m_hBall->MoveTo( pPlayer->GetAbsOrigin() + Vector( 0, 0, 32 ), vecEjectVel );
	if ( pPlayer != pAttacker ) 
	{
		pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_LOST_OBJECT );
		pAttacker->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_TAUNTS );
	}

	m_onBallFree.FireOutput( m_hBall, this );
	std::pair<CTFPlayer*, float> toAdd( pPlayer, gpGlobals->realtime );
	for ( int i = 0; i < m_ballLastHeldTimes.Count(); i++ )
	{
		if ( m_ballLastHeldTimes[i].first == pPlayer )
		{
			m_ballLastHeldTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
			return;
		}
	}

	m_ballLastHeldTimes.AddToTail( toAdd );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::LaunchBall( CTFPlayer *pPlayer, const Vector &vecPos, const Vector &vecVel )
{
	StopAskForBallEffects();
	m_hBall->SetStateFree();
	m_hBall->MoveTo( vecPos, vecVel );
	m_onBallFree.FireOutput( m_hBall, this );
	std::pair<CTFPlayer*, float> toAdd( pPlayer, gpGlobals->realtime );
	for ( int i = 0; i < m_ballLastHeldTimes.Count(); i++ )
	{
		if ( m_ballLastHeldTimes[i].first == pPlayer )
		{
			m_ballLastHeldTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
			return;
		}
	}

	m_ballLastHeldTimes.AddToTail( toAdd );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Score( CTFPlayer *pPlayer, CFuncPasstimeGoal *pGoal )
{
	Assert( pPlayer && pGoal );
	pGoal->OnScore( pPlayer->GetTeamNumber() );
	Score( pPlayer, pGoal->GetTeamNumber(), pGoal->Points(), pGoal->BWinOnScore() );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Score( CPasstimeBall *pBall, CFuncPasstimeGoal *pGoal )
{
	Assert( pBall && pGoal );
	CTFPlayer* pPlayer = pBall->GetThrower();
	Assert( pPlayer );
	pGoal->OnScore( pPlayer->GetTeamNumber() );
	Score( pPlayer, pGoal->GetTeamNumber(), pGoal->Points(), pGoal->BWinOnScore() );
}

//-----------------------------------------------------------------------------
// static
void CTFPasstimeLogic::AddCondToTeam( ETFCond eCond, int iTeam, float flTime )
{
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pTFPlayer && (pTFPlayer->GetTeamNumber() == iTeam) && pTFPlayer->IsAlive() )
		{
			pTFPlayer->m_Shared.AddCond( eCond, flTime );
		}
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Score( CTFPlayer *pPlayer, int iTeam, int iPoints, bool bForceWin ) 
{
	StopAskForBallEffects();
	m_pRespawnCountdown->Disable();

	Assert( pPlayer );
	if ( !pPlayer || ( iTeam == TEAM_UNASSIGNED ) )
	{
		return;
	}

	if ( bForceWin )
	{
		iPoints = MAX( 1, tf_passtime_scores_per_round.GetInt() - TFTeamMgr()->GetFlagCaptures( iTeam ) );
	}
	
	//
	// Update stats
	//
	++CTF_GameStats.m_passtimeStats.summary.nTotalScores;
	++CTF_GameStats.m_passtimeStats.classes[ pPlayer->GetPlayerClass()->GetClassIndex() ].nTotalScores;
	CTF_GameStats.Event_PlayerCapturedPoint( pPlayer );

	// 
	// Award player points
	//
	CTF_GameStats.Event_PlayerAwardBonusPoints( pPlayer, 0, 25 );

	//
	// Award player assist points
	//
	{
		CTFPlayer *pAssister = nullptr;
		float flAssisterTime = FLT_MAX;
		for ( unsigned short i = 0; i < m_ballLastHeldTimes.Count(); i++ )
		{
			auto &tempPair = m_ballLastHeldTimes[i];
			auto *pPossibleAssister = tempPair.first;
			auto timeLastHeld = tempPair.second;
			auto flSecAgo = gpGlobals->realtime - timeLastHeld;
			if ( ( pPossibleAssister->GetTeamNumber() == pPlayer->GetTeamNumber() ) 
				&& ( pPossibleAssister != pPlayer ) 
				&& ( flSecAgo < 10.0f ) 
				&& ( flSecAgo < flAssisterTime ) )
			{
				pAssister = pPossibleAssister;
				flAssisterTime = flSecAgo;
			}
		}

		if ( pAssister )
		{
			CTF_GameStats.Event_PlayerAwardBonusPoints( pAssister, 0, 10 );
			PasstimeGameEvents::Score( pPlayer->entindex(), pAssister->entindex(), iPoints ).Fire();
		}
		else
		{
			PasstimeGameEvents::Score( pPlayer->entindex(), iPoints ).Fire();
		}
	}

	//
	// Award team points
	//
	while ( iPoints-- > 0 )
	{
		TFTeamMgr()->IncrementFlagCaptures( iTeam );
	}

	//
	// Award bonus conditions
	//
	AddCondToTeam( TF_COND_CRITBOOSTED_CTF_CAPTURE, pPlayer->GetTeamNumber(), tf_passtime_score_crit_sec.GetFloat() );

	//
	// Feedback
	//
	pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_FLAGCAPTURED );
	TFGameRules()->BroadcastSound( iTeam, "Passtime.Crowd.Cheer" );
	TFGameRules()->BroadcastSound( GetEnemyTeam( iTeam ), "Passtime.Crowd.Boo" );

	if ( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) ) 
	{
		const char* pszSound = ( iTeam == TF_TEAM_RED )
			? "sf14.Merasmus.Soccer.GoalRed"
			: "sf14.Merasmus.Soccer.GoalBlue";
		TFGameRules()->BroadcastSound( 255, pszSound );
	}

	//
	// Game state management
	//
	ClearBallPower();
	m_hBall->SetStateOutOfPlay();
	MoveBallToSpawner(); // move it now instead of when it spawns to avoid lerping

	//
	// Finish round or respawn ball
	//
	CTeamRoundTimer *pRoundTimer = TFGameRules()->GetActiveRoundTimer();
	if ( ( TFGameRules()->State_Get() == GR_STATE_STALEMATE ) || ( pRoundTimer && ( pRoundTimer->GetTimeRemaining() <= 0.0f ) ) ) 
	{
		EndRoundExpiredTimer();
	}
	else
	{
		SetContextThink( &CTFPasstimeLogic::RespawnBall, gpGlobals->curtime, "spawnball" );
	}

	//
	// Fire outputs
	//
	m_onScoreAny.FireOutput( pPlayer, this );
	if( iTeam == TF_TEAM_RED )
	{
		m_onScoreRed.FireOutput( pPlayer, this );
	}
	else if( iTeam == TF_TEAM_BLUE )
	{
		m_onScoreBlu.FireOutput( pPlayer, this );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnPlayerTouchBall( CTFPlayer *pCatcher, CPasstimeBall *pBall )
{
	if ( pBall != m_hBall )
	{
		return;
	}

	const int iCatcherTeam = pCatcher->GetTeamNumber();
	float flFeet = pBall->GetAirtimeDistance() / 16.0f;
	auto iExperiment = (EPasstimeExperiment_Telepass) tf_passtime_experiment_telepass.GetInt();

	//
	// Check for pass and interception
	//
	CTFPlayer *pThrower = pBall->GetThrower();
	if ( pThrower // ball must must have been thrown...
		&& (pBall->GetCollisionCount() == 0) // and not bounced...
		&& (pBall->GetTeamNumber() != TEAM_UNASSIGNED) // and not be neutral...
		&& (pCatcher != pBall->GetPrevCarrier())) // and not passed to yourself...
	{
		PasstimeGameEvents::PassCaught( pThrower->entindex(), pCatcher->entindex(), flFeet, pBall->GetAirtimeSec() ).Fire();

		bool bAllowCheerSound = true;

		int iDistanceBonus = ( int ) ( pBall->GetAirtimeSec() * tf_passtime_powerball_airtimebonus.GetFloat() );
		iDistanceBonus = clamp( iDistanceBonus, 0, tf_passtime_powerball_maxairtimebonus.GetInt() );
		int iPassPoints = tf_passtime_powerball_passpoints.GetInt();
		AddBallPower( iPassPoints + iDistanceBonus );
		bAllowCheerSound = m_iBallPower < tf_passtime_powerball_threshold.GetInt();

		CPASFilter pasFilter( pCatcher->GetAbsOrigin() );
		pCatcher->EmitSound( pasFilter, pCatcher->entindex(), "Passtime.BallCatch" );

		// make sure this happens before BeginCarry/SEtOwner etc
		if ( pThrower->GetTeamNumber() == iCatcherTeam )
		{
			if ( pBall->GetHomingTarget() )
			{
				// pass was caught by teammate
				++CTF_GameStats.m_passtimeStats.summary.nTotalPassesCompleted;
				CTF_GameStats.m_passtimeStats.AddPassTravelDistSample( pBall->GetAirtimeDistance() );

				// award bonus effects for pass
				pCatcher->m_Shared.AddCond( TF_COND_SPEED_BOOST, tf_passtime_speedboost_on_get_ball_time.GetFloat() );

				if ( CFuncPasstimeGoalieZone::BPlayerInAny( pCatcher ) )
				{
					++CTF_GameStats.m_passtimeStats.summary.nTotalPassesCompletedNearGoal;
				}

				if ( iExperiment != EPasstimeExperiment_Telepass::None )
				{
					// origins need to be a copy
					auto throwerOrigin = pThrower->GetAbsOrigin();
					auto catcherOrigin = pCatcher->GetAbsOrigin();

					CPVSFilter filterThrower( throwerOrigin );
					switch( pThrower->GetTeamNumber() )
					{
					case TF_TEAM_RED:
						TE_TFParticleEffect( filterThrower, 0.0, "teleported_red", throwerOrigin, vec3_angle );
						TE_TFParticleEffect( filterThrower, 0.0, "player_sparkles_red", throwerOrigin, vec3_angle, pThrower, PATTACH_ABSORIGIN );
						break;
					case TF_TEAM_BLUE:
						TE_TFParticleEffect( filterThrower, 0.0, "teleported_blue", throwerOrigin, vec3_angle );
						TE_TFParticleEffect( filterThrower, 0.0, "player_sparkles_blue", throwerOrigin, vec3_angle, pThrower, PATTACH_ABSORIGIN );
						break;
					default:
						break;
					}

					pThrower->EmitSound( "Building_Teleporter.Send" );
					pCatcher->EmitSound( "Building_Teleporter.Receive" );

					// then move the player
					pThrower->Teleport( &catcherOrigin, nullptr, nullptr );
					if ( iExperiment == EPasstimeExperiment_Telepass::SwapWithCatcher )
					{
						pCatcher->Teleport( &throwerOrigin, nullptr, nullptr );

						CPVSFilter filterCatcher( catcherOrigin );
						switch( pCatcher->GetTeamNumber() )
						{
						case TF_TEAM_RED:
							TE_TFParticleEffect( filterCatcher, 0.0, "teleported_red", catcherOrigin, vec3_angle );
							TE_TFParticleEffect( filterCatcher, 0.0, "player_sparkles_red", catcherOrigin, vec3_angle, pCatcher, PATTACH_ABSORIGIN );
							break;
						case TF_TEAM_BLUE:
							TE_TFParticleEffect( filterCatcher, 0.0, "teleported_blue", catcherOrigin, vec3_angle );
							TE_TFParticleEffect( filterCatcher, 0.0, "player_sparkles_blue", catcherOrigin, vec3_angle, pCatcher, PATTACH_ABSORIGIN );
							break;
						default:
							break;
						}
					}

					// then start the effects
					pThrower->TeleportEffect();
				}
			}
			else
			{
				// toss was caught by teammate
				++CTF_GameStats.m_passtimeStats.summary.nTotalTossesCompleted;
			}

			float lastPassTime = 0.0f;
			for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
			{
				if ( m_ballLastPassTimes[i].first == pThrower)
				{
					lastPassTime = m_ballLastPassTimes[i].second;
					break;
				}
			}

			// successful pass
			if ( flFeet > 30 )
			{
				// fanfare and points if the pass was long enough (and we haven't been spamming throw/catch for points)
				if ( gpGlobals->realtime - lastPassTime > 6.0f ) // FIXME literal balance value
				{
					CTF_GameStats.Event_PlayerAwardBonusPoints( pThrower, pThrower, 15 ); // FIXME literal balance value
				}

				if ( bAllowCheerSound && ( pBall->GetAirtimeSec() > 2.0f ) ) // FIXME literal balance value
				{
					TFGameRules()->BroadcastSound( 255, "TFPlayer.StunImpactRange" );
				}
			}
			else// flFeet <= 30
			{
				// (points conditional on we haven't had the ball in the last 6 seconds)
				if ( gpGlobals->realtime - lastPassTime > 6.0f ) // FIXME literal balance value
				{
					CTF_GameStats.Event_PlayerAwardBonusPoints( pThrower, pThrower, 5 ); // FIXME literal balance value
				}
			}

			std::pair<CTFPlayer*, float> toAdd( pThrower, gpGlobals->realtime );
			bool skipTheRest = false;
			for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
			{
				if ( m_ballLastPassTimes[i].first == pThrower)
				{
					m_ballLastPassTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
					skipTheRest = true;
					break;
				}
			}

			if ( !skipTheRest )
			{
				m_ballLastPassTimes.AddToTail( toAdd );
			}
		}
		else
		{
			if ( pBall->GetHomingTarget() )
			{
				// pass was intercepted
				++CTF_GameStats.m_passtimeStats.summary.nTotalPassesIntercepted;
				CTF_GameStats.m_passtimeStats.AddPassTravelDistSample( pBall->GetAirtimeDistance() );
			}
			else
			{
				// toss was intercepted
				++CTF_GameStats.m_passtimeStats.summary.nTotalTossesIntercepted;
			}
			
			// interception can happen at any range, extra points if intercepted within the goal area
			int bonusPointsToAward = 15; // FIXME literal balance value
			if ( CFuncPasstimeGoalieZone::BPlayerInAny( pCatcher ) )
			{
				bonusPointsToAward = 25; // FIXME literal balance value
				if ( pBall->GetHomingTarget() )
				{
					++CTF_GameStats.m_passtimeStats.summary.nTotalPassesInterceptedNearGoal;
				}
				else
				{
					++CTF_GameStats.m_passtimeStats.summary.nTotalTossesInterceptedNearGoal;
				}
			}

			// award bonus effects for interception
			pCatcher->m_Shared.AddCond( TF_COND_PASSTIME_INTERCEPTION, tf_passtime_speedboost_on_get_ball_time.GetFloat() );
			pCatcher->m_Shared.AddCond( TF_COND_SPEED_BOOST, tf_passtime_speedboost_on_get_ball_time.GetFloat() );

			CTF_GameStats.Event_PlayerAwardBonusPoints( pCatcher, pCatcher, bonusPointsToAward );
			TFGameRules()->BroadcastSound( 255, "Passtime.BallIntercepted" );
			CrowdReactionSound( pCatcher->GetTeamNumber() );
		}
	}
	else 
	{
		++CTF_GameStats.m_passtimeStats.summary.nTotalRecoveries;
		CTFPlayer *pPrevCarrier = pBall->GetPrevCarrier();
		if ( pCatcher != pPrevCarrier )
		{
			// Gain a point for picking up a neutral ball.
			CTF_GameStats.Event_PlayerAwardBonusPoints( pCatcher, pThrower, 5 ); // FIXME literal balance value
		}

		PasstimeGameEvents::BallGet( pCatcher->entindex() ).Fire();
	}

	if ( ((iExperiment == EPasstimeExperiment_Telepass::TeleportToCatcherMaintainPossession)
			|| (iExperiment == EPasstimeExperiment_Telepass::SwapWithCatcher))
		&& BCanPlayerPickUpBall( pThrower, nullptr ) )
	{
		EjectBall( pCatcher, pThrower );
		m_hBall->SetStateCarried( pThrower );
		OnBallGet();					
	}
	else 
	{
		pBall->SetStateCarried( pCatcher );
		OnBallGet();
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnBallGet() 
{
	StopAskForBallEffects();
	if ( CTFPlayer *pPlayer = m_hBall->GetCarrier() )
	{
		m_onBallGetAny.FireOutput( pPlayer, this );
		if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
		{
			m_onBallGetRed.FireOutput( pPlayer, this );
		}
		else if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
		{
			m_onBallGetBlu.FireOutput( pPlayer, this );
		}
		CPasstimeBallController::BallPickedUp( m_hBall, pPlayer );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputSpawnBall( inputdata_t &input )
{
	RespawnBall();
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputTimeUp( inputdata_t &input )
{
	int iRedScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_RED );
	int iBlueScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_BLUE );
	int iPointDifference = abs( iRedScore - iBlueScore );
	
	// going through the list of goals to calculate the max possible point gain
	// is possible but tricky since goals can be enabled/disabled and there's no
	// way to know which goals are actually possible to score in, so this is 
	// simply hard-coded to work correctly for the official maps where there's
	// a 3-point unlockable goal.
	int iMaxPossibleScoreGain = 3;

	if ( ( iPointDifference <= iMaxPossibleScoreGain ) && !ShouldEndOvertime() )
	{
		m_pRespawnCountdown->Disable();
		TFGameRules()->BroadcastSound( 255, "Game.Overtime" );
		ThinkExpiredTimer();
	}
	else
	{
		EndRoundExpiredTimer();
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::ThinkExpiredTimer()
{
 	if ( TFGameRules() && (TFGameRules()->State_Get() != GR_STATE_RND_RUNNING) ) 
	{
		if ( m_pRespawnCountdown )
		{
			// just in case
			m_pRespawnCountdown->Disable();
		}
		return;
	}

	if ( ShouldEndOvertime() || m_pRespawnCountdown->Tick( gpGlobals->frametime ) )
	{
		EndRoundExpiredTimer();
		return;
	}

	// Check again every frame until either something else ends the round
	// or the conditions are met that allow an expired timer to end the round.
	SetContextThink( &CTFPasstimeLogic::ThinkExpiredTimer, gpGlobals->curtime, "ThinkExpiredTimer" );

	Assert( m_hBall ); // verified in ShouldEndOvertime
	Assert( m_pRespawnCountdown ); // always valid after Spawn
	bool bBallUnassigned = m_hBall->GetTeamNumber() == TEAM_UNASSIGNED;
	bool bCountdownRunning = !m_pRespawnCountdown->IsDisabled();
	if ( bBallUnassigned && !bCountdownRunning )
	{
		// start the countdown when the ball turns neutral
		m_pRespawnCountdown->Start( tf_passtime_overtime_idle_sec.GetFloat() );
	}
	else if ( !bBallUnassigned && bCountdownRunning ) 
	{
		// stop the countdown when the ball is picked up
		m_pRespawnCountdown->Disable();
	}
}


//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::ShouldEndOvertime() const
{
	if ( !m_hBall || !TFGameRules() ) 
	{
		return true;
	}

	// if nobody has the ball, only the respawn countdown can end overtime
	CTFPlayer *pBallCarrier = m_hBall->GetCarrier();
	if ( m_hBall->GetTeamNumber() == TEAM_UNASSIGNED || !pBallCarrier )
	{
		return false;
	}

	// if the teams are tied, someone has to score
	int iRedScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_RED );
	int iBluScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_BLUE );
	if ( iRedScore == iBluScore )
	{
		return false;
	}

	// if the winning team has posession, they win
	int iWinningTeam = ( iRedScore > iBluScore )
		? TF_TEAM_RED
		: TF_TEAM_BLUE;
	return pBallCarrier->GetTeamNumber() == iWinningTeam;
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::EndRoundExpiredTimer()
{
	StopAskForBallEffects();
	m_pRespawnCountdown->Disable();
	SetContextThink( &CTFPasstimeLogic::ThinkExpiredTimer, TICK_NEVER_THINK, "ThinkExpiredTimer" );
	
	// copied from TeamplayRoundBasedGameRules::State_Think_RND_RUNNING
	int iDrawScoreCheck = -1;
	int iWinningTeam = 0;
	bool bTeamsAreDrawn = true;
	for ( int i = FIRST_GAME_TEAM; (i < GetNumberOfTeams()) && bTeamsAreDrawn; i++ )
	{
		int iTeamScore = TFTeamMgr()->GetFlagCaptures( i );

		if ( iTeamScore > iDrawScoreCheck )
		{
			iWinningTeam = i;
		}

		if ( iTeamScore != iDrawScoreCheck )
		{
			if ( iDrawScoreCheck == -1 )
			{
				iDrawScoreCheck = iTeamScore;
			}
			else
			{
				bTeamsAreDrawn = false;
			}
		}
	}

	if ( bTeamsAreDrawn )
	{
		TFGameRules()->SetStalemate( STALEMATE_SERVER_TIMELIMIT, true );
	}
	else
	{
		TFGameRules()->SetWinningTeam( iWinningTeam, WINREASON_TIMELIMIT, true, false, false );
	}
}

//-----------------------------------------------------------------------------
struct SetSectionParams
{
	int num;
	CPathTrack *pSectionStart;
	CPathTrack *pSectionEnd;
	SetSectionParams() : num(-1), pSectionStart(0), pSectionEnd(0) {}
};

//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::ParseSetSection( const char *pStr, SetSectionParams &s ) const
{
	char pszStartName[64];
	char pszEndName[64];
	const int iScanCount = sscanf( pStr, "%i %s %s", &s.num, pszStartName, pszEndName ); // WHAT YEAR IS IT
	if ( iScanCount != 3 )
	{
		return false;
	}
	s.pSectionStart = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( 0, pszStartName ) );
	s.pSectionEnd = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( 0, pszEndName ) );

	if ( s.num < 0 ) 
		Warning( "SetSection number (%i) must be > 0\n", s.num );
	if ( s.num >= m_iNumSections ) 
		Warning( "SetSection number (%i) must be < section count (%i)\n", s.num, m_iNumSections.Get() );
	if ( !s.pSectionStart ) 
		Warning( "Failed to find section start path_track named %s\n", pszStartName );
	if ( !s.pSectionEnd) 
		Warning( "Failed to find section end path_track named %s\n", pszEndName );

	return (s.num >= 0)
		&& (s.num < m_iNumSections)
		&& s.pSectionStart
		&& s.pSectionEnd;
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputSetSection( inputdata_t &input )
{
	SetSectionParams params;
	if ( !ParseSetSection( input.value.String(), params ) )
	{
		Warning( "Error in SetSection input: %s\n", input.value.String() );
		return;
	}

	for ( int i = 0; i < m_trackPoints.Count(); ++i )
	{
		m_trackPoints.GetForModify(i).Zero();
	}

	int iTrackPoint = 0;
	for ( CPathTrack *pTrack = params.pSectionStart; pTrack; pTrack = pTrack->GetNext(), ++iTrackPoint )
	{
		if ( iTrackPoint == m_trackPoints.Count() )
		{
			Warning( "Too many track_path in section (%i max, easily changed but must be fixed).", m_trackPoints.Count() );
			return;
		}

		m_trackPoints.Set( iTrackPoint, pTrack->GetAbsOrigin() );
		if ( pTrack->GetAbsOrigin() == Vector( 0, 0, 0 ) )
		{
			// Because I'm using 0,0,0 to represent "no point" in a fixed 16-element array 
			Warning( "Can't have track_path at 0,0,0" );
		}

		if ( pTrack == params.pSectionEnd )
		{
			break;
		}
	}

	m_iCurrentSection = params.num;

}


//
// Secret Room
//

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SecretRoom_Spawn()
{
	SECRETROOM_LOG( "@@@@  SECRET ROOM: Spawn\n" );
	m_SecretRoom_pTv = gEntList.FindEntityByName( nullptr, "tv" );

	string_t self = GetEntityName();

	// plug_breakable.OnDamaged -> this.InputPlugDamaged
	HookOutput( "plug_breakable", self, "OnDamaged", "staticc", nullptr, 1 );

	// player triggers
	// the names are generated gibberish words
	// (Blu)	(1)Scout: "comillow"
	HookOutput( "comillow", self, "OnStartTouch", "statica" );
	HookOutput( "comillow", self, "OnEndTouch", "staticb" );

	// (Red)	(2)Soldier: "unissubs"
	HookOutput( "unissubs", self, "OnStartTouch", "statica" );
	HookOutput( "unissubs", self, "OnEndTouch", "staticb" );

	// (Red)	(3)Pyro: "amment"
	HookOutput( "amment", self, "OnStartTouch", "statica" );
	HookOutput( "amment", self, "OnEndTouch", "staticb" );

	// (Blu)	(4)Demo: "memagold"
	HookOutput( "memagold", self, "OnStartTouch", "statica" );
	HookOutput( "memagold", self, "OnEndTouch", "staticb" );

	// (Red)	(5)Heavy: "subcla"
	HookOutput( "subcla", self, "OnStartTouch", "statica" );
	HookOutput( "subcla", self, "OnEndTouch", "staticb" );

	// (Blu)	(6)Engineer: "enempose"
	HookOutput( "enempose", self, "OnStartTouch", "statica" );
	HookOutput( "enempose", self, "OnEndTouch", "staticb" );

	// (Red)	(7)Medic: "irlenous"
	HookOutput( "irlenous", self, "OnStartTouch", "statica" );
	HookOutput( "irlenous", self, "OnEndTouch", "staticb" );

	// (Red)	(8)Sniper: "donked"
	HookOutput( "donked", self, "OnStartTouch", "statica" );
	HookOutput( "donked", self, "OnEndTouch", "staticb" );

	// (Blu)	(9)Spy: "finear"
	HookOutput( "finear", self, "OnStartTouch", "statica" );
	HookOutput( "finear", self, "OnEndTouch", "staticb" );

	// the room trigger for keeping track of who gets the achievement
	HookOutput( "room_trigger", self, "OnStartTouch", "RoomTriggerOnTouch" );
	g_EventQueue.AddEvent( "room_trigger", "Enable", variant_t(), 0.0f, this, this );
}

//-----------------------------------------------------------------------------
int CTFPasstimeLogic::SecretRoom_CountSlottedPlayers() const
{
	int iNumSlotsFilled = 0;
	for ( CTFPlayer *pPlayer : m_SecretRoom_slottedPlayers )
	{
		if ( pPlayer ) ++iNumSlotsFilled;
	}
	return iNumSlotsFilled;
}

//-----------------------------------------------------------------------------
// this doesn't need a template, but something like this in variant_t.h would
// be nice. Or maybe just some explicit overloaded constructors.
template <typename T> variant_t make_variant( T value );
template <> variant_t make_variant( int value )
{
	variant_t v;
	v.SetInt( value );
	return v;
}

//-----------------------------------------------------------------------------
static void SecretRoom_PlayTvSound( CSoundPatch **ppPatch, int iEntIndex, const char *pSoundName, float flVolume )
{
	Assert( ppPatch );
	Assert( iEntIndex > 0 );
	Assert( pSoundName && *pSoundName );
	Assert( flVolume > 0 );

	CSoundEnvelopeController &snd = CSoundEnvelopeController::GetController();
	if ( *ppPatch )
	{
		SECRETROOM_LOG( "  @@  SECRET ROOM: Destroy sound patch\n" );
		snd.SoundDestroy( *ppPatch );
		*ppPatch = nullptr;
	}

	SECRETROOM_LOG( "  @@  SECRET ROOM: Create sound patch for %s volume %f\n", pSoundName, flVolume );
	CReliableBroadcastRecipientFilter filter;
	*ppPatch = snd.SoundCreate( filter, iEntIndex, pSoundName );
	snd.Play( *ppPatch, flVolume, PITCH_NORM );
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SecretRoom_UpdateTv( int iNumSlotsFilled )
{
	if ( iNumSlotsFilled == 9 )
	{
		SECRETROOM_LOG( "  @@  SECRET ROOM: Update TV all slots filled\n" );
		g_EventQueue.AddEvent( "screen", "Skin", make_variant( 3 ), 0.0f, this, this );
		SecretRoom_PlayTvSound( &m_SecretRoom_pTvSound, 
			m_SecretRoom_pTv->entindex(), "Passtime.Tv3", 1.0f );
	}
	else
	{
		// sound
		float volume = (float)( iNumSlotsFilled + 1 ) / 10.0f;
		const char *pSoundName = ( iNumSlotsFilled >= 4 )
			? "Passtime.Tv2"
			: "Passtime.Tv1";

		SECRETROOM_LOG( "  @@  SECRET ROOM: Update TV %i slots filled\n", iNumSlotsFilled );

		SecretRoom_PlayTvSound( &m_SecretRoom_pTvSound, 
			m_SecretRoom_pTv->entindex(), pSoundName, volume );

		// skin
		int iSkin = ( iNumSlotsFilled >= 4 ) ? 2 : 1;
		g_EventQueue.AddEvent( "screen", "Skin", make_variant( iSkin ), 0.0f, this, this );
	}
}

//-----------------------------------------------------------------------------
struct SecretRoom_TriggerInfo
{
	int iIndex;
	const char *pTriggerName;
	int iClass;
	int iTeam;
} static const s_SecretRoom_TriggerInfo[9] =
{
	{ 0, "comillow",	TF_CLASS_SCOUT,			TF_TEAM_BLUE },
	{ 1, "unissubs",	TF_CLASS_SOLDIER,		TF_TEAM_RED },
	{ 2, "amment",		TF_CLASS_PYRO,			TF_TEAM_RED },
	{ 3, "memagold",	TF_CLASS_DEMOMAN,		TF_TEAM_BLUE },
	{ 4, "subcla",		TF_CLASS_HEAVYWEAPONS,	TF_TEAM_RED },
	{ 5, "enempose",	TF_CLASS_ENGINEER,		TF_TEAM_BLUE },
	{ 6, "irlenous",	TF_CLASS_MEDIC,			TF_TEAM_RED },
	{ 7, "donked",		TF_CLASS_SNIPER,		TF_TEAM_RED },
	{ 8, "finear",		TF_CLASS_SPY,			TF_TEAM_BLUE },
};

//-----------------------------------------------------------------------------
static const SecretRoom_TriggerInfo &SecretRoom_GetSlotInfoForTrigger( 
	const char *pTriggerName )
{
	for ( const auto &info : s_SecretRoom_TriggerInfo )
	{
		if ( !V_strcmp( info.pTriggerName, pTriggerName ) )
		{
			return info;
		}
	}

	Error( "Invalid trigger" );
	
	// in case some platforms don't have noreturn attribute on Error
	static SecretRoom_TriggerInfo unused; 
	return unused;
}

//-----------------------------------------------------------------------------
//	SecretRoom_InputStartTouchPlayerSlot
void CTFPasstimeLogic::statica( inputdata_t &input )
{
	SECRETROOM_LOG( "@@@@  SECRET ROOM: Start touch player slot\n" );

	if ( m_SecretRoom_state != SecretRoomState::Open )
	{
		SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - state is not open\n" );

		// shouldn't happen because triggers should be disabled
		return;
	}

	if ( !input.pCaller || !input.pActivator )
	{
		SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - no caller or activator\n" );

		return;
	}

	CTFPlayer *pActivator = ToTFPlayer( input.pActivator );
	SECRETROOM_LOG( "   @  SECRET ROOM: Toucher is %s\n", pActivator->GetPlayerName() );

	if ( !pActivator || pActivator->IsDead() || !pActivator->IsAlive() )
	{
		SECRETROOM_LOG( "  @   SECRET ROOM: Ignore - bad player\n" );

		// not a player or not normal
		return;
	}

	const char *pTriggerName = input.pCaller->GetEntityName().ToCStr();
	const auto& info = SecretRoom_GetSlotInfoForTrigger( pTriggerName );

	SECRETROOM_LOG( "   @  SECRET ROOM: Trigger is %s, slot is %i\n", pTriggerName, info.iIndex );


	if ( m_SecretRoom_slottedPlayers[info.iIndex] )
	{
		SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - slot already filled by %s\n", m_SecretRoom_slottedPlayers[info.iIndex]->GetPlayerName() );

		// already someone filling the slot
		return;
	}

	int iActivatorTeam = pActivator->GetTeamNumber();
	int iActivatorClass = pActivator->GetPlayerClass()->GetClassIndex();

	if ( !pActivator 
		|| ( info.iTeam != iActivatorTeam ) 
		|| ( info.iClass != iActivatorClass ) )
	{
		SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - wrong class %i (%i) or team %i (%i) \n",
			iActivatorTeam, info.iTeam, info.iClass, iActivatorClass );

		// doesn't match
		return;
	}

	SECRETROOM_LOG( "   @  SECRET ROOM: Set slot %i to %s\n", info.iIndex, pActivator->GetPlayerName() );

	// set slot
	m_SecretRoom_slottedPlayers[info.iIndex] = pActivator;

	// either solve puzzle or update effects
	int iNumSlotsFilled = SecretRoom_CountSlottedPlayers();
	SECRETROOM_LOG( "   @  SECRET ROOM: %i slots filled\n", iNumSlotsFilled );

	if ( iNumSlotsFilled == 9 )
	{
		SecretRoom_Solve();
	}
	else
	{
		SecretRoom_UpdateTv( iNumSlotsFilled );
	}
}

//-----------------------------------------------------------------------------
//	SecretRoom_InputEndTouchPlayerSlot
void CTFPasstimeLogic::staticb( inputdata_t &input )
{
	SECRETROOM_LOG( "@@@@  SECRET ROOM: End touch player slot\n" );

	if ( m_SecretRoom_state != SecretRoomState::Open )
	{
		SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - state is not open\n" );

		// shouldn't happen because triggers should be disabled
		return;
	}

	const char *pTriggerName = input.pCaller->GetEntityName().ToCStr();
	const auto& info = SecretRoom_GetSlotInfoForTrigger( pTriggerName );

	SECRETROOM_LOG( "   @  SECRET ROOM: Trigger is %s, slot is %i\n", pTriggerName, info.iIndex );


	// input.pActivator can be null if a player disconnects while inside 
	// the trigger. but there's no way to tell if it's the player occupying 
	// the slot, so clear the slot just in case
	if ( input.pActivator )
	{
		CTFPlayer *pActivator = ToTFPlayer( input.pActivator );
		SECRETROOM_LOG( "   @  SECRET ROOM: Toucher is %s\n", pActivator->GetPlayerName() );

		if ( !pActivator || pActivator->IsDead() || !pActivator->IsAlive() )
		{
			SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - bad player\n" );

			// not a player or not normal
			return;
		}

		if ( m_SecretRoom_slottedPlayers[info.iIndex] != input.pActivator )
		{
			if ( m_SecretRoom_slottedPlayers[info.iIndex] )
				SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - slot is held by %s\n", m_SecretRoom_slottedPlayers[info.iIndex]->GetPlayerName() );
			else
				SECRETROOM_LOG( "   @  SECRET ROOM: Ignore - slot is empty\n" );

			// slot is empty already or some other player exiting the trigger

			// if slot is empty: due to this code not using proper filters,
			// this can be caused by players suiciding after changing teams
			// while standing inside the trigger, because the suicide happens
			// after the team change. this case is the entire reason for
			// m_SecretRoom_slottedPlayers.
			return;
		}
	}

	// clear the slot
	// note: in the case where two matching players are in the trigger 
	// and the one that entered first exits, the remaining player won't count
	// and will have to re-enter the trigger
	SECRETROOM_LOG( "   @  SECRET ROOM: Clear slot %i\n", info.iIndex );

	m_SecretRoom_slottedPlayers[info.iIndex] = nullptr;

	// update effects
	SecretRoom_UpdateTv( SecretRoom_CountSlottedPlayers() );
}

//-----------------------------------------------------------------------------
//	SecretRoom_InputPlugDamaged
void CTFPasstimeLogic::staticc( inputdata_t &input ) 
{
	SECRETROOM_LOG( "@@@@  SECRET ROOM: Plug destroyed\n" );

	NOTE_UNUSED( input );
	m_SecretRoom_state = SecretRoomState::Open;

	// set fx for puzzle open
	SecretRoom_UpdateTv( 0 );

	// enable triggers
	for ( const auto& info : s_SecretRoom_TriggerInfo )
	{
		g_EventQueue.AddEvent( info.pTriggerName, "Enable", 
			variant_t(), 0.0f, this, this );
	}
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SecretRoom_Solve()
{
	if ( m_SecretRoom_state != SecretRoomState::Open )
	{
		// paranoia
		Assert( m_SecretRoom_state == SecretRoomState::Open );
		return;
	}

	SECRETROOM_LOG( "@@@@  SECRET ROOM: Solved\n" );

	m_SecretRoom_state = SecretRoomState::Solved;

	// set fx for puzzle solved
	g_EventQueue.AddEvent( "light", "TurnOn", variant_t(), 0.0f, this, this );
	g_EventQueue.AddEvent( "spotlight", "LightOn", variant_t(), 0.0f, this, this );
	g_EventQueue.AddEvent( "tv_particles", "Start", variant_t(), 0.0f, this, this );
	g_EventQueue.AddEvent( "screen_image", "Enable", variant_t(), 0.0f, this, this );
	SecretRoom_UpdateTv( 9 );

	// disable triggers
	for ( const auto& info : s_SecretRoom_TriggerInfo )
	{
		g_EventQueue.AddEvent( info.pTriggerName, "Disable", 
			variant_t(), 0.0f, this, this );
	}

	// achieves
	for ( auto id : m_SecretRoom_playersThatTouchedRoom )
	{
		CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( id ) );
		if ( pPlayer )
		{
			pPlayer->AwardAchievement( ACHIEVEMENT_TF_PASS_TIME_HAT );
		}
	}
	m_SecretRoom_playersThatTouchedRoom.RemoveAll(); // paranoia
}

//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputRoomTriggerOnTouch( inputdata_t &input )
{
	CTFPlayer *pPlayer = ToTFPlayer( input.pActivator );
	if ( !pPlayer || pPlayer->IsBot() )
	{
		return;
	}

	CSteamID id;
	pPlayer->GetSteamID( &id );
	if ( id.IsValid() && ( m_SecretRoom_playersThatTouchedRoom.Find( id ) == -1 ) )
	{
		SECRETROOM_LOG( "@@@@  SECRET ROOM: Tracking %s for achievement\n", pPlayer->GetPlayerName() );
		m_SecretRoom_playersThatTouchedRoom.AddToTail( id );
	}
}