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

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: HUD Target ID element
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_hud_target_id.h"
#include "c_tf_playerresource.h"
#include "iclientmode.h"
#include "vgui/ILocalize.h"
#include "c_baseobject.h"
#include "c_team.h"
#include "tf_gamerules.h"
#include "tf_hud_statpanel.h"
#if defined( REPLAY_ENABLED )
#include "replay/iclientreplaycontext.h"
#include "replay/ireplaymoviemanager.h"
#include "replay/ienginereplay.h"
#endif // REPLAY_ENABLED
#include "tf_weapon_bonesaw.h"
#include "sourcevr/isourcevirtualreality.h"
#include "tf_revive.h"
#include "tf_logic_robot_destruction.h"
#include "entity_capture_flag.h"
#include "vgui_avatarimage.h"

#include "VGuiMatSurface/IMatSystemSurface.h"
#include "renderparm.h"

#include "tf_dropped_weapon.h"
#include "econ/econ_item_description.h"

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

extern ConVar cl_hud_minmode;

DECLARE_HUDELEMENT( CMainTargetID );
DECLARE_HUDELEMENT( CSpectatorTargetID );
DECLARE_HUDELEMENT( CSecondaryTargetID );

using namespace vgui;

enum
{
	SPECTATOR_TARGET_ID_NORMAL = 0,
	SPECTATOR_TARGET_ID_BOTTOM_LEFT,
	SPECTATOR_TARGET_ID_BOTTOM_CENTER,
	SPECTATOR_TARGET_ID_BOTTOM_RIGHT,
};

void SpectatorTargetLocationCallback( IConVar *var, const char *oldString, float oldFloat )
{
	CSpectatorTargetID *pSpecTargetID = (CSpectatorTargetID *)GET_HUDELEMENT( CSpectatorTargetID );
	if ( pSpecTargetID )
	{
		pSpecTargetID->InvalidateLayout();
	}
}
ConVar tf_spectator_target_location( "tf_spectator_target_location", "0", FCVAR_ARCHIVE, "Determines the location of the spectator targetID panel.", true, 0, true, 3, SpectatorTargetLocationCallback );
ConVar tf_hud_target_id_disable_floating_health( "tf_hud_target_id_disable_floating_health", "0", FCVAR_ARCHIVE, "Set to disable floating health bar" );
ConVar tf_hud_target_id_alpha( "tf_hud_target_id_alpha", "100", FCVAR_ARCHIVE, "Alpha value of target id background, default 100" );
ConVar tf_hud_target_id_offset( "tf_hud_target_id_offset", "0", FCVAR_ARCHIVE, "RES file Y offset for target id" );
ConVar tf_hud_target_id_show_avatars( "tf_hud_target_id_show_avatars", "2", FCVAR_ARCHIVE, "Display Steam avatars on TargetID when using floating health icons.  1 = everyone, 2 = friends only." );

#ifdef STAGING_ONLY
ConVar tf_bountymode_showhealth( "tf_bountymode_showhealth", "0", FCVAR_ARCHIVE, "Show floating health icon over enemy players.  1 = show health, 2 = show health and level", true, 0, true, 2 );
#endif // STAGING_ONLY

