tf2/tf2_src/game/client/tf/tf_hud_passtime.cpp

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

#include "cbase.h"
#include "c_func_passtime_goal.h"
#include "c_tf_passtime_ball.h"
#include "c_tf_passtime_logic.h"
#include "tf_hud_passtime.h"
#include "tf_hud_passtime_ball_offscreen_arrow.h"
#include "tf_weapon_passtime_gun.h"
#include "passtime_convars.h"
#include "passtime_game_events.h"
#include "tf_hud_freezepanel.h"
#include "tf_gamerules.h"
#include "c_tf_team.h"
#include "c_tf_player.h"
#include "c_tf_playerresource.h"
#include "iclientmode.h"
#include "vgui_controls/AnimationController.h"
#include "vgui_controls/CircularProgressBar.h"
#include "vgui_controls/ProgressBar.h"
#include "vgui/ISurface.h"
#include <algorithm>

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

//-----------------------------------------------------------------------------
using namespace vgui;

//-----------------------------------------------------------------------------
// The team colors from g_PR are wrong for probably good reasons that I don't understand.
static Color GetTeamColor( int iTeam, byte alpha = 255 )
{
	switch ( iTeam )
	{
	case TF_TEAM_RED:	return Color( 159, 55, 34, alpha );
	case TF_TEAM_BLUE:	return Color( 76, 109, 128, alpha );
	default:			return Color( 245, 231, 222, alpha );
	}
}

//-----------------------------------------------------------------------------
static const char *GetProgressBallImageForTeam( int iTeam )
{
	switch( iTeam )
	{
	case TF_TEAM_RED: return "../passtime/hud/passtime_ballcontrol_red";
	case TF_TEAM_BLUE: return "../passtime/hud/passtime_ballcontrol_blue";
	default: return "../passtime/hud/passtime_ballcontrol_none";
	};
}
static const char *GetProgressBallImageForTeam( C_BaseEntity *pEnt )
{
	if ( !pEnt ) 
	{
		return "../passtime/hud/passtime_ball";
	}
	return GetProgressBallImageForTeam( pEnt->GetTeamNumber() );
}

//-----------------------------------------------------------------------------
static const char *GetPlayerProgressPortrait( C_TFPlayer *pPlayer )
{
	if ( !pPlayer )
	{
		return "../passtime/hud/portrait_scout_red";
	}

	int iTeam = pPlayer->GetTeamNumber();
	int iClass = pPlayer->GetPlayerClass()->GetClassIndex();

	switch(iClass)
	{
		case TF_CLASS_SOLDIER:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_soldier_red"	: "../passtime/hud/portrait_soldier_blu";
		case TF_CLASS_SCOUT:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_scout_red"		: "../passtime/hud/portrait_scout_blu";
		case TF_CLASS_SNIPER:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_sniper_red"		: "../passtime/hud/portrait_sniper_blu";
		case TF_CLASS_DEMOMAN:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_demo_red"		: "../passtime/hud/portrait_demo_blu";
		case TF_CLASS_MEDIC:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_medic_red"		: "../passtime/hud/portrait_medic_blu";
		case TF_CLASS_HEAVYWEAPONS:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_heavy_red"		: "../passtime/hud/portrait_heavy_blu";
		case TF_CLASS_PYRO:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_pyro_red"		: "../passtime/hud/portrait_pyro_blu";
		case TF_CLASS_SPY:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_spy_red"		: "../passtime/hud/portrait_spy_blu";
		case TF_CLASS_ENGINEER:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_eng_red"		: "../passtime/hud/portrait_eng_blu";
		default:
			return (iTeam == TF_TEAM_RED) ? "../passtime/hud/portrait_scout_red"		: "../passtime/hud/portrait_scout_blu";
	}
}

//-----------------------------------------------------------------------------
static const char *GetProgressGoalImage( const C_FuncPasstimeGoal *pGoal )
{
	if ( !pGoal ) 
	{
		return "";
	}

	// NOTE: keep in mind that a goal that's on team blue is the goal where blue scores
	// and should look red on the hud since it's in the red part of the map. oops.
	bool bRedIcon = pGoal->GetTeamNumber() == TF_TEAM_BLUE;

	if ( pGoal->GetGoalType() == C_FuncPasstimeGoal::TYPE_TOWER )
	{
		if ( pGoal->BGoalTriggerDisabled() )
		{
			return bRedIcon
				? "../passtime/hud/passtime_goal_red_locked"
				: "../passtime/hud/passtime_goal_blue_locked";
		}
		else
		{
			return bRedIcon
				? "../passtime/hud/passtime_goal_red_unlocked"
				: "../passtime/hud/passtime_goal_blue_unlocked";
		}
	}
	else if ( pGoal->GetGoalType() == C_FuncPasstimeGoal::TYPE_ENDZONE )
	{
		return bRedIcon
			? "../passtime/hud/passtime_endzone_red_icon"
			: "../passtime/hud/passtime_endzone_blue_icon";
	}
	else
	{
		return bRedIcon
			? "../passtime/hud/passtime_goal_red_icon"
			: "../passtime/hud/passtime_goal_blue_icon";
	}
}

//-----------------------------------------------------------------------------
// CTFHudPasstimePanel
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
CTFHudPasstimePanel::CTFHudPasstimePanel( vgui::Panel *pParent, const char* name )
	: EditablePanel( pParent, name )
{}

//-----------------------------------------------------------------------------
bool CTFHudPasstimePanel::IsVisible()
{
	if ( IsTakingAFreezecamScreenshot() )
	{
		return false;
	}
	return BaseClass::IsVisible();
}


//-----------------------------------------------------------------------------
// CTFHudTeamScore
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
CTFHudTeamScore::CTFHudTeamScore( vgui::Panel *pParent ) 
	: CTFHudPasstimePanel( pParent, "HudTeamScore" )
	, m_pPlayingToCluster( 0 )
{
}

//-----------------------------------------------------------------------------
void CTFHudTeamScore::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	LoadControlSettings( "resource/UI/HudPasstimeTeamScore.res", NULL, NULL, NULL );
	m_pPlayingToCluster = FindControl<EditablePanel>( "PlayingToCluster" );

	if ( m_pPlayingToCluster )
	{
		m_pPlayingToCluster->SetVisible( true );
	}

	OnTick();
	vgui::ivgui()->AddTickSignal( GetVPanel() );
}

//-----------------------------------------------------------------------------
void CTFHudTeamScore::OnTick()
{
	// I would rather not do this every tick, but i couldn't find a reliable way
	// to do it from events.
	if( !g_pPasstimeLogic )
	{
		return;
	}

	int iBlueScore = 0;
	int iRedScore = 0;

	C_TFTeam *pTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
	if ( pTeam )
	{
		iBlueScore = pTeam->GetFlagCaptures();
	}

	pTeam = GetGlobalTFTeam( TF_TEAM_RED );
	if ( pTeam )
	{
		iRedScore = pTeam->GetFlagCaptures();
	}

	if ( m_pPlayingToCluster )
	{
		m_pPlayingToCluster->SetDialogVariable( "rounds", 
			tf_passtime_scores_per_round.GetInt() );
	}

	SetDialogVariable( "bluescore", iBlueScore );
	SetDialogVariable( "redscore", iRedScore );
}

