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

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

#include "cbase.h"
#include "iclientmode.h"
#include <vgui_controls/AnimationController.h>
#include <vgui_controls/EditablePanel.h>
#include <vgui_controls/ProgressBar.h>

#include "tf_gamerules.h"
#include "tf_logic_halloween_2014.h"
#include "c_tf_playerresource.h"
#include "tf_playerpanel.h"
#include "tf_teamstatus.h"
#include "tf_matchmaking_shared.h"
#include "tf_match_description.h"

using namespace vgui;

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


CTFTeamStatusPlayerPanel::CTFTeamStatusPlayerPanel( vgui::Panel *parent, const char *name ) : CTFPlayerPanel( parent, name )
{
	m_pHealthBar = new vgui::ContinuousProgressBar( this, "healthbar" );
	m_pOverhealBar = new vgui::ContinuousProgressBar( this, "overhealbar" );
	m_pClassImageBG = new vgui::Panel( this, "classimagebg" );
	m_pDeathFlag = new vgui::ImagePanel( this, "DeathPanel" );

	m_iTeam = TEAM_UNASSIGNED;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatusPlayerPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatusPlayerPanel::UpdateBorder( void )
{
	// do nothing
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFTeamStatusPlayerPanel::Update( void )
{
	if ( !g_TF_PR || !TFGameRules() )
		return false;

	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
	if ( !pLocalPlayer || ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM ) )
		return false;

	bool bChanged = false;
	bool bVisible = GetTeam() >= FIRST_GAME_TEAM;
	int iRespawnWait = -1;

	if ( IsVisible() != bVisible )
	{
		SetVisible( bVisible );
		bChanged = true;
	}

	if ( bVisible && g_TF_PR )
	{
		bool bSameTeamAsLocalPlayer = ( GetTeam() == g_TF_PR->GetTeam( pLocalPlayer->entindex() ) );

		// are we connected with a class?
		Assert( TF_CLASS_UNDEFINED == 0 );
		int iClass = -1;
		bool bAlive = false;
		int iHealth = -1;
		bool bIsLocalPlayer = false;
		if ( m_iPlayerIndex > 0 )
		{
			bIsLocalPlayer = pLocalPlayer->entindex() == m_iPlayerIndex;

			iClass = g_TF_PR->GetPlayerClass( m_iPlayerIndex );

			if ( iClass != TF_CLASS_UNDEFINED )
			{
				bAlive = g_TF_PR->IsAlive( m_iPlayerIndex );
			}
			if ( bAlive )
			{
				iHealth = g_TF_PR->GetHealth( m_iPlayerIndex );
			}

			// calc respawn time remaining
			if ( !bAlive && ( iClass != TF_CLASS_UNDEFINED ) )
			{
				float flRespawnAt = g_TF_PR->GetNextRespawnTime( m_iPlayerIndex );
				iRespawnWait = ( flRespawnAt - gpGlobals->curtime );
				if ( iRespawnWait <= 0 )
					iRespawnWait = -1;
			}

			// hide class info from the other team?
			if ( !bSameTeamAsLocalPlayer )
			{
				iClass = TF_CLASS_UNDEFINED;
			}
		}

		if ( m_iTeam != GetTeam() )
		{
			m_iTeam = GetTeam();
			bChanged = true;
		}

		if ( m_pClassImageBG )
		{
			if ( m_iTeam == TF_TEAM_RED )
			{
				Color bgColor( m_ColorPortraitBGRedLocalPlayer );
				if ( !bIsLocalPlayer )
				{
					bgColor = bAlive ? m_ColorPortraitBGRed : m_ColorPortraitBGRedDead;
				}
				
				m_pClassImageBG->SetBgColor( bgColor );
			}
			else
			{
				Color bgColor( m_ColorPortraitBGBlueLocalPlayer );
				if ( !bIsLocalPlayer )
				{
					bgColor = bAlive ? m_ColorPortraitBGBlue : m_ColorPortraitBGBlueDead;
				}
				m_pClassImageBG->SetBgColor( bgColor );
			}
		}

		// update live state
		if ( m_pClassImage )
		{
			if ( m_bPrevAlive != bAlive )
			{
				bChanged = true;
				m_bPrevAlive = bAlive;
				if ( !bAlive )
				{
					m_pClassImage->SetDrawColor( ( m_iTeam == TF_TEAM_RED ) ? m_ColorPortraitBlendDeadRed : m_ColorPortraitBlendDeadBlue );
				}

				m_pDeathFlag->SetImage( ( m_iTeam == TF_TEAM_RED ) ? "../HUD/comp_player_status" : "../HUD/comp_player_status_blue" );

				if ( bAlive )
				{
					g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "TeamStatus_PlayerAlive", false );
				}
				else
				{
					g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "TeamStatus_PlayerDead", false );
				}
			}

			// update class image
			if ( ( m_iPrevClass != iClass ) || bChanged )
			{
				bChanged = true;
				m_iPrevClass = iClass;
				if ( iClass < 0 )
				{
					m_pClassImage->SetImage( "hud_connecting" );
				}
				else if ( iClass == TF_CLASS_UNDEFINED )
				{
					int iDeadClass = g_TF_PR->GetPlayerClassWhenKilled( m_iPlayerIndex );
					if ( !bAlive && !bSameTeamAsLocalPlayer && ( m_iTeam >= FIRST_GAME_TEAM ) && ( iDeadClass > TF_CLASS_UNDEFINED ) )
					{
						m_pClassImage->SetImage( VarArgs( "%s_alpha", ( m_iTeam == TF_TEAM_RED ) ? g_pszItemClassImagesRed[iDeadClass + 9] : g_pszItemClassImagesBlue[iDeadClass + 9] ) );
					}
					else
					{
						m_pClassImage->SetImage( "class_portraits/silhouette_alpha" );
					}
				}
				else
				{
					if ( bAlive )
					{
						m_pClassImage->SetImage( VarArgs( "%s_alpha", ( m_iTeam == TF_TEAM_RED ) ? g_pszItemClassImagesRed[iClass] : g_pszItemClassImagesBlue[iClass] ) );
					}
					else
					{
						m_pClassImage->SetImage( VarArgs( "%s_alpha", ( m_iTeam == TF_TEAM_RED ) ? g_pszItemClassImagesRed[iClass + 9] : g_pszItemClassImagesBlue[iClass + 9] ) );

					}
				}
			}
		}

		// update health indicator
		if ( m_pHealthBar && m_pOverhealBar )
		{
			if ( iHealth != m_iPrevHealth )
			{
				m_iPrevHealth = iHealth;

				if ( ( iHealth > 0 ) && bSameTeamAsLocalPlayer )
				{
					float flMaxHealth = g_TF_PR->GetMaxHealth( m_iPlayerIndex );
					float flProgress = iHealth / flMaxHealth;

					// health bar
					if ( !m_pHealthBar->IsVisible() )
					{
						m_pHealthBar->SetVisible( true );
					}
					m_pHealthBar->SetProgress( ( flProgress >= 1.0f ) ? 1.0f : flProgress );

					if ( flProgress > m_flPercentageHealthMed )
					{
						m_pHealthBar->SetFgColor( m_ColorBarHealthHigh );
					}
					else if ( flProgress > m_flPercentageHealthLow )
					{
						m_pHealthBar->SetFgColor( m_ColorBarHealthMed );
					}
					else
					{
						m_pHealthBar->SetFgColor( m_ColorBarHealthLow );
					}

					// overheal bar
					if ( flProgress > 1.0f )
					{
						if ( !m_pOverhealBar->IsVisible() )
						{
							m_pOverhealBar->SetVisible( true );
						}
						m_pOverhealBar->SetProgress( flProgress - 1.0f );
					}
					else
					{
						if ( m_pOverhealBar->IsVisible() )
						{
							m_pOverhealBar->SetVisible( false );
						}
					}
				}
				else
				{
					if ( m_pHealthBar->IsVisible() )
					{
						m_pHealthBar->SetVisible( false );
					}

					if ( m_pOverhealBar->IsVisible() )
					{
						m_pOverhealBar->SetVisible( false );
					}
				}

				bChanged = true;
			}
		}

		// update respawn time
		if ( iRespawnWait != m_iPrevRespawnWait )
		{
			m_iPrevRespawnWait = iRespawnWait;
			if ( ( iRespawnWait < 0 ) || !bSameTeamAsLocalPlayer )
			{
				SetDialogVariable( "respawntime", "" );
			}
			else
			{
				SetDialogVariable( "respawntime", VarArgs( "%d", iRespawnWait ) );
			}

			bChanged = true;
		}

		// gamerules state
		if ( TFGameRules()->State_Get() != m_iPrevState )
		{
			m_iPrevState = TFGameRules()->State_Get();
			bChanged = true;
		}
	}

	return bChanged;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFTeamStatus::CTFTeamStatus( Panel *parent, const char *panelName ) : BaseClass( parent, panelName )
{
	m_pPlayerPanelKVs = NULL;
	m_bReapplyPlayerPanelKVs = false;

	Reset();

	ivgui()->AddTickSignal( GetVPanel(), 100 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFTeamStatus::~CTFTeamStatus()
{
	if ( m_pPlayerPanelKVs )
	{
		m_pPlayerPanelKVs->deleteThis();
		m_pPlayerPanelKVs = NULL;
	}
}

void SetGrowDir( CTFTeamStatus::EGrowDir* pGrowDir, const char* pszString )
{
	if ( FStrEq( pszString, "east" ) )
	{
		(*pGrowDir) = CTFTeamStatus::EGrowDir::GROW_EAST;
	}
	else if ( FStrEq( pszString, "west" ) )
	{
		(*pGrowDir) = CTFTeamStatus::EGrowDir::GROW_WEST;
	}
	else
	{
		Assert( !"Invalid direction string for team status team grow direction" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	SetGrowDir( &m_eTeam1GrowDir, inResourceData->GetString( "team1_grow_dir" ) );
	SetGrowDir( &m_eTeam2GrowDir, inResourceData->GetString( "team2_grow_dir" ) );

	KeyValues *pItemKV = inResourceData->FindKey( "playerpanels_kv" );
	if ( pItemKV )
	{
		if ( m_pPlayerPanelKVs )
		{
			m_pPlayerPanelKVs->deleteThis();
		}
		m_pPlayerPanelKVs = new KeyValues( "playerpanels_kv" );
		pItemKV->CopySubkeys( m_pPlayerPanelKVs );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	m_bReapplyPlayerPanelKVs = true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::PerformLayout( void )
{
	BaseClass::PerformLayout();

	int iTeam1Count = 0;
	int iTeam2Count = 0;

	// Tally up how many are on each team so we can scale them appropriately down below
	for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
	{
		if ( m_PlayerPanels[i]->GetTeam() == TF_TEAM_BLUE )
		{
			++iTeam1Count;
		}
		else if ( m_PlayerPanels[i]->GetTeam() == TF_TEAM_RED )
		{
			++iTeam2Count;
		}
	}

	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();

	// Snag local player info
	int nLocalPlayerTeam = TF_TEAM_COUNT;
	int nLocalPlayerIndex = -1;
	if ( pLocalPlayer )
	{
		nLocalPlayerIndex = pLocalPlayer->entindex();
		nLocalPlayerTeam = pLocalPlayer->GetTeamNumber();
	}

	int iTeam1Processed = 0;
	int iTeam2Processed = 0;

	for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
	{
		if ( m_PlayerPanels[i]->GetPlayerIndex() <= 0 )
		{
			m_PlayerPanels[i]->SetVisible( false );
			continue;
		}

		bool bIsLocalPlayerPanel = nLocalPlayerIndex == m_PlayerPanels[i]->GetPlayerIndex();
		int iTeam = m_PlayerPanels[i]->GetTeam();
		int iXPos = 0;

		// Setup vars
		EGrowDir& eGrowDir	= iTeam == TF_TEAM_BLUE ? m_eTeam1GrowDir	: m_eTeam2GrowDir;
		int& iTeamCount		= iTeam == TF_TEAM_BLUE ? iTeam1Count		: iTeam2Count;
		int& iBaseX			= iTeam == TF_TEAM_BLUE ? m_iTeam1BaseX		: m_iTeam2BaseX;
		int& iProcessed		= iTeam == TF_TEAM_BLUE ? iTeam1Processed	: iTeam2Processed;
		int& iMaxExpand		= iTeam == TF_TEAM_BLUE ? m_iTeam1MaxExpand	: m_iTeam2MaxExpand;
		const int iGap		= RemapValClamped( iTeamCount, 6, 12, m_i6v6Gap, m_i12v12Gap );

		// Local player is always the innermost panel
		int nTeamPanelIndex = bIsLocalPlayerPanel ? 0
							: iTeam == nLocalPlayerTeam ? iProcessed + 1 
							: iProcessed;

		// Setup X-position and widths
		// Use the max width if less than 6 (to fill out the space)
		int nNewWide = iTeamCount <= 6 ? m_iMaxSize : ( iMaxExpand - ( iGap * ( iTeamCount - 1 ) ) ) / iTeamCount;

		// How far each panel is apart from each other
		const int iXStep = iGap + nNewWide;
		// How many steps out this panel should be
		const int iXOffset = iXStep * nTeamPanelIndex;
		// Step out the panels by the step
		iXPos = eGrowDir == GROW_EAST ? iBaseX + iXOffset				// Align the left edge of the left-most panel on the specified point
			  : eGrowDir == GROW_WEST ? iBaseX - iXOffset - nNewWide	// Align the right edge of the right-most panel on the specified point
			  : 0;

		// This is expensive, so only do it if we need to
		if ( nNewWide != m_PlayerPanels[i]->GetWide() )
		{
			// We change the width in the KV's then reapply settings so the children will do their
			// magical proportionaltoparent layout.
			if ( m_pPlayerPanelKVs )
			{
				m_pPlayerPanelKVs->SetInt( "wide", scheme()->GetProportionalNormalizedValueEx( GetScheme(), nNewWide ) );
				m_PlayerPanels[i]->ApplySettings( m_pPlayerPanelKVs );
				m_PlayerPanels[i]->InvalidateLayout( false, true );
				m_PlayerPanels[i]->Update();
			}
		}

		if ( !bIsLocalPlayerPanel )
		{
			++iProcessed;
		}

		m_PlayerPanels[i]->SetPos( iXPos, m_PlayerPanels[i]->GetYPos() );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::Reset()
{
	for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
	{
		m_PlayerPanels[i]->Reset();
	}

	InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFTeamStatus::ShouldDraw( void )
{
	// Get the player and active weapon.
	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();

	if ( !pPlayer )
		return false;

	int iLocalTeam = g_TF_PR->GetTeam( pPlayer->entindex() );
	if ( iLocalTeam < FIRST_GAME_TEAM )
		return false;

	if ( TFGameRules() )
	{
		const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
		if ( !pMatchDesc || !pMatchDesc->m_params.m_bUseMatchHud )
			return false;

		if ( TFGameRules()->ShowMatchSummary() )
			return false; 
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::OnTick()
{
	if ( IsVisible() != ShouldDraw() )
	{
		SetVisible( ShouldDraw() );
	}

	if ( IsVisible() )
	{
		RecalculatePlayerPanels();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFTeamStatusPlayerPanel *CTFTeamStatus::GetOrAddPanel( int iPanelIndex )
{
	if ( iPanelIndex < m_PlayerPanels.Count() )
	{
		return m_PlayerPanels[iPanelIndex];
	}
	Assert( iPanelIndex == m_PlayerPanels.Count() );
	CTFTeamStatusPlayerPanel *pPanel = new CTFTeamStatusPlayerPanel( this, VarArgs( "playerpanel%d", iPanelIndex ) );
	if ( m_pPlayerPanelKVs )
	{
		pPanel->ApplySettings( m_pPlayerPanelKVs );
		pPanel->InvalidateLayout( false, true );
		InvalidateLayout();
	}
	m_PlayerPanels.AddToTail( pPanel );
	return pPanel;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::RecalculatePlayerPanels( void )
{
	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
	if ( !pPlayer || !g_TF_PR )
		return;

	int iPanel = 0;
	bool bNeedsLayout = false;
	int iLocalTeam = g_TF_PR->GetTeam( pPlayer->entindex() );
	if ( iLocalTeam >= FIRST_GAME_TEAM )
	{
		for ( int i = 1; i <= MAX_PLAYERS; i++ )
		{
			if ( !g_TF_PR->IsConnected( i ) )
				continue;

			int iTeam = g_TF_PR->GetTeam( i );
			if ( iTeam < FIRST_GAME_TEAM )
				continue;

			// Add an entry
			CTFTeamStatusPlayerPanel *pPanel = GetOrAddPanel( iPanel );

			if ( pPanel->GetPlayerIndex() != i )
			{
				bNeedsLayout = true;
			}

			pPanel->SetPlayerIndex( i );

			if ( pPanel->GetPreviousTeam() != pPanel->GetTeam() )
			{
				bNeedsLayout = true;
			}

			++iPanel;
		}
	}

	// Clear out any extra panels
	for ( int i = iPanel; i < m_PlayerPanels.Count(); i++ )
	{
		if ( m_PlayerPanels[i]->GetPlayerIndex() != 0 )
		{
			bNeedsLayout = true;
		}

		m_PlayerPanels[i]->SetPlayerIndex( 0 );
	}

	UpdatePlayerPanels();

	if ( bNeedsLayout )
	{
		InvalidateLayout();	
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFTeamStatus::UpdatePlayerPanels( void )
{
	if ( !g_TF_PR )
		return;

	for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
	{
		m_PlayerPanels[i]->Update();
	}
}