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

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: HUD Target ID element
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "hud.h"
#include "iclientmode.h"
#include "c_baseobject.h"
#include "c_tf_player.h"
#include "ienginevgui.h"
#include "vgui/ILocalize.h"
#include "vgui/ISurface.h"
#include <vgui/IVGui.h>
#include <vgui_controls/ProgressBar.h>
#include <vgui_controls/AnimationController.h>
#include "game_controls/IconPanel.h"
#include "teamplay_round_timer.h"

#include "tf_hud_building_status.h"

#include "c_obj_sentrygun.h"
#include "c_obj_dispenser.h"
#include "c_obj_teleporter.h"
#include "c_obj_sapper.h"

#include "tf_gamerules.h"
#include "tf_logic_halloween_2014.h"

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

class C_ObjectSentrygun;

extern CUtlVector<int> g_TeamRoundTimers;

using namespace vgui;

ConVar tf_hud_num_building_alert_beeps( "tf_hud_num_building_alert_beeps", "2", FCVAR_ARCHIVE, "Number of times to play warning sound when a new alert displays on building hud objects", true, 0, false, 0 );

//============================================================================

DECLARE_BUILD_FACTORY( CBuildingHealthBar );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingHealthBar::CBuildingHealthBar(Panel *parent, const char *panelName) : vgui::ProgressBar( parent, panelName )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingHealthBar::Paint()
{
	if ( _progress < 0.5 )
	{
		SetFgColor( m_cLowHealthColor );
	}
	else
	{
		SetFgColor( m_cHealthColor );
	}

	BaseClass::Paint();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingHealthBar::PaintBackground()
{
	// save progress and real fg color
	float flProgress = _progress;
	Color fgColor = GetFgColor();

	// stuff our fake info
	_progress = 1.0;
	SetFgColor( GetBgColor() );

	BaseClass::Paint();

	// restore actual progress / color
	_progress = flProgress;
	SetFgColor( fgColor );
}

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

	SetBgColor(GetSchemeColor("BuildingHealthBar.BgColor", pScheme));
	m_cHealthColor = GetSchemeColor("BuildingHealthBar.Health", pScheme);
	m_cLowHealthColor = GetSchemeColor("BuildingHealthBar.LowHealth", pScheme);
	SetBorder(NULL);
}