//-----------------------------------------------------------------------------
int CTFHudTeamScore::GetTeamScore( int iTeam )
{
	C_TFTeam *pTeam = GetGlobalTFTeam( iTeam );
	return pTeam 
		? pTeam->Get_Score()
		: 0;
}

//-----------------------------------------------------------------------------
// CTFHudPasstimePassNotify
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
CTFHudPasstimePassNotify::CTFHudPasstimePassNotify( vgui::Panel *pParent ) 
	: CTFHudPasstimePanel( pParent, "HudPasstimePassNotify" )
{
}

//-----------------------------------------------------------------------------
void CTFHudPasstimePassNotify::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	LoadControlSettings( "resource/UI/HudPasstimePassNotify.res", NULL, NULL, NULL );

	m_pTextBox = FindControl<EditablePanel>( "TextBox" );
	m_pTextInPassRange = m_pTextBox ? m_pTextBox->FindControl<Label>( "TextInPassRange" ) : NULL;
	m_pTextLockedOn = m_pTextBox ? m_pTextBox->FindControl<Label>( "TextLockedOn" ) : NULL;
	m_pTextPassIncoming = m_pTextBox ? m_pTextBox->FindControl<Label>( "TextPassIncoming" ) : NULL;
	m_pTextPlayerName = m_pTextBox ? m_pTextBox->FindControl<Label>( "TextPlayerName" ) : NULL;
	m_pSpeechIndicator = FindControl<ImagePanel>( "SpeechIndicator" );
	m_pPassLockIndicator = FindControl<ImagePanel>( "PassLockIndicator" );
	m_pTextBoxBorderNormal = pScheme->GetBorder( "TFFatLineBorder" );
	m_pTextBoxBorderIncomingRed = pScheme->GetBorder( "TFFatLineBorderRedBG" );
	m_pTextBoxBorderIncomingBlu = pScheme->GetBorder( "TFFatLineBorderBlueBG" );
	vgui::ivgui()->AddTickSignal( GetVPanel() );

	Assert( m_pTextInPassRange && m_pTextLockedOn && m_pTextPassIncoming && m_pTextPlayerName
		&& m_pSpeechIndicator && m_pPassLockIndicator );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimePassNotify::OnTick()
{
	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalPlayer || !g_pPasstimeLogic || !g_pPasstimeLogic->GetBall() ) 
	{
		// nothing can work
		if ( m_pTextBox )
		{
			m_pTextBox->SetVisible( false );
		}

		if ( m_pSpeechIndicator )
		{
			m_pSpeechIndicator->SetVisible( false );
		}

		if ( m_pPassLockIndicator )
		{
			m_pPassLockIndicator->SetVisible( false );
		}
		return;
	}

	C_PasstimeBall *pBall = g_pPasstimeLogic->GetBall();
	CTFPlayer *pBallCarrier = pBall ? pBall->GetCarrier() : NULL;
	if ( !pBallCarrier ) 
	{
		if ( pBall && pBall->GetHomingTarget() == pLocalPlayer )
		{
			//
			// Incoming pass
			//
			if ( m_pSpeechIndicator )
			{
				m_pSpeechIndicator->SetVisible( false );
			}

			if ( m_pPassLockIndicator )
			{
				m_pPassLockIndicator->SetVisible( false );
			}

			if ( m_pTextBox )
			{
				m_pTextBox->SetVisible( true );
			}

			// this should really be GetThrower instead of PrevCarrier, 
			// but it doesn't exist on the client and this will have the
			// desired value anyway.
			C_TFPlayer *pThrower = pBall->GetPrevCarrier(); 
			if ( pThrower )
			{
				if ( m_pTextPlayerName )
				{
					m_pTextPlayerName->SetText( pThrower->GetPlayerName() );
				}
			}
			else
			{
				if ( m_pTextPlayerName )
				{
					m_pTextPlayerName->SetText( "..." );
				}
			}

			if ( m_pTextLockedOn )
			{
				m_pTextLockedOn->SetVisible( false );
			}

			if ( m_pTextPassIncoming )
			{
				m_pTextPassIncoming->SetVisible( true );
			}

			if ( m_pTextInPassRange )
			{
				m_pTextInPassRange->SetVisible( false );
			}

			if ( m_pTextBox )
			{
				m_pTextBox->SetBorder( (pLocalPlayer->GetTeamNumber() == TF_TEAM_RED)
					? m_pTextBoxBorderIncomingRed 
					: m_pTextBoxBorderIncomingBlu );
			}

			return;
		}
	}

	//
	// Can't be an incoming pass at this point
	//

	if( !pBallCarrier 
		|| pLocalPlayer->IsObserver() 
		|| (pBallCarrier == pLocalPlayer) 
		|| (pBallCarrier->GetTeamNumber() != pLocalPlayer->GetTeamNumber()) )
	{
		// 
		// No carrier, or carrier is on enemy team, or carrier is local player
		//

		if ( m_pTextBox )
		{
			m_pTextBox->SetVisible( false );
		}

		if ( m_pSpeechIndicator )
		{
			m_pSpeechIndicator->SetVisible( false );
		}

		if ( m_pPassLockIndicator )
		{
			m_pPassLockIndicator->SetVisible( false );
		}
		return;
	}

	//
	// Carrier has the ball and is on our team
	//

	float flMaxPassRangeSqr = g_pPasstimeLogic->GetMaxPassRange();
	flMaxPassRangeSqr *= flMaxPassRangeSqr;
	bool bTargetable = pBallCarrier->EyePosition().DistToSqr( pLocalPlayer->EyePosition() ) < flMaxPassRangeSqr;
	if ( bTargetable )
	{
		trace_t	tr;
		CTraceFilterIgnorePlayers tracefilter( pLocalPlayer, COLLISION_GROUP_PROJECTILE );
		UTIL_TraceLine( pBallCarrier->EyePosition(), pLocalPlayer->EyePosition(), MASK_PLAYERSOLID, &tracefilter, &tr );
		bTargetable = tr.fraction == 1;
	}

	if ( !bTargetable ) 
	{
		if ( m_pTextBox )
		{
			m_pTextBox->SetVisible( false );
		}

		if ( m_pSpeechIndicator )
		{
			m_pSpeechIndicator->SetVisible( false );
		}

		if ( m_pPassLockIndicator )
		{
			m_pPassLockIndicator->SetVisible( false );
		}
		return;
	}

	bool bTargeted = pLocalPlayer->m_Shared.IsTargetedForPasstimePass();

	if ( m_pTextBox )
	{
		m_pTextBox->SetVisible( true );
	}

	if ( m_pPassLockIndicator )
	{
		m_pPassLockIndicator->SetVisible( bTargeted );
	}

	if ( m_pSpeechIndicator )
	{
		m_pSpeechIndicator->SetVisible( pLocalPlayer->m_Shared.AskForBallTime() > gpGlobals->curtime );
	}

	if ( bTargeted ) 
	{
		if ( m_pPassLockIndicator )
		{
			m_pPassLockIndicator->SetDrawColor( GetTeamColor( pLocalPlayer->GetTeamNumber() ) );
		}

		if ( m_pTextLockedOn )
		{
			m_pTextLockedOn->SetVisible( true );
		}

		if ( m_pTextPassIncoming )
		{
			m_pTextPassIncoming->SetVisible( false );
		}

		if ( m_pTextInPassRange )
		{
			m_pTextInPassRange->SetVisible( false );
		}
	}
	else if ( bTargetable )
	{
		if ( m_pTextLockedOn )
		{
			m_pTextLockedOn->SetVisible( false );
		}

		if ( m_pTextPassIncoming )
		{
			m_pTextPassIncoming->SetVisible( false );
		}

		if ( m_pTextInPassRange )
		{
			m_pTextInPassRange->SetVisible( true );
		}
	}
	//else if ( !bTargetable )
	//{
	//	m_pTopText->SetText( "CAN'T SEE YOU" );
	//}

	if ( m_pTextPlayerName )
	{
		m_pTextPlayerName->SetText( pBallCarrier->GetPlayerName() );
	}

	if ( m_pTextBox )
	{
		m_pTextBox->SetBorder( m_pTextBoxBorderNormal );
	}
}