bool ShouldHealthBarBeVisible( CBaseEntity *pTarget, CTFPlayer *pLocalPlayer )
{
	if ( !pTarget || !pLocalPlayer )
		return false;

	if ( tf_hud_target_id_disable_floating_health.GetBool() )
		return false;

	if ( pTarget->IsHealthBarVisible() )
		return true;

	if ( !pTarget->IsPlayer() )
		return false;

	if ( pLocalPlayer->IsPlayerClass( TF_CLASS_SPY ) )
		return true;

	if ( pLocalPlayer->InSameTeam( pTarget ) )
		return true;

	if ( pLocalPlayer->InSameDisguisedTeam( pTarget ) )
		return true;

	

	int iSeeEnemyHealth = 0;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLocalPlayer, iSeeEnemyHealth, see_enemy_health )
	if ( iSeeEnemyHealth )
		return true;
	
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTargetID::CTargetID( const char *pElementName ) :
	CHudElement( pElementName ), BaseClass( NULL, pElementName )
{
	vgui::Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );

	m_hFont = g_hFontTrebuchet24;
	m_flLastChangeTime = 0;
	m_iLastEntIndex = 0;
	m_nOriginalY = 0;
	m_bArenaPanelVisible = false;

	SetHiddenBits( HIDEHUD_MISCSTATUS );

	m_pTargetNameLabel = NULL;
	m_pTargetDataLabel = NULL;
	m_pBGPanel = NULL;
	m_pMoveableIcon = NULL;
	m_pMoveableSymbolIcon = NULL;
	m_pMoveableIconBG = NULL;
	m_pMoveableKeyLabel = NULL;
	m_pTargetHealth = new CTFSpectatorGUIHealth( this, "SpectatorGUIHealth" );
	m_pTargetAmmoIcon = NULL;
	m_pTargetKillStreakIcon = NULL;
	m_bLayoutOnUpdate = false;

	m_pFloatingHealthIcon = NULL;
	m_iLastScannedEntIndex = 0;
	m_pAvatarImage = NULL;

	RegisterForRenderGroup( "mid" );
	RegisterForRenderGroup( "commentary" );

	m_iRenderPriority = 5;

	ListenForGameEvent( "show_class_layout" );
	RegisterForRenderGroup( "arena_target_id" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTargetID::LevelShutdown( void )
{
	if ( m_pFloatingHealthIcon )
	{
		m_pFloatingHealthIcon->MarkForDeletion();
		m_pFloatingHealthIcon = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Setup
//-----------------------------------------------------------------------------
void CTargetID::Reset( void )
{
	m_pTargetHealth->Reset();

	vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
	if ( pScheme )
	{
		m_LabelColorDefault = pScheme->GetColor( "Label.TextColor", Color( 255, 255, 255, 255 ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTargetID::FireGameEvent( IGameEvent * event )
{
	const char *eventName = event->GetName();

	if ( FStrEq( "show_class_layout", eventName ) )
	{
		if ( TFGameRules() && TFGameRules()->IsInArenaMode() && GetLocalPlayerTeam() > LAST_SHARED_TEAM )
		{
			m_bArenaPanelVisible = event->GetBool( "show", false );
		}
		else
		{
			m_bArenaPanelVisible = false;
		}

		InvalidateLayout( true );
	}
}

//-----------------------------------------------------------------------------
bool CTargetID::DrawHealthIcon() 
{
	C_BaseEntity *pEnt = cl_entitylist->GetEnt( GetTargetIndex() );
	if ( pEnt && pEnt->IsBaseObject() )
		return true;

	if ( tf_hud_target_id_disable_floating_health.GetBool() )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Find out which player to pull an avatar image from.  pTFPlayer is the player under the crosshair.
//-----------------------------------------------------------------------------
C_TFPlayer *CTargetID::GetTargetForSteamAvatar( C_TFPlayer *pTFPlayer )
{
	if ( !tf_hud_target_id_show_avatars.GetBool() )
		return NULL;

	if ( !pTFPlayer || ( g_TF_PR && g_TF_PR->IsFakePlayer( pTFPlayer->entindex() ) ) )
		return NULL;

	C_TFPlayer *pTFLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pTFLocalPlayer )
		return NULL;

	// Health icon inside the panel (too busy - figure this out later)
	if ( DrawHealthIcon() )
		return NULL;

	// Save room when healing or being healed
	if ( pTFLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && pTFLocalPlayer->MedicGetHealTarget() == pTFPlayer )
		return NULL;
	
	C_TFPlayer *pTFHealer = NULL;
	float flHealerChargeLevel = -1.f;
	pTFLocalPlayer->GetHealer( &pTFHealer, &flHealerChargeLevel );
	if ( pTFHealer && pTFHealer->entindex() == m_iTargetEntIndex )
		return NULL;

	if ( pTFPlayer->IsPlayerClass( TF_CLASS_SPY ) && pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
	{
		C_TFPlayer *pDisguiseTarget = ToTFPlayer( pTFPlayer->m_Shared.GetDisguiseTarget() );
		if ( pDisguiseTarget && ( pTFLocalPlayer->InSameTeam( pDisguiseTarget ) || pDisguiseTarget == pTFLocalPlayer ) )
		{
			// Bots don't (currently) have avatars.
			if ( pDisguiseTarget->IsBot() )
				return NULL;

			if ( tf_hud_target_id_show_avatars.GetInt() == 2 && !pTFLocalPlayer->IsPlayerOnSteamFriendsList( pDisguiseTarget ) )
				return NULL;

			return pDisguiseTarget;
		}
	}

	if ( pTFLocalPlayer->IsPlayerOnSteamFriendsList( pTFPlayer ) )
		return pTFPlayer;

	if ( tf_hud_target_id_show_avatars.GetInt() == 1 )
		return pTFPlayer;

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTargetID::ApplySchemeSettings( vgui::IScheme *scheme )
{
	LoadControlSettings( "resource/UI/TargetID.res" );

	BaseClass::ApplySchemeSettings( scheme );

	m_pTargetNameLabel = dynamic_cast<Label *>(FindChildByName("TargetNameLabel"));
	m_pTargetDataLabel = dynamic_cast<Label *>(FindChildByName("TargetDataLabel"));
	m_pBGPanel =  dynamic_cast<CTFImagePanel *> ( FindChildByName("TargetIDBG") );
	m_pMoveableSubPanel = dynamic_cast<vgui::EditablePanel *> ( FindChildByName("MoveableSubPanel") );
	if ( m_pMoveableSubPanel )
	{
		m_pMoveableIcon = dynamic_cast<CIconPanel *> ( m_pMoveableSubPanel->FindChildByName("MoveableIcon") );
		m_pMoveableSymbolIcon = dynamic_cast<vgui::ImagePanel *> ( m_pMoveableSubPanel->FindChildByName("MoveableSymbolIcon") );
		m_pMoveableIconBG = dynamic_cast<CIconPanel *> ( m_pMoveableSubPanel->FindChildByName("MoveableIconBG") );
		m_pMoveableKeyLabel = dynamic_cast<Label *>( m_pMoveableSubPanel->FindChildByName("MoveableKeyLabel") );
	}
	m_hFont = scheme->GetFont( "TargetID", true );
	m_pTargetAmmoIcon = dynamic_cast<vgui::ImagePanel *>( FindChildByName( "AmmoIcon" ) );
	m_pTargetKillStreakIcon = dynamic_cast<vgui::ImagePanel *>( FindChildByName( "KillStreakIcon" ) );
	m_pAvatarImage = dynamic_cast< CAvatarImagePanel* >( FindChildByName( "AvatarImage" ) );
}

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

	m_iRenderPriority = inResourceData->GetInt( "priority" );

	int x;
	GetPos( x, m_nOriginalY );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTargetID::GetRenderGroupPriority( void )
{
	return m_iRenderPriority;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTargetID::UpdateFloatingHealthIconVisibility( bool bVisible )
{
	if ( m_pFloatingHealthIcon && ( m_pFloatingHealthIcon->IsVisible() != bVisible ) )
	{
		m_pFloatingHealthIcon->SetVisible( bVisible );
	}
}

//-----------------------------------------------------------------------------
// Purpose: clear out string etc between levels
//-----------------------------------------------------------------------------
void CTargetID::VidInit()
{
	CHudElement::VidInit();

	m_flLastChangeTime = 0;
	m_iLastEntIndex = 0;
}

bool CTargetID::IsValidIDTarget( int nEntIndex, float flOldTargetRetainFOV, float &flNewTargetRetainFOV )
{
	bool bReturn = false;
	flNewTargetRetainFOV = 0.0f;

	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
		return false;

#ifdef STAGING_ONLY
	if ( pLocalTFPlayer->m_Shared.InCond( TF_COND_STEALTHED_PHASE ) )
		return false;
#endif // STAGING_ONLY

	if ( nEntIndex )
	{
		C_BaseEntity *pEnt = cl_entitylist->GetEnt( nEntIndex );
		if ( pEnt )
		{
			Vector vDiff = pEnt->EyePosition() - pLocalTFPlayer->EyePosition();
			float flDist;
			flDist = VectorNormalize( vDiff );

			if ( flOldTargetRetainFOV != 0.0f )
			{
				// It has a FOV that maintains previous targets
				Vector vForward;
				pLocalTFPlayer->EyeVectors( &vForward );

				float fAngle = 1.0f - vDiff.Dot( vForward );
				fAngle = RemapVal( fAngle, 0.0f, 1.0f, 0.0f, 90.0f );

				if ( fAngle > flOldTargetRetainFOV )
				{
					return false;
				}
			}

			C_TFPlayer *pPlayer = ToTFPlayer( pEnt );

			int iHideEnemyHealth = 0;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLocalTFPlayer, iHideEnemyHealth, hide_enemy_health );

			bool bInSameTeam = pLocalTFPlayer->InSameDisguisedTeam( pEnt );	
			bool bSpy = pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) && iHideEnemyHealth == 0;

			if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
			{
				// We don't want to show health bars to the spy in MVM because it's distracting
				bSpy = false;

				// Are we disguised as the enemy?
				if ( pLocalTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pLocalTFPlayer->m_Shared.GetDisguiseTeam() != pLocalTFPlayer->GetTeamNumber() )
				{
					// Get the target's apparent team
					int iTheirApparentTeam = pEnt->GetTeamNumber();
					if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
					{
						iTheirApparentTeam = pPlayer->m_Shared.GetDisguiseTeam();
					}

					// Are we disguised as they appear?
					if ( pLocalTFPlayer->m_Shared.GetDisguiseTeam() == iTheirApparentTeam )
					{
						// Don't show the health
						bInSameTeam = false;
					}
				}
			}

			bool bSpectator = pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR;
			int iSeeEnemyHealth = 0;
			bool bStealthed = false;
			bool bHealthBarVisible = ShouldHealthBarBeVisible( pEnt, pLocalTFPlayer );
			bool bShow = bHealthBarVisible;

			if ( pPlayer )
			{
				if ( pPlayer->m_Shared.IsStealthed() )
				{
					bStealthed = true;
					bHealthBarVisible = false;
					bShow = false;
				}

				if ( !bStealthed )
				{
					CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLocalTFPlayer, iSeeEnemyHealth, see_enemy_health );
				}

				bool bMaintainInFOV = !pLocalTFPlayer->InSameTeam( pEnt );

				if ( bHealthBarVisible )
				{
					bool bEnemyPlayer = pPlayer->GetTeamNumber() != pLocalTFPlayer->GetTeamNumber();
					bool bEnemyMiniBoss = pPlayer->IsMiniBoss() && bEnemyPlayer;
					bShow = bEnemyMiniBoss;
#ifdef STAGING_ONLY
					bShow |= TFGameRules() && TFGameRules()->IsBountyMode() && tf_bountymode_showhealth.GetInt() && bEnemyPlayer;
#endif // STAGING_ONLY

					if ( bShow )
					{
						bMaintainInFOV = false;

						// Minibosses keep the health indicator up within a small FOV until a different valid target is selected
						// The FOV needs to grow exponentially when a target is getting near
						if ( bEnemyMiniBoss )
						{
							bMaintainInFOV = true;
						}
					}
				}

				if ( bMaintainInFOV )
				{
					const float flMaxDist = 800.0f;
					float fInterp = RemapVal( flMaxDist - MIN( flDist, flMaxDist ), 0.0f, flMaxDist, 0.0f, 1.0f );
					fInterp *= fInterp;
					flNewTargetRetainFOV = fInterp * 13.0f + 0.75f;
				}

				bReturn = ( bSpectator || pLocalTFPlayer->InSameTeam( pEnt ) || ( ( bInSameTeam || bSpy || iSeeEnemyHealth ) && !bStealthed ) );
			}


			if ( bShow || bHealthBarVisible )
			{
				// See if we're re-targeting our previous
				if ( m_pFloatingHealthIcon )
				{
					if ( m_pFloatingHealthIcon->GetEntity() && m_pFloatingHealthIcon->GetEntity() == pEnt )
					{
						UpdateFloatingHealthIconVisibility( true );
					}
					else
					{
						// New target - clear previous
						m_pFloatingHealthIcon->MarkForDeletion();
						m_pFloatingHealthIcon = NULL;
					}
				}

				//Recreate the floating health icon if there isn't one, we're not a spectator, and 
				// we're not a spy or this was a robot from Robot Destruction-Mode
				if ( !m_pFloatingHealthIcon && !bSpectator && ( !bSpy || bHealthBarVisible ) && !DrawHealthIcon() )
				{
					m_pFloatingHealthIcon = CFloatingHealthIcon::AddFloatingHealthIcon( pEnt );
				}
			}
			else if ( pEnt->IsBaseObject() && ( bInSameTeam || bSpy ) )
			{
				bReturn = true;
			}
			else if ( pEnt->IsVisibleToTargetID() )
			{
				bReturn = true;
			}
			else
			{
				UpdateFloatingHealthIconVisibility( false );
			}
		}
	}

	return bReturn;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTargetID::ShouldDraw( void )
{
	if ( !CHudElement::ShouldDraw() )
	{
		UpdateFloatingHealthIconVisibility( false );
		return false;
	}

	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
	{
		UpdateFloatingHealthIconVisibility( false );
		return false;
	}

	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
	{
		UpdateFloatingHealthIconVisibility( false );
		return false;
	}

	if ( pLocalTFPlayer->IsTaunting() )
	{
		UpdateFloatingHealthIconVisibility( false );
		return false;
	}

	// Get our target's ent index
	m_iTargetEntIndex = CalculateTargetIndex(pLocalTFPlayer);
	if ( !m_iTargetEntIndex )
	{
		if ( m_flTargetRetainFOV == 0.0f )
		{
			// Check to see if we should clear our ID
			if ( m_flLastChangeTime && ( gpGlobals->curtime > m_flLastChangeTime ) )
			{
				m_flLastChangeTime = 0;
				m_iLastEntIndex = 0;
			}
			else
			{
				// Keep re-using the old one
				m_iTargetEntIndex = m_iLastEntIndex;
			}
		}

		// If we're showing a floating health icon, and no longer have a target,
		// hide it and see if it's the same entity next time
		UpdateFloatingHealthIconVisibility( false );
	}
	else
	{
		m_flLastChangeTime = gpGlobals->curtime;

		if ( m_iTargetEntIndex != m_iLastScannedEntIndex )
		{
			// If we switched to another, valid target for a floating health icon, recreate it on the next pass
			if ( m_pFloatingHealthIcon )
			{
				m_pFloatingHealthIcon->MarkForDeletion();
				m_pFloatingHealthIcon = NULL;
			}
			m_iLastScannedEntIndex = m_iTargetEntIndex;
		}
	}

	float flTargetRetainFOV = 0.0f;
	bool bReturn = IsValidIDTarget( m_iTargetEntIndex, 0.0f, flTargetRetainFOV );

	if ( !bReturn )
	{
		m_iLastEntIndex = 0;
	}
	else
	{
		if ( !IsVisible() || (m_iTargetEntIndex != m_iLastEntIndex) )
		{
			m_iLastEntIndex = m_iTargetEntIndex;
			m_bLayoutOnUpdate = true;
			m_flTargetRetainFOV = flTargetRetainFOV;
			if ( m_pAvatarImage )
			{
				m_pAvatarImage->SetVisible( false );
			}
		}

		UpdateID();
	}

	return bReturn;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTargetID::PerformLayout( void )
{
	int iXIndent = XRES(5);
	int iXPostdent = XRES(10);
	int iWidth = iXIndent + iXPostdent;
	if ( DrawHealthIcon() )
	{
		iWidth += m_pTargetHealth->GetWide();
	}
	if ( m_pAvatarImage && m_pAvatarImage->IsVisible() )
	{
		iWidth += m_pAvatarImage->GetWide() + XRES( 2 );
	}

	int iTextW, iTextH;
	int iDataW, iDataH;

	if ( m_pTargetNameLabel && m_pTargetDataLabel )
	{
		m_pTargetNameLabel->GetContentSize( iTextW, iTextH );
		m_pTargetDataLabel->GetContentSize( iDataW, iDataH );
		iWidth += MAX(iTextW,iDataW);

		if ( m_pBGPanel )
		{
			m_pBGPanel->SetSize( iWidth, GetTall() );
		}

		int x1 = 0, y1 = 0;
		int x2 = 0, y2 = 0;
		int x3 = 0, y3 = 0;
		m_pTargetNameLabel->GetPos( x1, y1 );
		m_pTargetDataLabel->GetPos( x2, y2 );
		if ( m_pTargetKillStreakIcon )
		{
			m_pTargetKillStreakIcon->GetPos( x3, y3 );
		}
		
		int iWideExtra = 0;
		if ( DrawHealthIcon() )
		{
			iWideExtra += m_pTargetHealth->GetWide();
		}
		if ( m_pAvatarImage && m_pAvatarImage->IsVisible() )
		{
			iWideExtra += m_pAvatarImage->GetWide() + XRES( 4 );
		}

		int nBuffer = ( m_pAvatarImage && m_pAvatarImage->IsVisible() ) ? 6 : 8;
		m_pTargetNameLabel->SetPos( XRES( nBuffer ) + iWideExtra, y1 );
		m_pTargetDataLabel->SetPos( XRES( nBuffer ) + iWideExtra, y2 );

		if ( m_pTargetKillStreakIcon )
		{
			int nKSBuffer = ( cl_hud_minmode.GetBool() ) ? 6 : 9;
			m_pTargetKillStreakIcon->SetPos( XRES( nKSBuffer ) + iWideExtra, y3 );
		}
	}

	// Put the moveable icon to the right hand of our panel
	if ( m_pMoveableSubPanel && m_pMoveableSubPanel->IsVisible() )
	{
		if ( m_pMoveableKeyLabel && m_pMoveableIcon && m_pMoveableSymbolIcon && m_pMoveableIconBG )
		{
			m_pMoveableKeyLabel->SizeToContents();

			int iIndent = XRES(4);
			int iMoveWide = MAX( XRES(16) + m_pMoveableKeyLabel->GetWide() + iIndent, (m_pMoveableIcon->GetWide()) + iIndent + XRES(8) );
			m_pMoveableKeyLabel->SetWide( iMoveWide );
			m_pMoveableSubPanel->SetSize( iMoveWide, GetTall() );
			m_pMoveableSubPanel->SetPos( iWidth - iIndent, 0 );

			int x,y;
			m_pMoveableKeyLabel->GetPos( x, y );
			m_pMoveableSymbolIcon->SetPos( (iMoveWide - m_pMoveableSymbolIcon->GetWide()) * 0.5, y - m_pMoveableSymbolIcon->GetTall() );
			m_pMoveableSymbolIcon->GetPos( x, y );
			m_pMoveableIcon->SetPos( (iMoveWide - m_pMoveableIcon->GetWide()) * 0.5, y - m_pMoveableIcon->GetTall() );
			m_pMoveableIconBG->SetSize( m_pMoveableSubPanel->GetWide(), m_pMoveableSubPanel->GetTall() );
		}
	}

	if ( m_pMoveableSubPanel && m_pMoveableSubPanel->IsVisible() )
	{
		// Now add our extra width to the total size
		iWidth += m_pMoveableSubPanel->GetWide();
	}

	SetSize( iWidth, GetTall() );

	int nOffset = m_bArenaPanelVisible ? YRES (120) : 0; // HACK: move the targetID up a bit so it won't overlap the panel
	if( UseVR() )
	{
		SetPos( ScreenWidth() - iWidth - m_iXOffset,  m_nOriginalY - nOffset + YRES( tf_hud_target_id_offset.GetInt() ) );
	}
	else
	{
		SetPos( (ScreenWidth() - iWidth) * 0.5,  m_nOriginalY - nOffset + YRES( tf_hud_target_id_offset.GetInt() ) );
	}
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTargetID::CalculateTargetIndex( C_TFPlayer *pLocalTFPlayer ) 
{ 
	int iIndex = pLocalTFPlayer->GetIDTarget(); 

	// If our target entity is already in our secondary ID, don't show it in primary.
	CSecondaryTargetID *pSecondaryID = GET_HUDELEMENT( CSecondaryTargetID );
	if ( pSecondaryID && pSecondaryID != this && pSecondaryID->GetTargetIndex() == iIndex )
	{
		iIndex = 0;
	}

	return iIndex;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTargetID::UpdateID( void )
{
	wchar_t sIDString[ MAX_ID_STRING ] = L"";
	wchar_t sDataString[ MAX_ID_STRING ] = L"";

	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
		return;

	// Default the labels' colors
	Color colorName = m_LabelColorDefault;
	Color colorData = m_LabelColorDefault;

	// Get our target's ent index
	// Is this an entindex sent by the server?
	if ( m_iTargetEntIndex )
	{
		C_BaseEntity *pEnt = cl_entitylist->GetEnt( m_iTargetEntIndex );
		if ( !pEnt )
			return;

		bool bShowHealth = false;
		float flHealth = 0;
		float flMaxHealth = 1;
		int iMaxBuffedHealth = 0;
		int iTargetTeam = pEnt->GetTeamNumber();
		const char *pszActionCommand = NULL;
		const char *pszActionIcon = NULL;

		m_pTargetHealth->SetBuilding( false );
		m_pTargetHealth->SetLevel( -1 );

		// Some entities we always want to check, cause the text may change
		// even while we're looking at it
		// Is it a player?
		if ( IsPlayerIndex( m_iTargetEntIndex ) )
		{
			const char *printFormatString = NULL;
			wchar_t wszPlayerName[ MAX_PLAYER_NAME_LENGTH ];
			bool bDisguisedTarget = false;
			bool bDisguisedEnemy = false;

			C_TFPlayer *pPlayer = static_cast<C_TFPlayer*>( pEnt );
			if ( !pPlayer )
				return;

			C_TFPlayer *pDisguiseTarget = NULL;
			g_pVGuiLocalize->ConvertANSIToUnicode( pPlayer->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );

			// determine if the target is a disguised spy (either friendly or enemy)
			if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && // they're disguised
				//!pPlayer->m_Shared.InCond( TF_COND_DISGUISING ) && // they're not in the process of disguising
				!pPlayer->m_Shared.IsStealthed() ) // they're not cloaked
			{
				bDisguisedTarget = true;
				pDisguiseTarget = ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() );

				if ( pLocalTFPlayer->InSameTeam( pEnt ) == false )
				{
					iTargetTeam = pPlayer->m_Shared.GetDisguiseTeam();
				}
			}

			if ( bDisguisedTarget )
			{
				// is the target a disguised enemy spy?
				if ( pPlayer->IsEnemyPlayer() )
				{
					if ( pDisguiseTarget )
					{
						bDisguisedEnemy = true;
						// change the player name
						g_pVGuiLocalize->ConvertANSIToUnicode( pDisguiseTarget->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
						// change the team  / team color
					}
				}
			}

			bool bInSameTeam = pLocalTFPlayer->InSameDisguisedTeam( pEnt );
			bool bSpy = pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY );
			bool bMedic = pLocalTFPlayer->IsPlayerClass( TF_CLASS_MEDIC );
			bool bHeavy = pLocalTFPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS );

			// See if the player wants to fill in the data string
			bool bIsAmmoData = false;
			bool bIsKillStreakData = false;
			pPlayer->GetTargetIDDataString( bDisguisedTarget, sDataString, sizeof(sDataString), bIsAmmoData, bIsKillStreakData );
			if ( pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR || bInSameTeam || bSpy || bDisguisedEnemy || bMedic || bHeavy )
			{
				printFormatString = "#TF_playerid_sameteam";
				bShowHealth = true;
			}
			else if ( pLocalTFPlayer->m_Shared.GetState() == TF_STATE_DYING )
			{
				// We're looking at an enemy who killed us.
				printFormatString = "#TF_playerid_diffteam";
				bShowHealth = true;
			}			

			if ( bShowHealth )
			{
				if ( g_TF_PR )
				{
					if ( bDisguisedEnemy )
					{
						flHealth = (float)pPlayer->m_Shared.GetDisguiseHealth();
						flMaxHealth = (float)pPlayer->m_Shared.GetDisguiseMaxHealth();
						iMaxBuffedHealth = pPlayer->m_Shared.GetDisguiseMaxBuffedHealth();
					}
					else
					{
						flHealth = (float)pPlayer->GetHealth();
						flMaxHealth = g_TF_PR->GetMaxHealth( m_iTargetEntIndex );
						iMaxBuffedHealth = pPlayer->m_Shared.GetMaxBuffedHealth();
					}
				}
				else
				{
					bShowHealth = false;
				}
			}

			if ( printFormatString )
			{
				const wchar_t *pszPrepend = GetPrepend();
				if ( !pszPrepend || !pszPrepend[0] )
				{
					pszPrepend = L"";
				}
				g_pVGuiLocalize->ConstructString_safe( sIDString, g_pVGuiLocalize->Find(printFormatString), 2, pszPrepend, wszPlayerName );
			}

			// Show target's clip state to attached medics
			bool bShowClipInfo = bIsAmmoData &&
								 sDataString[0] && 
								 ToTFPlayer( pLocalTFPlayer->MedicGetHealTarget() ) == pPlayer;
			if ( m_pTargetAmmoIcon && m_pTargetAmmoIcon->IsVisible() != bShowClipInfo )
			{
				m_pTargetAmmoIcon->SetVisible( bShowClipInfo );
			}

			bool bShowKillStreak = bIsKillStreakData && sDataString[0];
			if ( m_pTargetKillStreakIcon && m_pTargetKillStreakIcon->IsVisible() != bShowKillStreak )
			{
				m_pTargetKillStreakIcon->SetVisible( bShowKillStreak );
			}
		}
		else	
		{
			// see if it is an object
			if ( pEnt->IsBaseObject() )
			{
				C_BaseObject *pObj = assert_cast<C_BaseObject *>( pEnt );

				pObj->GetTargetIDString( sIDString, sizeof(sIDString), false );
				pObj->GetTargetIDDataString( sDataString, sizeof(sDataString) );
				bShowHealth = true;
				flHealth = pObj->GetHealth();
				flMaxHealth = pObj->GetMaxHealth();
				m_pTargetHealth->SetBuilding( true );
				
				if ( m_pTargetKillStreakIcon )
				{
					m_pTargetKillStreakIcon->SetVisible( false );
				}

				// Switch the icon to the right object
				if ( pObj->GetBuilder() == pLocalTFPlayer )
				{
					int iObj = pObj->GetType();

					if ( iObj >= OBJ_DISPENSER && iObj <= OBJ_SENTRYGUN )
					{
						if ( pLocalTFPlayer->CanPickupBuilding(pObj) )
						{
							pszActionCommand = "+attack2";
						}

						
						switch ( iObj )
						{
						default:
						case OBJ_DISPENSER:
							pszActionIcon = "obj_status_dispenser";
							break;
						case OBJ_TELEPORTER:
							{
								pszActionIcon = (pObj->GetObjectMode() == MODE_TELEPORTER_ENTRANCE) ? "obj_status_tele_entrance" : "obj_status_tele_exit";
							}
							break;
						case OBJ_SENTRYGUN:
							{
								int iLevel = pObj->GetUpgradeLevel();
								if ( iLevel == 3 )
								{
									pszActionIcon =  "obj_status_sentrygun_3";
								}
								else
								{
									pszActionIcon = (iLevel == 2) ? "obj_status_sentrygun_2" : "obj_status_sentrygun_1";
								}
							}
							break;
						}
					}
				}
			}
			// Generic
			else if ( pEnt->IsVisibleToTargetID() )
			{
				CCaptureFlag *pFlag = dynamic_cast< CCaptureFlag * >( pEnt );
				if ( pFlag && pFlag->GetPointValue() > 0 )
				{
					bShowHealth = false;
					g_pVGuiLocalize->ConvertANSIToUnicode( CFmtStr("%d Points", pFlag->GetPointValue() ), sIDString, sizeof(sIDString) );
				}
				else
				{
					CTFDroppedWeapon *pDroppedWeapon = dynamic_cast< CTFDroppedWeapon * >( pEnt );
					if ( pDroppedWeapon )
					{
						CEconItemView* pDroppedEconItem = pDroppedWeapon->GetItem();
						if ( pLocalTFPlayer->GetDroppedWeaponInRange() != NULL )
						{
							pszActionIcon = "obj_weapon_pickup";
							pszActionCommand = "+use_action_slot_item";
						}
	
						if ( FStrEq( pDroppedEconItem->GetStaticData()->GetItemClass(), "tf_weapon_medigun" ) )
						{
							wchar_t wszChargeLevel[10];
							_snwprintf( wszChargeLevel, ARRAYSIZE( wszChargeLevel ) - 1, L"%.0f", pDroppedWeapon->GetChargeLevel() * 100 );
							wszChargeLevel[ARRAYSIZE( wszChargeLevel ) - 1] = '\0';

							g_pVGuiLocalize->ConstructString_safe( sIDString, L"%s1 (%s2%)", 2, CEconItemLocalizedFullNameGenerator( GLocalizationProvider(), pDroppedEconItem->GetItemDefinition(), pDroppedEconItem->GetItemQuality() ).GetFullName(), wszChargeLevel );
						}
						else
						{
							g_pVGuiLocalize->ConstructString_safe( sIDString, L"%s1", 1, CEconItemLocalizedFullNameGenerator( GLocalizationProvider(), pDroppedEconItem->GetItemDefinition(), pDroppedEconItem->GetItemQuality() ).GetFullName() );
						}

						locchar_t wszPlayerName [128];
						CBasePlayer *pOwner = GetPlayerByAccountID( pDroppedEconItem->GetAccountID() );
						// Bots will not work here, so don't fill this out.
						if ( pOwner )
						{
							g_pVGuiLocalize->ConvertANSIToUnicode( pOwner->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
							g_pVGuiLocalize->ConstructString_safe( sDataString, g_pVGuiLocalize->Find( "#TF_WhoDropped" ), 1, wszPlayerName );

							// Get the rarity color
							vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
							if ( pScheme )
							{
								const char* pszColorName = GetItemSchema()->GetRarityColor( pDroppedEconItem->GetItemDefinition()->GetRarity() );
								pszColorName = pszColorName ? pszColorName : "TanLight";
								colorName = pScheme->GetColor( pszColorName, Color( 255, 255, 255, 255 ) );
							}
						}
					}
					else if ( pLocalTFPlayer->InSameTeam( pEnt ) )
					{
						bShowHealth = true;
						flHealth = pEnt->GetHealth();
						flMaxHealth = pEnt->GetMaxHealth();
						iMaxBuffedHealth = pEnt->GetMaxHealth();

						// Display respawn timer on revive markers by hacking bountymode's player level display
						if ( !pEnt->IsPlayer() )
						{
							CTFReviveMarker *pMarker = dynamic_cast< CTFReviveMarker* >( pEnt );
							if ( pMarker && pMarker->GetOwner() )
							{
								float flRespawn = TFGameRules()->GetNextRespawnWave( pMarker->GetTeamNumber(), pMarker->GetOwner() ) - gpGlobals->curtime;
								m_pTargetHealth->SetLevel( (int)flRespawn );

								g_pVGuiLocalize->ConvertANSIToUnicode( pMarker->GetOwner()->GetPlayerName(), sIDString, sizeof(sIDString) );
							}
						}
					}
				}
			}
		}

		// Setup health icon
		if ( !pEnt->IsAlive() && ( pEnt->IsPlayer() || pEnt->IsBaseObject() ) )
		{
			flHealth = 0;	// fixup for health being 1 when dead
		}

		m_pTargetHealth->SetHealth( flHealth, flMaxHealth, iMaxBuffedHealth );
		m_pTargetHealth->SetVisible( DrawHealthIcon() );
		if ( m_pMoveableSubPanel )
		{
			bool bShowActionKey = pszActionCommand != NULL;
			if ( m_pMoveableSubPanel->IsVisible() != bShowActionKey )
			{
				m_pMoveableSubPanel->SetVisible( bShowActionKey );
				m_bLayoutOnUpdate = true;
			}

			if ( m_pMoveableSubPanel->IsVisible() )
			{
				const char *pBoundKey = engine->Key_LookupBinding( pszActionCommand );
				m_pMoveableSubPanel->SetDialogVariable( "movekey", pBoundKey );
			}

			if ( m_pMoveableIcon )
			{
				if ( pszActionIcon )
				{
					m_pMoveableIcon->SetIcon( pszActionIcon );
				}
				m_pMoveableIcon->SetVisible( pszActionIcon != NULL );
			}
		}

		if ( m_pAvatarImage && pEnt->IsPlayer() )
		{
			C_BasePlayer *pTFTarget = GetTargetForSteamAvatar( ToTFPlayer( pEnt ) );

			bool bShowAvatar = ( pTFTarget ) ? true : false;
			if ( m_pAvatarImage->IsVisible() != bShowAvatar )
			{
				m_pAvatarImage->SetVisible( bShowAvatar );
				if ( bShowAvatar )
				{
					m_pAvatarImage->SetPlayer( pTFTarget );
					m_pAvatarImage->SetShouldDrawFriendIcon( false );
					m_pAvatarImage->SetAlpha( tf_hud_target_id_alpha.GetInt() );
				}
			}
		}

		if ( m_pTargetNameLabel && m_pTargetDataLabel )
		{
			int iNameW, iDataW, iIgnored;
			m_pTargetNameLabel->GetContentSize( iNameW, iIgnored );
			m_pTargetDataLabel->GetContentSize( iDataW, iIgnored );

			// Target name
			if ( sIDString[0] )
			{
				sIDString[ ARRAYSIZE(sIDString)-1 ] = '\0';
				m_pTargetNameLabel->SetVisible(true);
				m_pTargetNameLabel->SetFgColor( colorName );

				// TODO: Support	if( hud_centerid.GetInt() == 0 )
				SetDialogVariable( "targetname", sIDString );
			}
			else
			{
				m_pTargetNameLabel->SetVisible(false);
				m_pTargetNameLabel->SetText("");
			}

			// Extra target data
			if ( sDataString[0] )
			{
				sDataString[ ARRAYSIZE(sDataString)-1 ] = '\0';
				m_pTargetDataLabel->SetVisible(true);
				m_pTargetDataLabel->SetFgColor( colorData );

				SetDialogVariable( "targetdata", sDataString );
			}
			else
			{
				m_pTargetDataLabel->SetVisible(false);
				m_pTargetDataLabel->SetText("");
			}

			int iPostNameW, iPostDataW;
			m_pTargetNameLabel->GetContentSize( iPostNameW, iIgnored );
			m_pTargetDataLabel->GetContentSize( iPostDataW, iIgnored );

			if ( m_pBGPanel )
			{
				m_pBGPanel->SetBGTeam( iTargetTeam );
				m_pBGPanel->UpdateBGImage();
				m_pBGPanel->SetAlpha( tf_hud_target_id_alpha.GetInt() );
			}

			if ( m_bLayoutOnUpdate || (iPostDataW != iDataW) || (iPostNameW != iNameW) )
			{
				InvalidateLayout( true );
				m_bLayoutOnUpdate = false;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CSecondaryTargetID::CSecondaryTargetID( const char *pElementName ) : CTargetID( pElementName )
{
	m_wszPrepend[0] = '\0';

	RegisterForRenderGroup( "mid" );

	m_bWasHidingLowerElements = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CSecondaryTargetID::ShouldDraw( void )
{
	bool bDraw = BaseClass::ShouldDraw();

	if ( bDraw )
	{
		if ( !m_bWasHidingLowerElements )
		{
			HideLowerPriorityHudElementsInGroup( "mid" );
			m_bWasHidingLowerElements = true;
		}
	}
	else 
	{
		if ( m_bWasHidingLowerElements )
		{
			UnhideLowerPriorityHudElementsInGroup( "mid" );
			m_bWasHidingLowerElements = false;
		}
	}

	return bDraw;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CSecondaryTargetID::CalculateTargetIndex( C_TFPlayer *pLocalTFPlayer )
{
	// If we're a medic & we're healing someone, target him.
	CBaseEntity *pHealTarget = pLocalTFPlayer->MedicGetHealTarget();
	if ( pHealTarget )
	{
		if ( pHealTarget->entindex() != m_iTargetEntIndex )
		{
			g_pVGuiLocalize->ConstructString_safe( m_wszPrepend, g_pVGuiLocalize->Find("#TF_playerid_healtarget" ), 0 );
		}
		return pHealTarget->entindex();
	}

	// If we have a healer, target him.
	C_TFPlayer *pHealer;
	float flHealerChargeLevel;
	pLocalTFPlayer->GetHealer( &pHealer, &flHealerChargeLevel );
	if ( pHealer )
	{
		if ( pHealer->entindex() != m_iTargetEntIndex )
		{
			g_pVGuiLocalize->ConstructString_safe( m_wszPrepend, g_pVGuiLocalize->Find("#TF_playerid_healer" ), 0 );
		}
		return pHealer->entindex();
	}

	if ( m_iTargetEntIndex )
	{
		m_wszPrepend[0] = '\0';
	}
	return 0;
}

// Separately declared versions of the hud element for alive and dead so they
// can have different positions

bool CMainTargetID::ShouldDraw( void )
{
	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
		return false;

	if ( pLocalTFPlayer->GetObserverMode() > OBS_MODE_NONE )
		return false;

	return BaseClass::ShouldDraw();
}

bool CSpectatorTargetID::ShouldDraw( void )
{
	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
		return false;

	if ( pLocalTFPlayer->GetObserverMode() <= OBS_MODE_NONE ||
		 pLocalTFPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
		return false;

	if ( pLocalTFPlayer->m_bIsCoaching )
	{
		return false;
	}

	// Hide panel for freeze-cam screenshot?
	extern bool IsTakingAFreezecamScreenshot();
	extern ConVar hud_freezecamhide;
	
	if ( IsTakingAFreezecamScreenshot() && hud_freezecamhide.GetBool() )
		return false;

#if defined( REPLAY_ENABLED )
	if ( g_pEngineClientReplay->IsPlayingReplayDemo() )
		return false;
#endif

	return BaseClass::ShouldDraw();
}

int	CSpectatorTargetID::CalculateTargetIndex( C_TFPlayer *pLocalTFPlayer ) 
{ 
	int iIndex = BaseClass::CalculateTargetIndex( pLocalTFPlayer );

#if defined( REPLAY_ENABLED )
	// Don't execute this if we're watching a replay
	if ( ( !g_pEngineClientReplay || !g_pEngineClientReplay->IsPlayingReplayDemo() ) && pLocalTFPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pLocalTFPlayer->GetObserverTarget() )
#else
	if ( pLocalTFPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pLocalTFPlayer->GetObserverTarget() )
#endif
	{
		iIndex = pLocalTFPlayer->GetObserverTarget()->entindex();
	}

	return iIndex;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CSpectatorTargetID::ApplySchemeSettings( vgui::IScheme *scheme )
{
	BaseClass::ApplySchemeSettings( scheme );

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

	m_pBGPanel_Spec_Blue = FindChildByName("TargetIDBG_Spec_Blue");
	m_pBGPanel_Spec_Red = FindChildByName("TargetIDBG_Spec_Red");

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

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CSpectatorTargetID::PerformLayout( void )
{
	int iXIndent = XRES(5);
	int iXPostdent = XRES(10);
	int iWidth = m_pTargetHealth->GetWide() + iXIndent + iXPostdent;

	int iTextW, iTextH;
	int iDataW, iDataH;

	if ( m_pTargetNameLabel && m_pTargetDataLabel )
	{
		m_pTargetNameLabel->GetContentSize( iTextW, iTextH );
		m_pTargetDataLabel->GetContentSize( iDataW, iDataH );
		iWidth += MAX(iTextW,iDataW);

		SetSize( iWidth, GetTall() );

		int nOffset = m_bArenaPanelVisible ? YRES (120) : 0; // HACK: move the targetID up a bit so it won't overlap the panel

		int x1 = 0, y1 = 0;
		int x2 = 0, y2 = 0;
		int x3 = 0, y3 = 0;
		m_pTargetNameLabel->GetPos( x1, y1 );
		m_pTargetDataLabel->GetPos( x2, y2 );
		if ( m_pTargetKillStreakIcon )
		{
			m_pTargetKillStreakIcon->GetPos( x3, y3 );
		}

		// Shift Labels
		{
			int nBuffer = ( m_pAvatarImage && m_pAvatarImage->IsVisible() ) ? 6 : 8;
			m_pTargetNameLabel->SetPos( XRES( nBuffer ) + m_pTargetHealth->GetWide(), y1 );
			m_pTargetDataLabel->SetPos( XRES( nBuffer ) + m_pTargetHealth->GetWide(), y2 );

			if ( m_pTargetKillStreakIcon )
			{
				m_pTargetKillStreakIcon->SetPos( XRES( 10 ) + m_pTargetHealth->GetWide(), y3 );
			}
		}

		if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_NORMAL )
		{
			SetPos( (ScreenWidth() - iWidth) * 0.5,  m_nOriginalY - nOffset );
		}
		else
		{
			int iBottomBarHeight = 0;
			if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
			{
				iBottomBarHeight = g_pSpectatorGUI->GetBottomBarHeight();
			}

			int iYPos =	ScreenHeight() - GetTall() - iBottomBarHeight - m_iYOffset;

			if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_BOTTOM_LEFT )
			{
				SetPos( m_iXOffset, iYPos );
			}
			else if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_BOTTOM_CENTER )
			{
				SetPos( (ScreenWidth() - iWidth) * 0.5, iYPos );
			}
			else if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_BOTTOM_RIGHT )
			{
				SetPos( ScreenWidth() - iWidth - m_iXOffset, iYPos );
			}
		}

		if ( m_pBGPanel_Spec_Blue )
		{
			m_pBGPanel_Spec_Blue->SetSize( iWidth, GetTall() );
		}

		if ( m_pBGPanel_Spec_Red )
		{
			m_pBGPanel_Spec_Red->SetSize( iWidth, GetTall() );
		}

		if ( m_pBGPanel_Spec_Blue && m_pBGPanel_Spec_Red )
		{
			if ( m_iTargetEntIndex )
			{
				C_BaseEntity *pEnt = cl_entitylist->GetEnt( m_iTargetEntIndex );
				if ( pEnt )
				{
					bool bRed = ( pEnt->GetTeamNumber() == TF_TEAM_RED );
					m_pBGPanel_Spec_Blue->SetVisible( !bRed );
					m_pBGPanel_Spec_Red->SetVisible( bRed );			

					m_pBGPanel_Spec_Blue->SetAlpha( tf_hud_target_id_alpha.GetInt() );
					m_pBGPanel_Spec_Red->SetAlpha( tf_hud_target_id_alpha.GetInt() );
				}
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CFloatingHealthIcon::CFloatingHealthIcon( vgui::Panel *parent, const char *name ) : EditablePanel( parent, name )
{
	m_flPrevHealth = -1.f;
	m_nPrevLevel = 0;

	SetVisible( false );
	SetBounds( 0, 0, 128, 128 );

	vgui::ivgui()->AddTickSignal( GetVPanel(), 50 );
	OnTick();

	m_pTargetHealth = new CTFSpectatorGUIHealth( this, "SpectatorGUIHealth" );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::Reset( void )
{
	m_pTargetHealth->Reset();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::SetEntity( C_BaseEntity *pEntity )
{
	m_hEntity = pEntity;

	if ( !m_pTargetHealth )
		return;

	m_pTargetHealth->SetAllowAnimations( false );
	m_pTargetHealth->HideHealthBonusImage();

	bool bBuilding = false;

	if ( m_hEntity->IsPlayer() )
	{
		C_TFPlayer *pPlayer = ToTFPlayer( m_hEntity );
		bBuilding = ( pPlayer && pPlayer->IsMiniBoss() ) ? true : false;
	}
	m_pTargetHealth->SetBuilding( bBuilding );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CFloatingHealthIcon* CFloatingHealthIcon::AddFloatingHealthIcon( C_BaseEntity *pEntity )
{
	CFloatingHealthIcon *pHealthIcon = new CFloatingHealthIcon( g_pClientMode->GetViewport(), "HealthIcon" );
	vgui::SETUP_PANEL( pHealthIcon );
	pHealthIcon->SetEntity( pEntity );

	return pHealthIcon;
}

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

	LoadControlSettings( "resource/UI/HealthIconPanel.res" );
	SetVisible( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::OnTick( void )
{
	if ( !m_pTargetHealth )
		return;

	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();

	if ( !ShouldHealthBarBeVisible( m_hEntity, pLocalTFPlayer ) )
	{
		SetVisible( false );
		return;
	}

	C_TFPlayer *pTargetPlayer = ToTFPlayer( m_hEntity );
	if ( pTargetPlayer && pTargetPlayer->m_Shared.IsStealthed() )
	{
		SetVisible( false );
		return;
	}

	// Defaults for all entities
	float flHealth = m_hEntity->GetHealth();
	float flMaxHealth = m_hEntity->GetMaxHealth();
	float iMaxBuffedHealth = m_hEntity->GetMaxHealth();

	if ( pTargetPlayer && pTargetPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTargetPlayer->IsEnemyPlayer() )
	{
		flHealth = (float)pTargetPlayer->m_Shared.GetDisguiseHealth();
		flMaxHealth = (float)pTargetPlayer->m_Shared.GetDisguiseMaxHealth();
		iMaxBuffedHealth = pTargetPlayer->m_Shared.GetDisguiseMaxBuffedHealth();
	}
		
	if ( flHealth != m_flPrevHealth )
 	{
		m_pTargetHealth->SetHealth( flHealth, flMaxHealth, iMaxBuffedHealth );
		m_flPrevHealth = flHealth;
	}

#ifdef STAGING_ONLY
	if ( TFGameRules() && TFGameRules()->IsBountyMode() && tf_bountymode_showhealth.GetInt() == 2 )
	{
		if ( m_hEntity->IsPlayer() )
		{
			if ( !pTargetPlayer || pTargetPlayer->IsMiniBoss() )
				return;

			int nPlayerLevel = pTargetPlayer->GetExperienceLevel();
			if ( nPlayerLevel != m_nPrevLevel )
			{
				m_pTargetHealth->SetLevel( nPlayerLevel );
				m_nPrevLevel = nPlayerLevel;
			}
		}
	}
#endif // STAGING_ONLY
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
ConVar tf_healthicon_height_offset( "tf_healthicon_height_offset", "10", FCVAR_ARCHIVE, "Offset of the health icon away from the top of the target." );
void CFloatingHealthIcon::Paint( void )
{
	if ( !CalculatePosition() )
		return;

	BaseClass::Paint();
}

//-----------------------------------------------------------------------------
bool CFloatingHealthIcon::CalculatePosition( )
{
	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
		return false;

	if ( !m_hEntity || m_hEntity->IsDormant() )
	{
		return false;
	}

	Vector vecTarget = m_hEntity->GetAbsOrigin();

	// Reposition based on our target's position
	Vector vecDistance = vecTarget - pLocalTFPlayer->GetAbsOrigin();
	vecTarget.z += VEC_HULL_MAX_SCALED( m_hEntity->GetBaseAnimating() ).z + tf_healthicon_height_offset.GetInt() + m_hEntity->GetHealthBarHeightOffset();

	int iX, iY;
	GetVectorInHudSpace( vecTarget, iX, iY );				// TODO: GetVectorInHudSpace or GetVectorInScreenSpace?
	SetPos( iX - ( GetWide() / 2 ), iY - GetTall() );

	return true;
}

//-----------------------------------------------------------------------------
void CFloatingHealthIcon::SetVisible( bool state )
{
	if ( state )
	{
		CalculatePosition();
	}

	BaseClass::SetVisible( state );
}


//-----------------------------------------------------------------------------
bool CFloatingHealthIcon::IsVisible( void )
{
	if ( !m_pTargetHealth )
		return false;

	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalTFPlayer )
		return false;

	//if ( pLocalTFPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
	if ( pLocalTFPlayer->GetObserverMode() > OBS_MODE_NONE )
		return false;

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

	return BaseClass::IsVisible();
}