Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1720 lines
51 KiB

//========= 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;
}
}
}