//============================================================================

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusItem::CBuildingStatusItem( Panel *parent, const char *szLayout, int iObjectType, int iObjectMode=0 ) :
BaseClass( parent, "BuildingStatusItem" )
{
	SetProportional( true );

	// Save our layout file for re-loading
	Q_strncpy( m_szLayout, szLayout, sizeof(m_szLayout) );

	// load control settings...
	LoadControlSettings( szLayout );

	SetPositioned( false );

	m_pObject = NULL;
	m_iObjectType = iObjectType;
	m_iObjectMode = iObjectMode;

	m_pBuiltPanel = new vgui::EditablePanel( this, "BuiltPanel" );
	m_pNotBuiltPanel = new vgui::EditablePanel( this, "NotBuiltPanel" );

	// sub panels
	m_pBuildingPanel = new vgui::EditablePanel( m_pBuiltPanel, "BuildingPanel" );
	m_pRunningPanel = new vgui::EditablePanel( m_pBuiltPanel, "RunningPanel" );

	// Shared between All sub panels
	m_pBackground = new CIconPanel( this, "Background" );

	// Running and Building sub panels only
	m_pHealthBar = new CBuildingHealthBar( m_pBuiltPanel, "Health" );
	m_pHealthBar->SetSegmentInfo( YRES(1), YRES(3) );
	m_pHealthBar->SetProgressDirection( ProgressBar::PROGRESS_NORTH );
	m_pHealthBar->SetBarInset( 0 );

	m_pBuildingProgress = new vgui::ContinuousProgressBar( m_pBuildingPanel, "BuildingProgress" ); 

	m_pAlertTray = new CBuildingStatusAlertTray( m_pBuiltPanel, "AlertTray" );
	m_pWrenchIcon = new CIconPanel( m_pBuiltPanel, "WrenchIcon" );
	m_pSapperIcon = new CIconPanel( m_pBuiltPanel, "SapperIcon" );

	m_pUpgradeIcons[0] = new CIconPanel( m_pBuiltPanel, "Icon_Upgrade_1" );
	m_pUpgradeIcons[1] = new CIconPanel( m_pBuiltPanel, "Icon_Upgrade_2" );
	m_pUpgradeIcons[2] = new CIconPanel( m_pBuiltPanel, "Icon_Upgrade_3" );

	m_iUpgradeLevel = 1;

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

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem::ApplySchemeSettings( IScheme *pScheme )
{
	// This lets us use hud_reloadscheme to reload the status items
	int x, y;
	GetPos( x, y );

	LoadControlSettings( m_szLayout );

	SetPos( x, y );

	BaseClass::ApplySchemeSettings( pScheme );
}

//-----------------------------------------------------------------------------
// Purpose: Calc visibility of subpanels
//-----------------------------------------------------------------------------
void CBuildingStatusItem::PerformLayout( void )
{
	BaseClass::PerformLayout();

	C_BaseObject *pObj = m_pObject.Get();

	m_bActive = ( pObj != NULL );

	m_pHealthBar->SetVisible( m_bActive );

	m_pNotBuiltPanel->SetVisible( !m_bActive );
	m_pBuiltPanel->SetVisible( m_bActive );

	if ( pObj )
	{
		// redo the background
		m_pBackground->SetIcon( GetBackgroundImage() );

		if ( pObj->IsBuilding() )
		{
			m_pBuildingPanel->SetVisible( true );
			m_pRunningPanel->SetVisible( false );

			m_pUpgradeIcons[0]->SetVisible( false );
			m_pUpgradeIcons[1]->SetVisible( false );
			m_pUpgradeIcons[2]->SetVisible( false );
		}
		else
		{
			m_pBuildingPanel->SetVisible( false );
			m_pRunningPanel->SetVisible( true );

			int iUpgradeLevel = pObj->GetUpgradeLevel();

			Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

			m_pUpgradeIcons[0]->SetVisible( false );
			m_pUpgradeIcons[1]->SetVisible( false );
			m_pUpgradeIcons[2]->SetVisible( false );

			// show the correct upgrade level icon
			if ( !pObj->IsMiniBuilding() )
			{
				m_pUpgradeIcons[iUpgradeLevel-1]->SetVisible( true );
			}
		}
	}
	else
	{
		// redo the background
		m_pBackground->SetIcon( GetInactiveBackgroundImage() );

		if ( m_pAlertTray->IsTrayOut() )
		{
			m_pAlertTray->HideTray();
			m_pWrenchIcon->SetVisible( false );
			m_pSapperIcon->SetVisible( false );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Setup
//-----------------------------------------------------------------------------
void CBuildingStatusItem::LevelInit( void )
{
	if ( m_pAlertTray )
		m_pAlertTray->LevelInit();
}

//-----------------------------------------------------------------------------
// Purpose: Setup
//-----------------------------------------------------------------------------
void CBuildingStatusItem::SetObject( C_BaseObject *pObj )
{
	m_pObject = pObj;

	Assert( !pObj || ( pObj && !pObj->IsMarkedForDeletion() ) );

	if ( !pObj )
	{
		m_pAlertTray->HideTray();
		m_pWrenchIcon->SetVisible( false );
		m_pSapperIcon->SetVisible( false );
		m_pAlertTray->SetAlertType( BUILDING_HUD_ALERT_NONE );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem::Paint( void )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem::PaintBackground( void )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem::GetBackgroundImage( void )
{
	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

	const char *pResult = "obj_status_background_blue";

	if ( !pLocalPlayer )
	{
		Assert( 0 );
		return pResult;
	}

	switch( pLocalPlayer->GetTeamNumber() )
	{
	case TF_TEAM_BLUE:
		pResult = "obj_status_background_blue";
		break;
	case TF_TEAM_RED:
		pResult = "obj_status_background_red";
		break;
	default:
		break;
	}

	return pResult;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem::GetInactiveBackgroundImage( void )
{
	return "obj_status_background_disabled";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem::OnTick()
{
	// We only tick while active and with a valid built object
	C_BaseObject *pObj = GetRepresentativeObject();

	if ( !pObj )	// implies not active
	{
		if ( m_bActive )
		{
			// we lost our object. force relayout to inactive mode
			InvalidateLayout();

			// tell our parent that we're gone
			IGameEvent *event = gameeventmanager->CreateEvent( "building_info_changed" );
			if ( event )
			{
				event->SetInt( "building_type", GetRepresentativeObjectType() );
				event->SetInt( "object_mode", GetRepresentativeObjectMode() );
				gameeventmanager->FireEventClientSide( event );
			}
		}

		// We don't want to tick while inactive regardless
		return;
	}

	float flHealth = (float)pObj->GetHealth() / (float)pObj->GetMaxHealth();

	m_pHealthBar->SetProgress( flHealth );

	if ( pObj->IsBuilding() )
	{
		m_pBuildingPanel->SetVisible( true );
		m_pRunningPanel->SetVisible( false );

		m_pBuildingProgress->SetProgress( pObj->GetPercentageConstructed() );
	}
	else
	{
		m_pBuildingPanel->SetVisible( false );
		m_pRunningPanel->SetVisible( true );
	}

	// what is our current alert state?
	BuildingHudAlert_t alertLevel = pObj->GetBuildingAlertLevel();

	if ( alertLevel <= BUILDING_HUD_ALERT_NONE )
	{
		// if the tray is out, hide it
		if ( m_pAlertTray->IsTrayOut() )
		{
			m_pAlertTray->HideTray();
			m_pWrenchIcon->SetVisible( false );
			m_pSapperIcon->SetVisible( false );
		}
	}
	else
	{
		m_pWrenchIcon->SetVisible( false );
		m_pSapperIcon->SetVisible( false );

		bool bShowAlertTray = false;
		bool bAlertTrayFullyDeployed = m_pAlertTray->GetPercentDeployed() >= 1.0f;
		switch( alertLevel )
		{
			// show low ammo for normal sentry and mini-sentry
		case BUILDING_HUD_ALERT_LOW_AMMO:
		case BUILDING_HUD_ALERT_VERY_LOW_AMMO:
			bShowAlertTray = true;
			m_pWrenchIcon->SetVisible( bAlertTrayFullyDeployed );
			break;

			// do not show low health for mini-sentry
		case BUILDING_HUD_ALERT_LOW_HEALTH:
		case BUILDING_HUD_ALERT_VERY_LOW_HEALTH:
			bShowAlertTray = pObj->IsMiniBuilding() == false;
			m_pWrenchIcon->SetVisible( bAlertTrayFullyDeployed && bShowAlertTray );
			break;

			// always show when being sapped
		case BUILDING_HUD_ALERT_SAPPER:
			bShowAlertTray = true;
			m_pSapperIcon->SetVisible( bAlertTrayFullyDeployed );
			break;

		default:
			bShowAlertTray = false;
			break;
		}

		if ( bShowAlertTray && !pObj->IsDisposableBuilding() )
		{
			if ( !m_pAlertTray->IsTrayOut() )
			{
				m_pAlertTray->ShowTray();
			}
			m_pAlertTray->SetAlertType( alertLevel );
		}
		else
		{
			if ( m_pAlertTray->IsTrayOut() )
			{
				m_pAlertTray->HideTray();
			}
			m_pAlertTray->SetAlertType( BUILDING_HUD_ALERT_NONE );
		}
	}	
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
C_BaseObject *CBuildingStatusItem::GetRepresentativeObject( void )
{
	if ( !m_bActive )
	{
		return NULL;
	}
	else
	{
		return m_pObject.Get();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBuildingStatusItem::GetRepresentativeObjectType( void )
{
	return m_iObjectType;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBuildingStatusItem::GetRepresentativeObjectMode( void )
{
	return m_iObjectMode;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBuildingStatusItem::GetObjectPriority( void )
{
	int nPriority = GetObjectInfo( GetRepresentativeObjectType() )->m_iDisplayPriority;

	// MvM hack to sort buildings properly since we can have more than one sentry via upgrades
	if ( GetRepresentativeObjectType() == OBJ_SENTRYGUN && GetRepresentativeObjectMode() == MODE_SENTRYGUN_DISPOSABLE )
	{
		nPriority = 0;
	}

	return nPriority;	
}

//============================================================================


DECLARE_BUILD_FACTORY( CBuildingStatusAlertTray );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusAlertTray::CBuildingStatusAlertTray(Panel *parent, const char *panelName) : BaseClass( parent, panelName )
{
	m_pAlertPanelMaterial = NULL;
	m_flAlertDeployedPercent = 0.0f;
	m_bIsTrayOut = false;

	m_pAlertPanelHudTexture = NULL;
	m_pAlertPanelMaterial = NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusAlertTray::ApplySettings( KeyValues *inResourceData )
{
	m_pAlertPanelHudTexture = gHUD.GetIcon( inResourceData->GetString( "icon", "" ) );

	if ( m_pAlertPanelHudTexture )
	{
		m_pAlertPanelMaterial = materials->FindMaterial( m_pAlertPanelHudTexture->szTextureFile, TEXTURE_GROUP_VGUI );
	}

	BaseClass::ApplySettings( inResourceData );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusAlertTray::Paint( void )
{
	// Paint the alert tray
	if ( !m_pAlertPanelMaterial || !m_pAlertPanelHudTexture )
	{
		return;
	}

	int x = 0;
	int y = 0;
	ipanel()->GetAbsPos(GetVPanel(), x,y );
	int iWidth = GetWide();
	int iHeight = GetTall();

	// Position the alert panel image based on the deployed percent
	float flXa = m_pAlertPanelHudTexture->texCoords[0];
	float flXb = m_pAlertPanelHudTexture->texCoords[2];
	float flYa = m_pAlertPanelHudTexture->texCoords[1];
	float flYb = m_pAlertPanelHudTexture->texCoords[3];

	float flMaskXa = flXa;
	float flMaskXb = flXb;
	float flMaskYa = flYa;
	float flMaskYb = flYb;

	float flFrameDelta = ( flXb - flXa ) * ( 1.0 - m_flAlertDeployedPercent );

	flXa += flFrameDelta;
	flXb += flFrameDelta; 

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->Bind( m_pAlertPanelMaterial );
	IMesh* pMesh = pRenderContext->GetDynamicMesh( true );

	int r, g, b, a;
	r = a = 255;

	switch( m_lastAlertType )
	{
	case BUILDING_HUD_ALERT_VERY_LOW_AMMO:
	case BUILDING_HUD_ALERT_VERY_LOW_HEALTH:
		g = b = (int)( 127.0f + 127.0f * cos( gpGlobals->curtime * 2.0f * M_PI * 0.5 ) );
		break;

	case BUILDING_HUD_ALERT_SAPPER:
		g = b = (int)( 127.0f + 127.0f * cos( gpGlobals->curtime * 2.0f * M_PI * 1.5 ) );
		break;

	case BUILDING_HUD_ALERT_LOW_AMMO:
	case BUILDING_HUD_ALERT_LOW_HEALTH:
	case BUILDING_HUD_ALERT_NONE:
	default:
		g = b = 255;
		break;
	}

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	meshBuilder.Position3f( x, y, 0.0f );
	meshBuilder.TexCoord2f( 0, flXa, flYa );
	meshBuilder.TexCoord2f( 1, flMaskXa, flMaskYa );
	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( x + iWidth, y, 0.0f );
	meshBuilder.TexCoord2f( 0, flXb, flYa );
	meshBuilder.TexCoord2f( 1, flMaskXb, flMaskYa );
	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( x + iWidth, y + iHeight, 0.0f );
	meshBuilder.TexCoord2f( 0, flXb, flYb );
	meshBuilder.TexCoord2f( 1, flMaskXb, flMaskYb );
	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( x, y + iHeight, 0.0f );
	meshBuilder.TexCoord2f( 0, flXa, flYb );
	meshBuilder.TexCoord2f( 1, flMaskXa, flMaskYb );
	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}

void CBuildingStatusAlertTray::PaintBackground( void )
{
}

void CBuildingStatusAlertTray::ShowTray( void )
{
	if ( m_bIsTrayOut == false )
	{
		m_flAlertDeployedPercent = 0.0;
		g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "deployed", 1.0, 0.0, 0.3, AnimationController::INTERPOLATOR_LINEAR );

		m_bIsTrayOut = true;
	}
}

void CBuildingStatusAlertTray::HideTray( void )
{
	if ( m_bIsTrayOut == true )
	{
		m_flAlertDeployedPercent = 1.0;
		g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "deployed", 0.0, 0.0, 0.3, AnimationController::INTERPOLATOR_LINEAR );

		m_bIsTrayOut = false;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Setup
//-----------------------------------------------------------------------------
void CBuildingStatusAlertTray::LevelInit( void )
{
	m_bIsTrayOut = false;
	m_flAlertDeployedPercent = 0.0f;
}

void CBuildingStatusAlertTray::SetAlertType( BuildingHudAlert_t alertLevel )
{	
	m_lastAlertType = alertLevel;
}

//============================================================================

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusItem_SentryGun::CBuildingStatusItem_SentryGun( Panel *parent ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_sentrygun.res", OBJ_SENTRYGUN, MODE_SENTRYGUN_NORMAL )
{
	m_pShellsProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Shells" );
	m_pRocketsProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Rockets" );
	m_pUpgradeProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Upgrade" );

	m_pRocketIcon = new vgui::ImagePanel( GetRunningPanel(), "RocketIcon" );
	m_pUpgradeIcon = new CIconPanel( GetRunningPanel(), "UpgradeIcon" );

	m_pSentryIcons[0] = new CIconPanel( this, "Icon_Sentry_1" );
	m_pSentryIcons[1] = new CIconPanel( this, "Icon_Sentry_2" );
	m_pSentryIcons[2] = new CIconPanel( this, "Icon_Sentry_3" );

	m_iUpgradeLevel = 1;
}


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

	m_cLowAmmoColor = scheme->GetColor( "LowHealthRed", Color(255,0,0,255) );
	m_cNormalAmmoColor = scheme->GetColor( "ProgressOffWhite", Color(255,255,255,255) );
}

//-----------------------------------------------------------------------------
// Purpose: Calc visibility of subpanels
//-----------------------------------------------------------------------------
void CBuildingStatusItem_SentryGun::PerformLayout( void )
{
	BaseClass::PerformLayout();

	C_ObjectSentrygun *pSentrygun = dynamic_cast<C_ObjectSentrygun *>( GetRepresentativeObject() );

	if ( !pSentrygun || ( pSentrygun && pSentrygun->IsDisposableBuilding() ) )
	{
		return;
	}

	GetRunningPanel()->SetDialogVariable( "numkills", pSentrygun->GetKills() );
	GetRunningPanel()->SetDialogVariable( "numassists", pSentrygun->GetAssists() );

	int iShells, iMaxShells;
	int iRockets, iMaxRockets;
	pSentrygun->GetAmmoCount( iShells, iMaxShells, iRockets, iMaxRockets );

	// Shells label
	float flShells = (float)iShells / (float)iMaxShells;
	m_pShellsProgress->SetProgress( flShells );

	if ( flShells < 0.25f )
	{
		m_pShellsProgress->SetFgColor( m_cLowAmmoColor );
	}
	else
	{
		m_pShellsProgress->SetFgColor( m_cNormalAmmoColor );
	}

	// Rockets label
	float flRockets = (float)iRockets / (float)SENTRYGUN_MAX_ROCKETS;
	m_pRocketsProgress->SetProgress( flRockets );

	if ( flRockets < 0.25f )
	{
		m_pRocketsProgress->SetFgColor( m_cLowAmmoColor );
	}
	else
	{
		m_pRocketsProgress->SetFgColor( m_cNormalAmmoColor );
	}

	int iUpgradeLevel = pSentrygun->GetUpgradeLevel();

	Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

	// show the correct icon
	m_pSentryIcons[0]->SetVisible( false );
	m_pSentryIcons[1]->SetVisible( false );
	m_pSentryIcons[2]->SetVisible( false );
	m_pSentryIcons[iUpgradeLevel-1]->SetVisible( true );

	// upgrade progress
	int iMetal = pSentrygun->GetUpgradeMetal();
	int iMetalRequired = pSentrygun->GetUpgradeMetalRequired();
	float flUpgrade = (float)iMetal / (float)iMetalRequired;
	m_pUpgradeProgress->SetProgress( flUpgrade );

	// upgrade label only in 1 or 2
	m_pUpgradeIcon->SetVisible( iUpgradeLevel < 3 );
	m_pUpgradeProgress->SetVisible( iUpgradeLevel < 3 );

	// rockets label only in 3
	m_pRocketIcon->SetVisible( iUpgradeLevel == 3 );
	m_pRocketsProgress->SetVisible( iUpgradeLevel == 3 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem_SentryGun::OnTick()
{
	BaseClass::OnTick();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem_SentryGun::GetBackgroundImage( void )
{
	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

	const char *pResult = "obj_status_background_tall_blue";

	if ( !pLocalPlayer )
	{
		return pResult;
	}

	switch( pLocalPlayer->GetTeamNumber() )
	{
	case TF_TEAM_BLUE:
		pResult = "obj_status_background_tall_blue";
		break;
	case TF_TEAM_RED:
		pResult = "obj_status_background_tall_red";
		break;
	default:
		break;
	}

	return pResult;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem_SentryGun::GetInactiveBackgroundImage( void )
{
	return "obj_status_background_tall_disabled";
}

//============================================================================

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusItem_SentryGun_Disposable::CBuildingStatusItem_SentryGun_Disposable( Panel *parent ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_sentrygun_disp.res", OBJ_SENTRYGUN, MODE_SENTRYGUN_DISPOSABLE )
{
	m_pShellsProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Shells" );

	m_pUpgradeIcon = new CIconPanel( GetRunningPanel(), "UpgradeIcon" );

	m_pSentryIcons[0] = new CIconPanel( this, "Icon_Sentry_1" );
	m_pSentryIcons[1] = new CIconPanel( this, "Icon_Sentry_2" );
	m_pSentryIcons[2] = new CIconPanel( this, "Icon_Sentry_3" );

	m_iUpgradeLevel = 1;
}


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

	m_cLowAmmoColor = scheme->GetColor( "LowHealthRed", Color(255,0,0,255) );
	m_cNormalAmmoColor = scheme->GetColor( "ProgressOffWhite", Color(255,255,255,255) );
}

//-----------------------------------------------------------------------------
// Purpose: Calc visibility of subpanels
//-----------------------------------------------------------------------------
void CBuildingStatusItem_SentryGun_Disposable::PerformLayout( void )
{
	BaseClass::PerformLayout();

	C_ObjectSentrygun *pSentrygun = dynamic_cast<C_ObjectSentrygun *>( GetRepresentativeObject() );

	if ( !pSentrygun || ( pSentrygun && !pSentrygun->IsDisposableBuilding() ) )
	{
		return;
	}

	GetRunningPanel()->SetDialogVariable( "numkills", pSentrygun->GetKills() );
	GetRunningPanel()->SetDialogVariable( "numassists", pSentrygun->GetAssists() );

	int iShells, iMaxShells;
	int iRockets, iMaxRockets;
	pSentrygun->GetAmmoCount( iShells, iMaxShells, iRockets, iMaxRockets );

	// Shells label
	float flShells = (float)iShells / (float)iMaxShells;
	m_pShellsProgress->SetProgress( flShells );

	if ( flShells < 0.25f )
	{
		m_pShellsProgress->SetFgColor( m_cLowAmmoColor );
	}
	else
	{
		m_pShellsProgress->SetFgColor( m_cNormalAmmoColor );
	}

	int iUpgradeLevel = pSentrygun->GetUpgradeLevel();

	Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

	// show the correct icon
	m_pSentryIcons[0]->SetVisible( false );
	m_pSentryIcons[1]->SetVisible( false );
	m_pSentryIcons[2]->SetVisible( false );
	m_pSentryIcons[iUpgradeLevel-1]->SetVisible( true );

	m_pUpgradeIcon->SetEnabled( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem_SentryGun_Disposable::OnTick()
{
	BaseClass::OnTick();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem_SentryGun_Disposable::GetBackgroundImage( void )
{
	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

	const char *pResult = "obj_status_background_tall_blue";

	if ( !pLocalPlayer )
	{
		return pResult;
	}

	switch( pLocalPlayer->GetTeamNumber() )
	{
	case TF_TEAM_BLUE:
		pResult = "obj_status_background_blue";
		break;
	case TF_TEAM_RED:
		pResult = "obj_status_background_red";
		break;
	default:
		break;
	}

	return pResult;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem_SentryGun_Disposable::GetInactiveBackgroundImage( void )
{
	return "obj_status_background_disabled";
}

//============================================================================

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusItem_Dispenser::CBuildingStatusItem_Dispenser( Panel *parent ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_dispenser.res", OBJ_DISPENSER )
{
	m_pAmmoProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Ammo" );
	m_pUpgradeProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Upgrade" );

	m_pUpgradeIcon = new CIconPanel( GetRunningPanel(), "UpgradeIcon" );

}

//-----------------------------------------------------------------------------
// Purpose: Calc visibility of subpanels
//-----------------------------------------------------------------------------
void CBuildingStatusItem_Dispenser::PerformLayout( void )
{
	BaseClass::PerformLayout();

	C_ObjectDispenser *pDispenser = static_cast<C_ObjectDispenser*>(GetRepresentativeObject());

	if ( !pDispenser )
	{
		return;
	}

	int iAmmo = pDispenser->GetMetalAmmoCount();

	float flMaxMetal = pDispenser->IsMiniBuilding() ? MINI_DISPENSER_MAX_METAL : DISPENSER_MAX_METAL_AMMO;
	float flProgress = (float)iAmmo / flMaxMetal;
	m_pAmmoProgress->SetProgress( flProgress );

	int iUpgradeLevel = pDispenser->GetUpgradeLevel();

	Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

	// upgrade progress
	int iMetal = pDispenser->GetUpgradeMetal();
	int iMetalRequired = pDispenser->GetUpgradeMetalRequired();
	flProgress = (float)iMetal / (float)iMetalRequired;
	
	m_pUpgradeProgress->SetProgress( flProgress );
	
	// upgrade label only in 1 or 2
	bool bShowUpgradeInfo = iUpgradeLevel < 3;
	m_pUpgradeIcon->SetVisible( bShowUpgradeInfo );
	m_pUpgradeProgress->SetVisible( bShowUpgradeInfo );
}



//============================================================================

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusItem_TeleporterEntrance::CBuildingStatusItem_TeleporterEntrance( Panel *parent ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_tele_entrance.res", OBJ_TELEPORTER, MODE_TELEPORTER_ENTRANCE )
{
	// Panel and children when we are charging
	m_pChargingPanel = new vgui::EditablePanel( GetRunningPanel(), "ChargingPanel" );
	m_pRechargeTimer = new vgui::ContinuousProgressBar( m_pChargingPanel, "Recharge" );

	// Panel and children when we are fully charged
	m_pFullyChargedPanel = new vgui::EditablePanel( GetRunningPanel(), "FullyChargedPanel" );

	m_iTimesUsed = -1;	// force first update of 0
	m_iTeleporterState = -1;

	m_pUpgradeProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Upgrade" );
	m_pUpgradeIcon = new CIconPanel( GetRunningPanel(), "UpgradeIcon" );

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

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem_TeleporterEntrance::OnTick( void )
{
	// We only tick while active and with a valid built object
	C_ObjectTeleporter *pTeleporter = static_cast<C_ObjectTeleporter*>(GetRepresentativeObject());

	if ( pTeleporter && IsActive() )
	{
		if ( pTeleporter->GetState() == TELEPORTER_STATE_RECHARGING )
		{
			// Update the recharge
			float flMaxRecharge = pTeleporter->GetCurrentRechargeDuration();
			float flChargeTime = pTeleporter->GetChargeTime();
			m_pRechargeTimer->SetProgress( 1.0 - ( flChargeTime / flMaxRecharge ) );
		}
	}

	BaseClass::OnTick();
}

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

	// We only tick while active and with a valid built object
	C_ObjectTeleporter *pTeleporter = static_cast<C_ObjectTeleporter*>(GetRepresentativeObject());

	if ( !IsActive() || !pTeleporter )
	{
		return;
	}

	bool bRecharging = ( pTeleporter->GetState() == TELEPORTER_STATE_RECHARGING );

	m_pChargingPanel->SetVisible( bRecharging );
	m_pFullyChargedPanel->SetVisible( !bRecharging );

	// How many times has this teleporter been used?
	m_pFullyChargedPanel->SetDialogVariable( "timesused", pTeleporter->GetTimesUsed() );		

	int iUpgradeLevel = pTeleporter->GetUpgradeLevel();

	Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

	// upgrade progress
	int iMetal = pTeleporter->GetUpgradeMetal();
	int iMetalRequired = pTeleporter->GetUpgradeMetalRequired();
	float flUpgrade = (float)iMetal / (float)iMetalRequired;
	m_pUpgradeProgress->SetProgress( flUpgrade );

	// upgrade label only in 1 or 2
	m_pUpgradeIcon->SetVisible( iUpgradeLevel < 3 );
	m_pUpgradeProgress->SetVisible( iUpgradeLevel < 3 );
}

//============================================================================

CBuildingStatusItem_TeleporterExit::CBuildingStatusItem_TeleporterExit( Panel *parent ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_tele_exit.res", OBJ_TELEPORTER, MODE_TELEPORTER_EXIT )
{
	m_pUpgradeProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Upgrade" );
	m_pUpgradeIcon = new CIconPanel( GetRunningPanel(), "UpgradeIcon" );
}

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

	// We only tick while active and with a valid built object
	C_ObjectTeleporter *pTeleporter = static_cast<C_ObjectTeleporter*>(GetRepresentativeObject());

	if ( !IsActive() || !pTeleporter )
	{
		return;
	}

	int iUpgradeLevel = pTeleporter->GetUpgradeLevel();

	Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

	// upgrade progress
	int iMetal = pTeleporter->GetUpgradeMetal();
	int iMetalRequired = pTeleporter->GetUpgradeMetalRequired();
	float flUpgrade = (float)iMetal / (float)iMetalRequired;
	m_pUpgradeProgress->SetProgress( flUpgrade );

	// upgrade label only in 1 or 2
	m_pUpgradeIcon->SetVisible( iUpgradeLevel < 3 );
	m_pUpgradeProgress->SetVisible( iUpgradeLevel < 3 );
}

#ifdef STAGING_ONLY
//============================================================================
CBuildingStatusItem_TeleporterSpeed::CBuildingStatusItem_TeleporterSpeed( Panel *parent, int ETeleporterMode ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_tele_speedpad.res", OBJ_TELEPORTER, ETeleporterMode )
{
	// Panel and children when we are charging
	m_pChargingPanel = new vgui::EditablePanel( GetRunningPanel(), "ChargingPanel" );
	m_pRechargeTimer = new vgui::ContinuousProgressBar( m_pChargingPanel, "Recharge" );

	// Panel and children when we are fully charged
	m_pFullyChargedPanel = new vgui::EditablePanel( GetRunningPanel(), "FullyChargedPanel" );

	m_iTimesUsed = -1;	// force first update of 0
	m_iTeleporterState = -1;

	m_pUpgradeProgress = new vgui::ContinuousProgressBar( GetRunningPanel(), "Upgrade" );
	m_pUpgradeIcon = new CIconPanel( GetRunningPanel(), "UpgradeIcon" );

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

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBuildingStatusItem_TeleporterSpeed::OnTick( void )
{
	// We only tick while active and with a valid built object
	C_ObjectTeleporter *pTeleporter = static_cast<C_ObjectTeleporter*>( GetRepresentativeObject() );

	if ( pTeleporter && IsActive() )
	{
		if ( pTeleporter->GetState() == TELEPORTER_STATE_RECHARGING )
		{
			// Update the recharge
			float flMaxRecharge = pTeleporter->GetCurrentRechargeDuration();
			float flChargeTime = pTeleporter->GetChargeTime();
			m_pRechargeTimer->SetProgress( 1.0 - ( flChargeTime / flMaxRecharge ) );
		}
	}

	BaseClass::OnTick();
}

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

	// We only tick while active and with a valid built object
	C_ObjectTeleporter *pTeleporter = static_cast<C_ObjectTeleporter*>( GetRepresentativeObject() );

	if ( !IsActive() || !pTeleporter )
	{
		return;
	}

	bool bRecharging = ( pTeleporter->GetState() == TELEPORTER_STATE_RECHARGING );

	m_pChargingPanel->SetVisible( bRecharging );
	m_pFullyChargedPanel->SetVisible( !bRecharging );

	// How many times has this teleporter been used?
	m_pFullyChargedPanel->SetDialogVariable( "timesused", pTeleporter->GetTimesUsed() );

	int iUpgradeLevel = pTeleporter->GetUpgradeLevel();

	Assert( iUpgradeLevel >= 1 && iUpgradeLevel <= 3 );

	// upgrade progress
	int iMetal = pTeleporter->GetUpgradeMetal();
	int iMetalRequired = pTeleporter->GetUpgradeMetalRequired();
	float flUpgrade = (float)iMetal / (float)iMetalRequired;
	m_pUpgradeProgress->SetProgress( flUpgrade );

	// upgrade label only in 1 or 2
	m_pUpgradeIcon->SetVisible( iUpgradeLevel < 3 );
	m_pUpgradeProgress->SetVisible( iUpgradeLevel < 3 );
}
#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBuildingStatusItem_Sapper::CBuildingStatusItem_Sapper( Panel *parent ) :
CBuildingStatusItem( parent, "resource/UI/hud_obj_sapper.res", OBJ_ATTACHMENT_SAPPER )
{
	// health of target building
	m_pTargetHealthBar = new ContinuousProgressBar( GetRunningPanel(), "TargetHealth" );

	// image of target building 
	m_pTargetIcon = new CIconPanel( GetRunningPanel(), "TargetIcon" );

	// force first think to set the icon
	m_iTargetType = -1;
}

void CBuildingStatusItem_Sapper::PerformLayout( void )
{
	BaseClass::PerformLayout();

	// We only tick while active and with a valid built object
	C_ObjectSapper *pSapper = static_cast<C_ObjectSapper*>(GetRepresentativeObject());

	// only visible 
	SetVisible( pSapper != NULL );

	if ( !IsActive() || !pSapper )
	{
		return;
	}

	C_BaseObject *pTarget = pSapper->GetParentObject();

	if ( pTarget )
	{
		float flHealth = (float)pTarget->GetHealth() / (float)pTarget->GetMaxHealth();

		m_pTargetHealthBar->SetProgress( flHealth );

		int iTargetType = pTarget->GetType();

		if ( m_iTargetType != iTargetType )
		{
			m_pTargetIcon->SetIcon( pTarget->GetHudStatusIcon() );

			m_iTargetType = iTargetType;
		}
	}
	else
	{
		m_pTargetHealthBar->SetProgress( 0.0f );
	}
}


//============================================================================


DECLARE_HUDELEMENT( CHudBuildingStatusContainer_Spy );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CHudBuildingStatusContainer_Spy::CHudBuildingStatusContainer_Spy( const char *pElementName ) :
BaseClass( "BuildingStatus_Spy" )
{
	AddBuildingPanel( OBJ_ATTACHMENT_SAPPER );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CHudBuildingStatusContainer_Spy::ShouldDraw( void )
{
	// Don't draw in freezecam
	C_TFPlayer *pPlayer = CTFPlayer::GetLocalTFPlayer();
	if ( !pPlayer || !pPlayer->IsPlayerClass( TF_CLASS_SPY ) || pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
	{
		return false;
	}

	if ( pPlayer->GetTeamNumber() <= TEAM_SPECTATOR )
	{
		return false;
	}

	return CHudElement::ShouldDraw();
}

//============================================================================

DECLARE_HUDELEMENT( CHudBuildingStatusContainer_Engineer );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CHudBuildingStatusContainer_Engineer::CHudBuildingStatusContainer_Engineer( const char *pElementName ) :
BaseClass( "BuildingStatus_Engineer" )
{
	AddBuildingPanel( OBJ_SENTRYGUN, MODE_SENTRYGUN_NORMAL );
	AddBuildingPanel( OBJ_DISPENSER );
	AddBuildingPanel( OBJ_TELEPORTER, MODE_TELEPORTER_ENTRANCE );
	AddBuildingPanel( OBJ_TELEPORTER, MODE_TELEPORTER_EXIT );
	AddBuildingPanel( OBJ_SENTRYGUN, MODE_SENTRYGUN_DISPOSABLE );
#ifdef STAGING_ONLY
	AddBuildingPanel( OBJ_TELEPORTER, MODE_TELEPORTER_SPEED );
	AddBuildingPanel( OBJ_TELEPORTER, MODE_TELEPORTER_SPEED2 );
#endif

	vgui::ivgui()->AddTickSignal( GetVPanel(), 500 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CHudBuildingStatusContainer_Engineer::ShouldDraw( void )
{
	// Don't draw in freezecam
	C_TFPlayer *pPlayer = CTFPlayer::GetLocalTFPlayer();
	if ( !pPlayer || !pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) || pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
		return false;

	if ( pPlayer->GetTeamNumber() <= TEAM_SPECTATOR )
		return false;

	if ( CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() )
		return false;

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

	return CHudElement::ShouldDraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudBuildingStatusContainer_Engineer::OnTick()
{
	BaseClass::OnTick();
	
	if ( !ShouldDraw() )
		return;

	C_TFPlayer *pLocalPlayer = CTFPlayer::GetLocalTFPlayer();
	if ( pLocalPlayer )
	{
		bool bDisposableSentriesVisible = false;

		if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
		{
			int nDisposableSentries = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, nDisposableSentries, engy_disposable_sentries );
			if ( nDisposableSentries )
			{
				bDisposableSentriesVisible = true;
			}
		}

#ifdef STAGING_ONLY	
		int iSpeedPad = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, iSpeedPad, teleporter_is_speedpad );
#endif // STAGING_ONLY		

		for ( int i = 0 ; i < m_BuildingPanels.Count() ; i++ )
		{
			CBuildingStatusItem *pItem = m_BuildingPanels.Element( i );

			if ( pItem && ( pItem->GetRepresentativeObjectType() == OBJ_SENTRYGUN ) && ( pItem->GetRepresentativeObjectMode() == MODE_SENTRYGUN_DISPOSABLE ) )
			{
				if ( pItem->IsVisible() != bDisposableSentriesVisible )
				{
					pItem->SetVisible( bDisposableSentriesVisible );
				}

#ifndef STAGING_ONLY	
				break;
#endif // !STAGING_ONLY
			}

#ifdef STAGING_ONLY	
			// Disable entrance and exit
			if ( pItem && ( pItem->GetRepresentativeObjectType() == OBJ_TELEPORTER ) )
			{
				if ( pItem->GetRepresentativeObjectMode() == MODE_TELEPORTER_SPEED || pItem->GetRepresentativeObjectMode() == MODE_TELEPORTER_SPEED2 )
				{
					pItem->SetVisible( iSpeedPad );
				}
				else
				{
					pItem->SetVisible( !(bool)(iSpeedPad) );
				}
			}
#endif // STAGING_ONLY		
		}
	}
}

//============================================================================

// order the buildings in our m_BuildingsList by their object priority
typedef CBuildingStatusItem *BUILDINGSTATUSITEM_PTR;
static bool BuildingOrderLessFunc( const BUILDINGSTATUSITEM_PTR &left, const BUILDINGSTATUSITEM_PTR &right )
{
	return ( left->GetObjectPriority() <= right->GetObjectPriority() );
}

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

	SetHiddenBits( HIDEHUD_MISCSTATUS );

	SetProportional(true);

	ListenForGameEvent( "building_info_changed" );

	m_BuildingPanels.SetLessFunc( BuildingOrderLessFunc );

	m_AlertLevel = BUILDING_HUD_ALERT_NONE;
	m_flNextBeep = 0;
	m_iNumBeepsToBeep = 0;

	// for beeping
	vgui::ivgui()->AddTickSignal( GetVPanel() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CHudBuildingStatusContainer::ShouldDraw( void )
{
	// Don't draw in freezecam
	C_TFPlayer *pPlayer = CTFPlayer::GetLocalTFPlayer();
	if ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
		return false;

	return CHudElement::ShouldDraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudBuildingStatusContainer::LevelInit( void )
{
	CHudElement::LevelInit();

	for ( int i = 0; i < m_BuildingPanels.Count(); i++ )
	{
		CBuildingStatusItem *pItem = m_BuildingPanels.Element(i);

		if ( pItem )
		{
			pItem->LevelInit();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Create the appropriate info panel for the object
//-----------------------------------------------------------------------------
CBuildingStatusItem *CHudBuildingStatusContainer::CreateItemPanel( int iObjectType, int iObjectMode )
{
	CBuildingStatusItem *pBuildingItem = NULL;
	
	switch( iObjectType )
	{
	case OBJ_SENTRYGUN:
		if ( iObjectMode == 0 )
		{
			pBuildingItem = new CBuildingStatusItem_SentryGun( this );
		}
		else
		{
			pBuildingItem = new CBuildingStatusItem_SentryGun_Disposable( this );
		}
		break;
	case OBJ_DISPENSER:
		pBuildingItem = new CBuildingStatusItem_Dispenser( this );
		break;
	case OBJ_TELEPORTER:
		if ( iObjectMode == 0 )
		{
			pBuildingItem = new CBuildingStatusItem_TeleporterEntrance( this );
		}
		else if ( iObjectMode == 1 )
		{
			pBuildingItem = new CBuildingStatusItem_TeleporterExit( this );
		}
#ifdef STAGING_ONLY		
		else if ( iObjectMode == 2 )
		{
			pBuildingItem = new CBuildingStatusItem_TeleporterSpeed( this, MODE_TELEPORTER_SPEED );
		}
		else
		{
			pBuildingItem = new CBuildingStatusItem_TeleporterSpeed( this, MODE_TELEPORTER_SPEED2 );
		}
#endif
		break;
	case OBJ_ATTACHMENT_SAPPER:
		pBuildingItem = new CBuildingStatusItem_Sapper( this );
		break;
	default:
		pBuildingItem = NULL;
		break;
	}
	
	Assert( pBuildingItem );

	return pBuildingItem;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudBuildingStatusContainer::AddBuildingPanel( int iObjectType, int iObjectMode )
{
	CBuildingStatusItem *pBuildingItem = CreateItemPanel( iObjectType, iObjectMode );

	Assert( pBuildingItem );

	pBuildingItem->SetPos( 0, 0 );
	pBuildingItem->InvalidateLayout();

	m_BuildingPanels.Insert( pBuildingItem );

	RepositionObjectPanels();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudBuildingStatusContainer::UpdateAllBuildings( void )
{
	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pLocalPlayer )
		return;

	for ( int i = 0; i < m_BuildingPanels.Count(); i++ )
	{
		CBuildingStatusItem *pItem = m_BuildingPanels.Element(i);

		if ( pItem )
		{
			// find the item that represents this building type
			C_BaseObject *pObj = NULL;
			if ( pObj )
			{
				// find the object
				pObj = pLocalPlayer->GetObjectOfType( pItem->GetRepresentativeObjectType(), pItem->GetRepresentativeObjectMode() );

				pItem->SetObject( pObj );

				pItem->InvalidateLayout( true );
				RecalculateAlertState();
			}
		}
	}
}


void CHudBuildingStatusContainer::OnBuildingChanged( int iBuildingType, int iBuildingMode, bool bBuildingIsDead )
{
	bool bFound = false;
	for ( int i = 0; i < m_BuildingPanels.Count() && !bFound; i++ )
	{
		CBuildingStatusItem *pItem = m_BuildingPanels.Element(i);

		if ( pItem && pItem->GetRepresentativeObjectType() == iBuildingType && pItem->GetRepresentativeObjectMode() == iBuildingMode )
		{
			// find the item that represents this building type
			C_BaseObject *pObj = NULL;

			// find the object
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pLocalPlayer )
			{
				pObj = pLocalPlayer->GetObjectOfType( iBuildingType, iBuildingMode );
				pItem->SetObject( pObj );
				pItem->InvalidateLayout( true );
				bFound = true;

				RecalculateAlertState();
			}
		}
	}
}

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

	SetPaintBackgroundEnabled( false );

	RepositionObjectPanels();
}

//-----------------------------------------------------------------------------
// Purpose: Contents of object list has changed, reposition the panels
//-----------------------------------------------------------------------------
void CHudBuildingStatusContainer::RepositionObjectPanels( void )
{
	float flXPos = XRES(9);
	float flYPos = YRES(9);

	float flTeleEntranceY = YRES(9);
	float flTeleExitY = YRES(9);

	// Regular Panels
	for ( int i = 0; i < m_BuildingPanels.Count(); i++ )
	{
		CBuildingStatusItem *pItem = m_BuildingPanels.Element(i);

		if ( pItem )
		{
			// set position directly
			pItem->SetPos( flXPos, flYPos );

			// do not increment for speed pad (this is a minor hack)
			// OBJ_TELEPORTER, MODE_TELEPORTER_SPEED
			if ( pItem->GetRepresentativeObjectType() == OBJ_TELEPORTER )
			{
				switch ( pItem->GetRepresentativeObjectMode() )
				{
					case MODE_TELEPORTER_ENTRANCE:
						flTeleEntranceY = flYPos;
						flYPos += pItem->GetTall();
						break;
					case MODE_TELEPORTER_EXIT:
						flTeleExitY = flYPos;
						flYPos += pItem->GetTall();
						break;
#ifdef STAGING_ONLY						
					case MODE_TELEPORTER_SPEED:
						pItem->SetPos( flXPos, flTeleEntranceY );
						break;
					case MODE_TELEPORTER_SPEED2:
						pItem->SetPos( flXPos, flTeleExitY );						
						break;
#endif						
				}
			}
			else
			{
				flYPos += pItem->GetTall();	// the fade around the panels gives a gap
			}
		}
	}
}

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

	if ( Q_strcmp(type, "building_info_changed" ) == 0 )
	{
		int iBuildingType = event->GetInt( "building_type" );
		int iBuildingMode = event->GetInt( "object_mode" );

		if ( iBuildingType >= 0 )
		{
			bool bRemove = ( event->GetInt( "remove" ) > 0 );

			OnBuildingChanged( iBuildingType, iBuildingMode, bRemove );
		}
		else
		{
			UpdateAllBuildings();
		}
	}
	else
	{
		CHudElement::FireGameEvent( event );
	}
}

void CHudBuildingStatusContainer::RecalculateAlertState( void )
{
	BuildingHudAlert_t maxAlertLevel = BUILDING_HUD_ALERT_NONE;

	// find our highest warning level
	for ( int i = 0; i < m_BuildingPanels.Count(); i++ )
	{
		CBuildingStatusItem *pItem = m_BuildingPanels.Element(i);
		C_BaseObject * pObj = pItem->GetRepresentativeObject();

		if ( pObj )
		{
			BuildingHudAlert_t alertLevel = pObj->GetBuildingAlertLevel();
			if ( alertLevel > maxAlertLevel )
			{
				if ( pObj->IsMiniBuilding() && alertLevel != BUILDING_HUD_ALERT_LOW_HEALTH && alertLevel != BUILDING_HUD_ALERT_VERY_LOW_HEALTH && alertLevel != BUILDING_HUD_ALERT_SAPPER )
					continue;
				maxAlertLevel = alertLevel;
			}
		}
	}

	if ( maxAlertLevel != m_AlertLevel )
	{
		if ( maxAlertLevel >= BUILDING_HUD_ALERT_VERY_LOW_AMMO )
		{
			m_flNextBeep = gpGlobals->curtime;	// beep asap
			m_iNumBeepsToBeep = tf_hud_num_building_alert_beeps.GetInt();
		}

		m_AlertLevel = maxAlertLevel;
	}
}

void CHudBuildingStatusContainer::OnTick( void )
{
	if ( m_AlertLevel >= BUILDING_HUD_ALERT_VERY_LOW_AMMO &&
		gpGlobals->curtime >= m_flNextBeep && 
		m_iNumBeepsToBeep > 0 )
	{
		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

		if ( !pLocalPlayer )
			return;

		pLocalPlayer->EmitSound( "Hud.Warning" );

		switch( m_AlertLevel )
		{
		case BUILDING_HUD_ALERT_VERY_LOW_AMMO:
		case BUILDING_HUD_ALERT_VERY_LOW_HEALTH:
			m_flNextBeep = gpGlobals->curtime + 2.0f;
			m_iNumBeepsToBeep--;
			break;

		case BUILDING_HUD_ALERT_SAPPER:
			m_flNextBeep = gpGlobals->curtime + 1.0f;
			// don't decrement beeps, we want them to go on forever
			break;
		}
	}
}