//-----------------------------------------------------------------------------
// CTFHudPasstimeEventText
//-----------------------------------------------------------------------------

namespace HudPasstimeEventText 
{
	static const float flInSec = 0.1f;
	static const float flOutSec = 0.25f;
	static const float flShowSec = 3.0f;
	static const float flPauseSec = 0.1f;
	static const int iQueueDepthPanic = 3;
	static char const * const pKeyTeam = "team";
	static char const * const pKeySubject = "subject";
	static char const * const pKeySource = "source";
}

//-----------------------------------------------------------------------------
CTFHudPasstimeEventText::QueueElement::QueueElement()
{
	title[0] = (wchar_t)0;
	detail[0] = (wchar_t)0;
	bonus[0] = (wchar_t)0;
}

//-----------------------------------------------------------------------------
CTFHudPasstimeEventText::CTFHudPasstimeEventText()
	: m_localizeKeys( "" )
{
	m_bValid = false;
	m_pTitleLabel = 0;
	m_pDetailLabel = 0;
	m_pBonusLabel = 0;
	m_state = State::Idle;
}

//-----------------------------------------------------------------------------
CTFHudPasstimeEventText::~CTFHudPasstimeEventText()
{
	Clear();
}

//-----------------------------------------------------------------------------
// static
void CTFHudPasstimeEventText::SetLabelText( vgui::Label *pLabel, const wchar_t *pText )
{
	if ( pText && pText[0] )
	{
		pLabel->SetVisible( true );
		pLabel->SetText( pText );
	}
	else
	{
		pLabel->SetVisible( false );
		pLabel->SetText( L"" );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::EnterState( State state, float duration )
{
	m_state = state;
	
	// move things faster if the queue is backlogged, but State::Pause is always the same duration
	if ( (state != State::Pause) && (m_queue.Count() >= HudPasstimeEventText::iQueueDepthPanic) ) 
	{
		duration /= 2.0f;
	}
	m_displayTimer.Start( duration );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::SetAlpha( int ia )
{
	if ( m_pTitleLabel )
	{
		m_pTitleLabel->SetAlpha( ia );
		m_pTitleLabel->SetVisible( ia != 0 );
	}

	if ( m_pDetailLabel )
	{
		m_pDetailLabel->SetAlpha( ia );
		m_pDetailLabel->SetVisible( ia != 0 );
	}

	if ( m_pBonusLabel )
	{
		m_pBonusLabel->SetAlpha( ia );
		m_pBonusLabel->SetVisible( ia != 0 );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::Tick()
{
	if ( !m_bValid ) 
		return;

	switch( m_state )
	{
	case State::Idle:
		if ( !m_queue.IsEmpty() ) 
		{
			SetAlpha( 1 );
			auto msg = m_queue.RemoveAtHead();
			if ( m_pTitleLabel )
			{
				SetLabelText( m_pTitleLabel, msg.title );
			}
			if ( m_pDetailLabel )
			{
				SetLabelText( m_pDetailLabel, msg.detail );
			}
			if ( m_pBonusLabel )
			{
				SetLabelText( m_pBonusLabel, msg.bonus );
			}
			EnterState( State::In, HudPasstimeEventText::flInSec );
		}
		else
		{
			SetAlpha( 0 );
		}
		break;

	case State::In:
		if ( m_displayTimer.IsElapsed() )
		{
			EnterState( State::Show, HudPasstimeEventText::flShowSec );
			SetAlpha( 255 );
		}
		else
		{
			// animate alpha
			// note: GetElapsedTime()
			float flFrac = m_displayTimer.GetElapsedTime() / m_displayTimer.GetCountdownDuration();
			SetAlpha( (int) (flFrac * flFrac * 255.0f) );
		}
		break;

	case State::Show:
		if ( m_displayTimer.IsElapsed() )
		{
			EnterState( State::Out, HudPasstimeEventText::flOutSec );
		}
		break;

	case State::Out:
		if ( m_displayTimer.IsElapsed() )
		{
			EnterState( State::Pause, HudPasstimeEventText::flPauseSec );
			SetAlpha( 0 );
		}
		else
		{
			// animate alpha
			// note: GetRemainingTime()
			float flFrac = m_displayTimer.GetRemainingTime() / m_displayTimer.GetCountdownDuration();
			SetAlpha( (int) (flFrac * flFrac * 255.0f) );
		}
		break;

	case State::Pause:
		if ( m_displayTimer.IsElapsed() )
		{
			m_state = State::Idle;
		}
		break;
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::Clear()
{
	while( !m_queue.IsEmpty() )
	{
		m_queue.RemoveAtTail();
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::SetControls( vgui::Label *pTitleLabel, vgui::Label *pDetailLabel, vgui::Label *pBonusLabel )
{
	m_pTitleLabel = pTitleLabel;
	m_pDetailLabel = pDetailLabel;
	m_pBonusLabel = pBonusLabel;
	m_bValid = pTitleLabel && pDetailLabel && pBonusLabel;
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::SetPlayerName( C_TFPlayer *pPlayer, const char *pKey )
{
	if ( pPlayer )
	{
		g_pVGuiLocalize->ConvertANSIToUnicode( pPlayer->GetPlayerName(), m_pwcsBuf, sizeof(m_pwcsBuf) );
		m_localizeKeys->SetWString( pKey,  m_pwcsBuf );
	}
	else
	{
		m_localizeKeys->SetWString( pKey, L"" );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::SetTeam( C_TFPlayer *pPlayer )
{
	if ( pPlayer ) 
	{
		C_TFTeam *pTeam = GetGlobalTFTeam( pPlayer->GetTeamNumber() );
		m_localizeKeys->SetWString( "team", pTeam ? pTeam->Get_Localized_Name() : L"" );
	}
	else
	{
		m_localizeKeys->SetWString( "team", L"" );
	}
}

//-----------------------------------------------------------------------------
template< int TArraySize >
void CTFHudPasstimeEventText::ConstructNewString( const char *pLocTag, wchar_t (&out)[TArraySize] )
{
	// FIXME calling find is redundant 
	if ( pLocTag && pLocTag[0] && g_pVGuiLocalize->Find( pLocTag ) )
	{
		g_pVGuiLocalize->ConstructString_safe( out, pLocTag, m_localizeKeys );
	}
	else
	{
		out[0] = (wchar_t)0;
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::Enqueue( C_TFPlayer *pSource, C_TFPlayer *pSubject, const char *pTitle, const char *pDetail, const char *pBonus )
{
	if ( !m_bValid || !pSubject )
		return;

	SetTeam( pSubject );
	SetPlayerName( pSubject, HudPasstimeEventText::pKeySubject );
	SetPlayerName( pSource, HudPasstimeEventText::pKeySource );

	auto *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
	auto bShowBonus = (pSubject == pLocalPlayer)
		|| (pLocalPlayer->IsObserver() && pLocalPlayer->GetObserverTarget() == pLocalPlayer);
	
	QueueElement e;
	ConstructNewString( pTitle, e.title );
	ConstructNewString( pDetail, e.detail );
	ConstructNewString( bShowBonus ? pBonus : nullptr, e.bonus );
	m_queue.Insert( e );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::EnqueueGeneric( const char *pTitle, const char *pDetail, const char *pBonus )
{
	QueueElement e;
	ConstructNewString( pTitle, e.title );
	ConstructNewString( pDetail, e.detail );
	ConstructNewString( pBonus, e.bonus );
	m_queue.Insert( e );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::EnqueueSteal( C_TFPlayer *pVictim, C_TFPlayer *pStealer )
{
	Enqueue( pVictim, pStealer, "#Msg_PasstimeEventStealTitle", "#Msg_PasstimeEventStealDetail", "#Msg_PasstimeEventStealBonus" );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::EnqueuePass( C_TFPlayer *pThrower, C_TFPlayer *pCatcher )
{
	Enqueue( pThrower, pCatcher, "#Msg_PasstimeEventPassTitle", "#Msg_PasstimeEventPassDetail", "#Msg_PasstimeEventPassBonus" );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::EnqueueInterception( C_TFPlayer *pThrower, C_TFPlayer *pCatcher )
{
	Enqueue( pThrower, pCatcher, "#Msg_PasstimeEventInterceptTitle", "#Msg_PasstimeEventInterceptDetail", "#Msg_PasstimeEventInterceptBonus" );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeEventText::EnqueueScore( C_TFPlayer *pThrower, C_TFPlayer *pAssister )
{
	if ( pAssister )
		Enqueue( pAssister, pThrower, "#Msg_PasstimeEventScoreTitle", "#Msg_PasstimeEventScoreDetail_Assist", "#Msg_PasstimeEventScoreBonus" );
	else
		Enqueue( pAssister, pThrower, "#Msg_PasstimeEventScoreTitle", "#Msg_PasstimeEventScoreDetail_NoAssist", "#Msg_PasstimeEventScoreBonus" );
}

//-----------------------------------------------------------------------------
// CTFHudPasstimeBallStatus
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
CTFHudPasstimeBallStatus::CTFHudPasstimeBallStatus( Panel *pParent )
	: CTFHudPasstimePanel( pParent, "HudPasstimeBallStatus" )
{
	m_bInitialized = false;
	m_bReset = false;
	m_bGoalsFound = false;
	m_iXBlueProgress = -100.0f;
	m_iXRedProgress = -100.0f;
	m_iYBlueProgress = -100.0f;
	m_iYRedProgress = -100.0f;
	memset( m_pGoalIconsBlue, 0, sizeof( m_pGoalIconsBlue ) );
	memset( m_pGoalIconsRed, 0, sizeof( m_pGoalIconsRed ) );
	memset( m_pPlayerIcons, 0, sizeof( m_pPlayerIcons ) );
	m_pProgressBall = 0;
	m_pProgressBallCarrierName = 0;
	m_pProgressLevelBar = 0;
	m_pSelfPlayerIcon = 0;
	m_pEventText = new CTFHudPasstimeEventText();
	m_pBallPowerMeterFillContainer = nullptr;
	m_pBallPowerMeterFill = nullptr;
	m_pBallPowerMeterFrame = nullptr;
}

//-----------------------------------------------------------------------------
CTFHudPasstimeBallStatus::~CTFHudPasstimeBallStatus()
{
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	m_bInitialized = false;

	LoadControlSettings( "resource/UI/HudPasstimeBallStatus.res", NULL, NULL, NULL );
	m_pPowerCluster = FindControl<EditablePanel>( "BallPowerCluster" );
	m_pProgressBall = FindControl<ImagePanel>( "ProgressBallIcon" );
	m_pProgressBallCarrierName = FindControl<Label>( "ProgressBallCarrierName" );
	m_pProgressLevelBar = FindControl<Panel>( "ProgressLevelBar" );
	m_pSelfPlayerIcon = FindControl<ImagePanel>( "ProgressSelfPlayerIcon" );

	Panel *pBallPowerRoot = FindControl<Panel>( "BallPowerCluster" );
	if ( !pBallPowerRoot ) 
	{
		pBallPowerRoot = this;
	}
	m_pBallPowerMeterFillContainer = pBallPowerRoot->FindControl<Panel>( "BallPowerMeterFillContainer", true );
	m_pBallPowerMeterFill = pBallPowerRoot->FindControl<ImagePanel>( "BallPowerMeterFill", true );
	m_pBallPowerMeterFrame = pBallPowerRoot->FindControl<Panel>( "BallPowerMeterFrame", true );
	m_pBallPowerMeterFinalSection = pBallPowerRoot->FindControl<Panel>( "BallPowerMeterFinalSectionContainer", true );

	m_pEventText->SetControls( FindControl<Label>( "EventTitleLabel" ), 
		FindControl<Label>( "EventDetailLabel" ), 
		FindControl<Label>( "EventBonusLabel" ) );

	m_bInitialized = m_pProgressBall
		&& m_pProgressBallCarrierName
		&& m_pProgressLevelBar
		&& m_pSelfPlayerIcon
		&& m_pBallPowerMeterFillContainer
		&& m_pBallPowerMeterFill
		&& m_pBallPowerMeterFinalSection
		&& m_pBallPowerMeterFrame;

	if ( !m_bInitialized )
	{
		// just bail if the res file is missing required controls
		// this prevents a lot of stupid null checks in the future
		return;
	}

	// set up some ballpower stuff
	m_iBallPowerMeterFillWidth = m_pBallPowerMeterFillContainer ? m_pBallPowerMeterFillContainer->GetWide() : 0;
	int iFinalSectionWidth = (int)(m_iBallPowerMeterFillWidth * 0.2f);
	if ( m_pBallPowerMeterFinalSection )
	{
		m_pBallPowerMeterFinalSection->SetWide( iFinalSectionWidth );
		m_pBallPowerMeterFinalSection->SetPos( m_pBallPowerMeterFinalSection->GetXPos() + (m_iBallPowerMeterFillWidth - iFinalSectionWidth), m_pBallPowerMeterFinalSection->GetYPos() );
	}
	m_iPrevBallPower = g_pPasstimeLogic 
		? g_pPasstimeLogic->GetBallPower() 
		: 0;
	
	// find the left/right markers in the res files
	{
		auto *pRedEnd = FindChildByName( "RedProgressEnd" );
		auto *pBlueEnd = FindChildByName( "BlueProgressEnd" );
		if ( pRedEnd && pBlueEnd ) 
		{
			pRedEnd->GetPos( m_iXRedProgress, m_iYRedProgress );
			pBlueEnd->GetPos( m_iXBlueProgress, m_iYBlueProgress );
		}
		else 
		{
			// no markers in the res file, just give it offscreen but valid coords
			m_iXBlueProgress = -100.0f;
			m_iXRedProgress = -100.0f;
			m_iYBlueProgress = -100.0f;
			m_iYRedProgress = -100.0f;
		}
	}

	// find all the goal icon image panels
	{
		char buf[16];
		for ( auto i = 0; i < NumGoalIcons; ++i ) 
		{
			V_sprintf_safe( buf, "GoalRed%i", i );
			m_pGoalIconsRed[i] = FindControl<vgui::ImagePanel>( buf );
			V_sprintf_safe( buf, "GoalBlue%i", i );
			m_pGoalIconsBlue[i] = FindControl<vgui::ImagePanel>( buf );
		}
	}

	ListenForGameEvent( PasstimeGameEvents::BallFree::s_eventName );
	ListenForGameEvent( PasstimeGameEvents::BallGet::s_eventName );
	ListenForGameEvent( PasstimeGameEvents::BallStolen::s_eventName );
	ListenForGameEvent( PasstimeGameEvents::PassCaught::s_eventName );
	ListenForGameEvent( PasstimeGameEvents::Score::s_eventName );
	Reset(); // this ensures players will try to guess game state for the hud if they join a game in progress
	vgui::ivgui()->AddTickSignal( GetVPanel() );

	// find all the player icon image panels
	{
		char controlname[32];
		for ( auto i = 0; i < MAX_PLAYERS; ++i ) 
		{
			V_sprintf_safe( controlname, "playericon%i", i ); // ugh
			m_pPlayerIcons[i] = FindControl<vgui::ImagePanel>( controlname );
			Assert( m_pPlayerIcons[i] );
			m_pPlayerIcons[i]->SetEnabled( true );
			m_pPlayerIcons[i]->SetShouldScaleImage( true );
		}
	}
}

//-----------------------------------------------------------------------------
bool CTFHudPasstimeBallStatus::BShouldDraw() const
{
	CBasePlayer *pPlayer = CBasePlayer::GetLocalPlayer();
	if ( !pPlayer || !pPlayer->IsAlive() || ( pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM ) )
	{
		return false;
	}

	gamerules_roundstate_t roundstate = TFGameRules()->State_Get();
	return ((roundstate == GR_STATE_RND_RUNNING) || (roundstate == GR_STATE_STALEMATE))
		&& !TFGameRules()->InSetup();
}

//-----------------------------------------------------------------------------
// FIXME copypasta with tf_passtime_logic.cpp
static float CalcProgressFrac( const Vector& vecOrigin )
{
	Assert( g_pPasstimeLogic && (g_pPasstimeLogic->GetNumSections() > 0) );

	Vector arrTrackPoints[16];
	g_pPasstimeLogic->GetTrackPoints( arrTrackPoints );

	float flBestDist = FLT_MAX;
	float flBestLen = 0;
	float flTotalLen = 1; // don't set 0 so div by zero is impossible

	Vector vecThisPoint;
	Vector vecPointOnLine;
	Vector vecPrevPoint = arrTrackPoints[0];
	float flThisFrac = 0;
	float flThisLen = 0;
	float flThisDist = 0;
	for ( int i = 1; i < ARRAYSIZE(arrTrackPoints); ++i )
	{
		vecThisPoint = arrTrackPoints[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);
}

//-----------------------------------------------------------------------------
// FIXME copypasta with tf_passtime_logic.cpp
static float CalcBallProgressFrac()
{
	Assert( g_pPasstimeLogic && g_pPasstimeLogic->GetBall() && (g_pPasstimeLogic->GetNumSections() > 0) );
	CPasstimeBall *pBall = g_pPasstimeLogic->GetBall();
	CTFPlayer *pCarrier = pBall->GetCarrier();
	return CalcProgressFrac( pCarrier 
		? pCarrier->GetNetworkOrigin()
		: pBall->GetNetworkOrigin() );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::UpdateGoalIcon( vgui::ImagePanel *pIcon, C_FuncPasstimeGoal *pGoal )
{
	Assert( m_bInitialized );
	// TODO: animations on enable/disable?
	if ( !pIcon ) 
	{
		return;
	}

	if ( !pGoal )
	{
		pIcon->SetVisible( false );
		return;
	}

	pIcon->SetVisible( true );

	const auto iDisabledAlpha = 50;
	const auto iEnabledAlpha = 255;
	pIcon->SetAlpha( ( pGoal->BGoalTriggerDisabled() && ( pGoal->GetGoalType() != C_FuncPasstimeGoal::TYPE_TOWER ) )
		? iDisabledAlpha
		: iEnabledAlpha );

	// TODO don't call SetImage(char*) every frame, wtf.
	pIcon->SetImage( GetProgressGoalImage( pGoal ) );

	const float flProgressFrac = CalcProgressFrac( pGoal->GetAbsOrigin() );
	const int iActualBarHalfHeight = m_pProgressLevelBar ? m_pProgressLevelBar->GetTall() / 6 : 0; // magic number because NPOT waste in image
	int iX = Lerp( flProgressFrac, m_iXBlueProgress, m_iXRedProgress ) - ( pIcon->GetWide() / 2 );
	int iY = Lerp( flProgressFrac, m_iYBlueProgress, m_iYRedProgress ) - iActualBarHalfHeight;
	pIcon->SetPos( iX, iY );
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnTickHidden()
{
	m_bGoalsFound = false;
	
	if ( m_pProgressBall )
	{
		m_pProgressBall->SetVisible( false );
	}

	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetVisible( false );
	}

	if ( m_pSelfPlayerIcon )
	{
		m_pSelfPlayerIcon->SetVisible( false );
	}

	if ( m_pProgressLevelBar )
	{
		m_pProgressLevelBar->SetVisible( false );
	}

	if ( m_pPowerCluster )
	{
		m_pPowerCluster->SetVisible( false );
	}

	for ( int i = 0; i < MAX_PLAYERS; ++i )
	{
		m_pPlayerIcons[i]->SetVisible( false );
	}

	m_iPrevBallPower = g_pPasstimeLogic 
		? g_pPasstimeLogic->GetBallPower() 
		: 0;

	HideGoalIcons();
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnTickVisible( C_TFPlayer *pLocalPlayer, C_PasstimeBall *pBall)
{
	if ( m_pProgressLevelBar )
	{
		m_pProgressLevelBar->SetVisible( true );
	}

	//
	// Update ball icon
	//
	float flBallProgressFrac = CalcBallProgressFrac();
	int iX_Ball = m_pProgressBall ? Lerp( flBallProgressFrac, m_iXBlueProgress, m_iXRedProgress ) - ( m_pProgressBall->GetWide() / 2 ) : 0;
	int iY_Ball = m_pProgressBall ? Lerp( flBallProgressFrac, m_iYBlueProgress, m_iYRedProgress ) - ( m_pProgressBall->GetTall() / 2 ) : 0;

	if ( m_pProgressBall )
	{
		m_pProgressBall->SetVisible( true );
		m_pProgressBall->SetPos( iX_Ball, iY_Ball );
	}

	// todo setimage from event, not every frame
	// todo look in to letting entities manage their own hud elements
	CTFPlayer *pCarrier = pBall->GetCarrier();
	int iTeam = pCarrier
		? pCarrier->GetTeamNumber()
		: pBall->GetTeamNumber();
	if ( m_pProgressBall )
	{
		m_pProgressBall->SetImage( GetProgressBallImageForTeam( iTeam ) );
	}

	//
	// Update ball power
	//
	if ( m_pPowerCluster )
	{
		m_pPowerCluster->SetVisible( true );
	}
	{
		// update the power bar
		int iCurPower = g_pPasstimeLogic->GetBallPower();
		int iThreshold = tf_passtime_powerball_threshold.GetInt();
		int iAlpha = (iCurPower > iThreshold)
			? FLerp( 150, 255, (1 + sin(gpGlobals->curtime*5)) / 2.0f)
			: 222;
		if ( m_pBallPowerMeterFill )
		{
			m_pBallPowerMeterFill->SetDrawColor( GetTeamColor( iTeam, iAlpha ) );
		}
		float flPowerFrac = (iCurPower / 100.f);
		if ( m_pBallPowerMeterFillContainer )
		{
			m_pBallPowerMeterFillContainer->SetWide( m_iBallPowerMeterFillWidth * flPowerFrac );
		}

		// show power up/down notifications
		// this should really be done with a game event but this is a temp experimental feature for now
		bool bWasAboveThreshold = m_iPrevBallPower > iThreshold;
		bool bIsAboveThreshold = iCurPower > iThreshold;
		m_iPrevBallPower = iCurPower;
		if ( bWasAboveThreshold && !bIsAboveThreshold ) 
		{
			m_pEventText->Clear(); // push everything else out of the way
			m_pEventText->EnqueueGeneric( "#Msg_PasstimeEventPowerDownTitle", "#Msg_PasstimeEventPowerDownDetail", "#Msg_PasstimeEventPowerDownBonus" );
		}
		else if ( !bWasAboveThreshold && bIsAboveThreshold )
		{
			m_pEventText->Clear(); // push everything else out of the way
			m_pEventText->EnqueueGeneric( "#Msg_PasstimeEventPowerUpTitle", "#Msg_PasstimeEventPowerUpDetail", "#Msg_PasstimeEventPowerUpBonus" );
		}
	}

	//
	// Update player icons
	// TODO make less bad
	//
	C_TFPlayer *pSpecTarget = ToTFPlayer( pLocalPlayer->GetObserverTarget() );
	if ( m_pSelfPlayerIcon )
	{
		m_pSelfPlayerIcon->SetVisible( false );
	}
	const int iActualBarHalfHeight = m_pProgressLevelBar ? m_pProgressLevelBar->GetTall() / 7 : 0; // magic number because NPOT waste in image
	for ( int iEntIndex = 1; iEntIndex <= MAX_PLAYERS; iEntIndex++ )
	{
		vgui::ImagePanel *pIcon = m_pPlayerIcons[iEntIndex - 1];
		if ( !g_TF_PR->IsConnected( iEntIndex ) )
		{
			pIcon->SetVisible( false );
			continue;
		}

		int iEntTeam = g_TF_PR->GetTeam( iEntIndex );
		if ( !g_TF_PR->IsAlive( iEntIndex )  // no dead people; not the same as IsDead
			|| ( ( iEntTeam != TF_TEAM_RED ) && ( iEntTeam != TF_TEAM_BLUE) )  ) // no spectators
		{
			pIcon->SetVisible( false );
			continue;
		}

		// needed for origin
		// dormant means "not available on this client right now"
		C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iEntIndex ) );
		if ( !pPlayer || pPlayer->IsDormant() )
		{
			pIcon->SetVisible( false );
			continue;
		}

		// don't show cloaked spies
		bool bSpy = g_TF_PR->GetPlayerClass( iEntIndex ) == TF_CLASS_SPY;
		if ( bSpy )
		{
			if ( pPlayer->m_Shared.IsFullyInvisible() )
			{
				pIcon->SetVisible( false );
				continue;
			}

			int iDisguiseTeam = pPlayer->m_Shared.GetDisguiseTeam();
			if ( iDisguiseTeam == TF_TEAM_RED || iDisguiseTeam == TF_TEAM_BLUE )
			{
				iEntTeam = iDisguiseTeam;
			}
		}

		const float flProgressFrac = CalcProgressFrac( pPlayer->GetNetworkOrigin() );
		// Player pips
		{
			pIcon->SetVisible( true );
			if ( iEntTeam == TF_TEAM_RED )
			{
				int iX = Lerp( flProgressFrac, m_iXBlueProgress, m_iXRedProgress ) - (pIcon->GetWide() / 2);
				int iY = Lerp( flProgressFrac, m_iYBlueProgress, m_iYRedProgress ) - pIcon->GetTall() - iActualBarHalfHeight;
				pIcon->SetPos( iX, iY );
				pIcon->SetImage( "../passtime/hud/passtime_ballcontrol_team_red" );
			}
			else
			{
				int iX = Lerp( flProgressFrac, m_iXBlueProgress, m_iXRedProgress ) - (pIcon->GetWide() / 2);
				int iY = Lerp( flProgressFrac, m_iYBlueProgress, m_iYRedProgress ) + iActualBarHalfHeight;
				pIcon->SetPos( iX, iY );
				pIcon->SetImage( "../passtime/hud/passtime_ballcontrol_team_blue" );
			}
		}

		// Local player image
		if ( g_TF_PR->IsLocalPlayer( iEntIndex ) || ( pLocalPlayer->IsObserver() && ( pPlayer == pSpecTarget ) ) )
		{
			if ( m_pSelfPlayerIcon )
			{
				// TODO don't call SetImage(char*) every frame, wtf.
				if ( pLocalPlayer->IsObserver() && pSpecTarget )
				{
					m_pSelfPlayerIcon->SetImage( GetPlayerProgressPortrait( pSpecTarget ) );
				}
				else
				{
					m_pSelfPlayerIcon->SetImage( GetPlayerProgressPortrait( pLocalPlayer ) );
				}

				int iX = Lerp( flProgressFrac, m_iXBlueProgress, m_iXRedProgress ) - (m_pSelfPlayerIcon->GetWide() / 2);
				int iY = Lerp( flProgressFrac, m_iYBlueProgress, m_iYRedProgress ) - m_pSelfPlayerIcon->GetTall() - iActualBarHalfHeight;
				m_pSelfPlayerIcon->SetVisible( true );
				m_pSelfPlayerIcon->SetPos( iX, iY );
			}
		}
	}

	//
	// Refresh goal icons if necessary
	//
	bool bReadyToFindGoals = (g_pPasstimeLogic->GetNumSections() > 0);
	if ( !m_bGoalsFound && bReadyToFindGoals ) 
	{
		// release any existing handles to goals
		for ( auto i = 0; i < NumGoalIcons; ++i )
		{
			m_hGoalsBlue[i].Term();
			m_hGoalsRed[i].Term();
		}

		// Update the goal list and pair hud icons with actual goals
		const int iMaxSortedGoals = 8; // arbitrary
		const auto &goals = C_FuncPasstimeGoal::GetAutoList();
		const int iNumGoals = goals.Count();
		if ( ( iNumGoals > 1 ) && ( iNumGoals < iMaxSortedGoals ) )
		{
			// sort goals by position in world, from blue to red (blue progress is always 0, red is always 1))
			C_FuncPasstimeGoal* sortedgoals[iMaxSortedGoals];
			std::copy( goals.begin(), goals.end(), sortedgoals );
			std::sort( sortedgoals, sortedgoals + iNumGoals, []( C_FuncPasstimeGoal* a, C_FuncPasstimeGoal* b ) 
			{
				// this is wasteful but it should only happen one frame per round
				// The order of the icons in the hud res file determines which direction to sort these
				// so that the iteration below visits the goals in the same order.
				return CalcProgressFrac( a->GetAbsOrigin() ) < CalcProgressFrac( b->GetAbsOrigin() );
			});

			// Pair goals and icons so the tick function can update the icon state based on the actual goal state
			// This should work for any number of goals and icons in any order.
			// If there are more goals than icons, just ignore them, but make sure the hud shows at least
			// the goals farthest from the middle of the map in a symmetrical way, so iterate from both ends
			// of the array of sorted goals.

			// pair first N blue goals in left-right order
			// first icon in array is leftmost blue goal on hud is first goal in sorted array
			int iRedIcon = 0;
			int iBlueIcon = 0;
			for ( int iGoal = 0; iGoal < iNumGoals; ++iGoal ) 
			{
				// NOTE: goal's teams are backwards: the blue-colored goals on the blue side of the map are
				// on team red because that's where red scores. doh.
				auto *pGoal = sortedgoals[iGoal];
				if ( pGoal && ( iBlueIcon < NumGoalIcons ) && ( pGoal->GetTeamNumber() == TF_TEAM_RED ) )
				{
					m_hGoalsBlue[iBlueIcon++] = pGoal;
				}
				
				pGoal = sortedgoals[iNumGoals - iGoal - 1];
				if ( pGoal && ( iRedIcon < NumGoalIcons ) && ( pGoal->GetTeamNumber() == TF_TEAM_BLUE ) )
				{
					m_hGoalsRed[iRedIcon++] = pGoal;
				}
			}

			m_bGoalsFound = true;
		}
	}
			
	//
	// Update goal icons
	//
	if ( m_bGoalsFound )
	{
		for ( auto i = 0; i < NumGoalIcons; ++i ) 
		{
			UpdateGoalIcon( m_pGoalIconsBlue[i], m_hGoalsBlue[i].Get() );
			UpdateGoalIcon( m_pGoalIconsRed[i], m_hGoalsRed[i].Get() );
		}
	}
	else 
	{
		HideGoalIcons();
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::HideGoalIcons() 
{
	for ( int i = 0; i < NumGoalIcons; ++i )
	{
		auto *pIcon = m_pGoalIconsBlue[i];
		if ( pIcon ) 
			pIcon->SetVisible( false );
		pIcon = m_pGoalIconsRed[i];
		if ( pIcon ) 
			pIcon->SetVisible( false );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnTick()
{
	if ( !g_pPasstimeLogic || !m_bInitialized ) 
	{
		// happens randomly during map load
		m_pEventText->Clear();
		return;
	}

	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalPlayer )
	{
		// can happen during exit
		return; 
	}

	// Tick the event text regardless of the state of the rest of the hud so
	// that messages can continue to display even after the round ends or whatever.
	m_pEventText->Tick();

	// I wish there were a reliable way to do this in an event-driven way instead of every frame
	C_PasstimeBall *pBall = g_pPasstimeLogic->GetBall();
	if ( !BShouldDraw() || !pBall ) 
	{
		OnTickHidden();
		
		// this is the easiest way I could find to refresh the goals when switching maps
		// todo this is dumb
		m_bGoalsFound = false;
	}
	else
	{
		OnTickVisible( pLocalPlayer, pBall );
	}

	//
	// Try to figure out game state that's usually managed by events if hud was reloaded mid-game
	// This happens at the end to ensure that the hud is fully initialized before trying to reset
	// on the first frame a player joins a game in progress
	//
	if ( m_bReset )
	{
		m_pEventText->Clear();

		// I don't *think* it's possible that this could accidentally end up 
		// running every frame.

		// Order of operations here is important, see functions for details
		// todo make less bad
		if ( TryForceBallGet() || TryForceBallFree() )
		{
			m_bReset = false;
		}
	};
}

//-----------------------------------------------------------------------------
bool CTFHudPasstimeBallStatus::TryForceBallGet()
{
	Assert( m_bInitialized );

	// The HUD was reset during play, or possibly due to joining a game inprogroess,
	// so try to get into a BallGet state if possible
	if ( !g_TF_PR ) 
	{
		// is this even possible?
		return false;
	}

	for ( int iPlayer = 1 ; iPlayer <= MAX_PLAYERS; iPlayer++ )
	{
		if ( !g_TF_PR->IsConnected( iPlayer ) )
		{
			continue;
		}

		C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayer ) );
		if ( !pPlayer || !pPlayer->m_Shared.HasPasstimeBall() )
		{
			continue;
		}
		
		if ( g_TF_PR->IsLocalPlayer( iPlayer ) )
		{
			OnBallGetSelf( iPlayer );
		}
		else
		{
			OnBallGetOther( iPlayer );
		}

		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
bool CTFHudPasstimeBallStatus::TryForceBallFree()
{
	Assert( m_bInitialized );
	
	// The HUD was reset during play, or possibly due to joining a game inprogroess,
	// so try to get into a BallGet state if possible
	if ( !g_pPasstimeLogic )
	{
		return false;
	}

	C_PasstimeBall *pBall = g_pPasstimeLogic->GetBall();
	if ( !m_bInitialized || !pBall ) 
	{
		return false;
	}

	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetVisible( false );
	}
	return true;
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnBallGet( int getterIndex )
{
	Assert( m_bInitialized && g_PR );

	if ( g_PR->IsLocalPlayer( getterIndex ) )
	{
		OnBallGetSelf( getterIndex );
	}
	else
	{
		OnBallGetOther( getterIndex );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::FireGameEvent( IGameEvent *pEvent )
{
	if ( !m_bInitialized || !g_TF_PR || !g_PR ) 
	{
		return;
	}

	const char *pszEventName = pEvent->GetName();
	if ( FStrEq( pszEventName, PasstimeGameEvents::BallFree::s_eventName ) )
	{
		PasstimeGameEvents::BallFree ev( pEvent );
		C_TFPlayer *pOwner = ToTFPlayer( UTIL_PlayerByIndex( ev.ownerIndex ) );
		C_TFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( ev.attackerIndex ) );
		const bool wasMyBall = pOwner == C_TFPlayer::GetLocalPlayer();
		if ( wasMyBall )
		{
			OnBallFreeSelf( pOwner, pAttacker );
		}
		else
		{
			OnBallFreeOther( pOwner, pAttacker );
		}
	}
	else if ( FStrEq( pszEventName, PasstimeGameEvents::BallGet::s_eventName ) )
	{
		OnBallGet( PasstimeGameEvents::BallGet( pEvent ).ownerIndex );
	}
	else if ( FStrEq( pszEventName, PasstimeGameEvents::BallStolen::s_eventName ) )
	{
		PasstimeGameEvents::BallStolen ballStolenEvent( pEvent );
		OnBallGet( ballStolenEvent.attackerIndex );

		auto *pAttacker = ToTFPlayer( UTIL_PlayerByIndex(ballStolenEvent.attackerIndex) );
		auto *pVictim = ToTFPlayer( UTIL_PlayerByIndex(ballStolenEvent.victimIndex) );
		m_pEventText->EnqueueSteal( pVictim, pAttacker );
	}
	else if ( FStrEq( pszEventName, PasstimeGameEvents::PassCaught::s_eventName ) )
	{
		PasstimeGameEvents::PassCaught passCaughtEvent( pEvent );
		OnBallGet( passCaughtEvent.catcherIndex );
		
		auto *pCatcher = ToTFPlayer( UTIL_PlayerByIndex( passCaughtEvent.catcherIndex ) );
		auto *pThrower = ToTFPlayer( UTIL_PlayerByIndex( passCaughtEvent.passerIndex ) );
		if ( pCatcher && pThrower ) 
		{
			if ( pCatcher->GetTeamNumber() == pThrower->GetTeamNumber() )
			{
				m_pEventText->EnqueuePass( pThrower, pCatcher );
			}
			else
			{
				m_pEventText->EnqueueInterception( pThrower, pCatcher );
			}
		}
	}
	else if ( FStrEq( pszEventName, PasstimeGameEvents::Score::s_eventName ) )
	{
		OnBallScore();
		PasstimeGameEvents::Score scoreEvent( pEvent );
		auto *pScorer = ToTFPlayer( UTIL_PlayerByIndex( scoreEvent.scorerIndex ) );
		auto *pAssister = ToTFPlayer( UTIL_PlayerByIndex( scoreEvent.assisterIndex ) );
		m_pEventText->EnqueueScore( pScorer, pAssister );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::Reset() 
{
	m_bReset = true;

	// delay the actual reset for a bit because Reset is called before
	// the game entities are settled into their new state (e.g. the ball
	// is about to be deleted).
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnBallFreeOther( C_TFPlayer *pOwner, 
	C_TFPlayer *pAttacker )
{
	Assert( m_bInitialized );	
	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetVisible( false );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnBallFreeSelf( C_TFPlayer *pOwner, 
	C_TFPlayer *pAttacker )
{
	Assert( m_bInitialized );	
	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetVisible( false );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnBallGetOther( int iPlayer )
{
	Assert( m_bInitialized );	
	Assert( g_PR );

	wchar_t wszFinalText[128];
	wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
	wchar_t *pwszFormatString = g_pVGuiLocalize->Find( "#TF_Passtime_CarrierName" );
	if ( !pwszFormatString )
	{
		pwszFormatString = L"%s1";
	}
	g_pVGuiLocalize->ConvertANSIToUnicode( ( iPlayer > 0 ) ? g_PR->GetPlayerName( iPlayer ) : "", wszPlayerName, sizeof( wszPlayerName ) );
	g_pVGuiLocalize->ConstructString_safe( wszFinalText, pwszFormatString, 1, wszPlayerName );

	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetText( wszFinalText );
		m_pProgressBallCarrierName->SetVisible( true );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnBallGetSelf( int iPlayer )
{
	Assert( m_bInitialized );	
	Assert( g_PR );

	wchar_t wszFinalText[128];
	wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
	wchar_t *pwszFormatString = g_pVGuiLocalize->Find( "#TF_Passtime_CarrierName" );
	if ( !pwszFormatString )
	{
		pwszFormatString = L"%s1";
	}
	g_pVGuiLocalize->ConvertANSIToUnicode( ( iPlayer > 0 ) ? g_PR->GetPlayerName( iPlayer ) : "", wszPlayerName, sizeof( wszPlayerName ) );
	g_pVGuiLocalize->ConstructString_safe( wszFinalText, pwszFormatString, 1, wszPlayerName );

	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetText( wszFinalText );
		m_pProgressBallCarrierName->SetVisible( true );
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstimeBallStatus::OnBallScore()
{
	Assert( m_bInitialized );	
	if ( m_pProgressBallCarrierName )
	{
		m_pProgressBallCarrierName->SetVisible( false );
	}
}

//-----------------------------------------------------------------------------
// CTFHudPasstime
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
CTFHudPasstime::CTFHudPasstime( Panel *pParent ) 
	: CTFHudPasstimePanel( pParent, "HudPasstime" )
	, m_pBallStatus( new CTFHudPasstimeBallStatus( this ) )
	, m_pTeamScore( new CTFHudTeamScore( this ) )
	, m_pBallOffscreenArrow( new CTFHudPasstimeBallOffscreenArrow( this ) )
	, m_pPassNotify( new CTFHudPasstimePassNotify( this ) )
{
	for ( int i = 0; i < MAX_PLAYERS; ++i )
	{
		m_pPlayerArrows[i] = new CTFHudPasstimePlayerOffscreenArrow( this, i );
	}
}

//-----------------------------------------------------------------------------
CTFHudPasstime::~CTFHudPasstime()
{
	// this is only called when the game quits, so don't bother deleting members
}

//-----------------------------------------------------------------------------
void CTFHudPasstime::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	LoadControlSettings( "resource/UI/HudPasstime.res", NULL, NULL, NULL );
	vgui::ivgui()->AddTickSignal( GetVPanel() );
	OnTick();
}

//-----------------------------------------------------------------------------
void CTFHudPasstime::Reset() 
{
	if ( m_pBallStatus )
	{
		m_pBallStatus->Reset();
	}
}

//-----------------------------------------------------------------------------
void CTFHudPasstime::OnTick() 
{
	if ( m_pTeamScore ) 
	{
		m_pTeamScore->SetVisible( IsVisible() );
	}
}