d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
114 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 0fb75b41fd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0fb75b41fd'
${ noResults }
source-engine/game/client/tf/tf_hud_building_status.cpp

1720 lines
51 KiB
Raw Blame History

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