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_playerstatus.cpp

1157 lines
39 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "hudelement.h"
#include "iclientmode.h"
#include <KeyValues.h>
#include <vgui/IScheme.h>
#include <vgui/ISurface.h>
#include <vgui/ISystem.h>
#include <vgui_controls/AnimationController.h>
#include <vgui_controls/EditablePanel.h>
#include <vgui/ISurface.h>
#include <vgui/IImage.h>
#include <vgui_controls/Label.h>
#include "c_tf_playerresource.h"
#include "tf_playermodelpanel.h"
#include "econ_item_description.h"
#include "hud_numericdisplay.h"
#include "c_team.h"
#include "c_tf_player.h"
#include "tf_shareddefs.h"
#include "tf_hud_playerstatus.h"
#include "tf_gamerules.h"
#include "tf_logic_halloween_2014.h"
#include "tf_logic_player_destruction.h"
#include "tf_wheel_of_doom.h"
#include "confirm_dialog.h"
using namespace vgui;
ConVar cl_hud_playerclass_use_playermodel( "cl_hud_playerclass_use_playermodel", "1", FCVAR_ARCHIVE, "Use player model in player class HUD." );
#ifdef STAGING_ONLY
ConVar cl_hud_playerclass_playermodel_lod( "cl_hud_playerclass_playermodel_lod", "0", FCVAR_ARCHIVE, "Adjust lod on player model in the player class HUD." );
#endif // STAGING_ONLY
ConVar cl_hud_playerclass_playermodel_showed_confirm_dialog( "cl_hud_playerclass_playermodel_showed_confirm_dialog", "0", FCVAR_ARCHIVE | FCVAR_HIDDEN );
extern ConVar tf_max_health_boost;
static const char *g_szBlueClassImages[] =
{
"",
"../hud/class_scoutblue",
"../hud/class_sniperblue",
"../hud/class_soldierblue",
"../hud/class_demoblue",
"../hud/class_medicblue",
"../hud/class_heavyblue",
"../hud/class_pyroblue",
"../hud/class_spyblue",
"../hud/class_engiblue",
"../hud/class_scoutblue",
};
static const char *g_szRedClassImages[] =
{
"",
"../hud/class_scoutred",
"../hud/class_sniperred",
"../hud/class_soldierred",
"../hud/class_demored",
"../hud/class_medicred",
"../hud/class_heavyred",
"../hud/class_pyrored",
"../hud/class_spyred",
"../hud/class_engired",
"../hud/class_scoutred",
};
enum
{
HUD_HEALTH_NO_ANIM = 0,
HUD_HEALTH_BONUS_ANIM,
HUD_HEALTH_DYING_ANIM,
};
DECLARE_BUILD_FACTORY( CTFClassImage );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFHudPlayerClass::CTFHudPlayerClass( Panel *parent, const char *name ) : EditablePanel( parent, name )
{
m_pClassImage = NULL;
m_pClassImageBG = NULL;
m_pSpyImage = NULL;
m_pSpyOutlineImage = NULL;
m_pPlayerModelPanel = NULL;
m_pPlayerModelPanelBG = NULL;
m_pCarryingWeaponPanel = NULL;
m_pCarryingLabel = NULL;
m_pCarryingOwnerLabel = NULL;
m_pCarryingBG = NULL;
m_nTeam = TEAM_UNASSIGNED;
m_nClass = TF_CLASS_UNDEFINED;
m_nDisguiseTeam = TEAM_UNASSIGNED;
m_nDisguiseClass = TF_CLASS_UNDEFINED;
m_hDisguiseWeapon = NULL;
m_flNextThink = 0.0f;
m_nKillStreak = 0;
#ifdef STAGING_ONLY
m_nLOD = -1;
#endif // STAGING_ONLY
m_bUsePlayerModel = cl_hud_playerclass_use_playermodel.GetBool();
ListenForGameEvent( "localplayer_changedisguise" );
ListenForGameEvent( "post_inventory_application" );
ListenForGameEvent( "localplayer_pickup_weapon" );
for ( int i = 0; i < TF_CLASS_COUNT_ALL; i++ )
{
// The materials are given to vgui via the SetImage() function, which prepends
// the "vgui/", so we need to precache them with the same.
if ( g_szBlueClassImages[i] && g_szBlueClassImages[i][0] )
{
PrecacheMaterial( VarArgs( "vgui/%s", g_szBlueClassImages[i] ) );
PrecacheMaterial( VarArgs( "vgui/%s_cloak", g_szBlueClassImages[i] ) );
PrecacheMaterial( VarArgs( "vgui/%s_halfcloak", g_szBlueClassImages[i] ) );
}
if ( g_szRedClassImages[i] && g_szRedClassImages[i][0] )
{
PrecacheMaterial( VarArgs( "vgui/%s", g_szRedClassImages[i] ) );
PrecacheMaterial( VarArgs( "vgui/%s_cloak", g_szRedClassImages[i] ) );
PrecacheMaterial( VarArgs( "vgui/%s_halfcloak", g_szRedClassImages[i] ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerClass::Reset()
{
m_flNextThink = gpGlobals->curtime + 0.05f;
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudSpyDisguiseHide" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerClass::ApplySchemeSettings( IScheme *pScheme )
{
// load control settings...
LoadControlSettings( "resource/UI/HudPlayerClass.res" );
m_nTeam = TEAM_UNASSIGNED;
m_nClass = TF_CLASS_UNDEFINED;
m_nDisguiseTeam = TEAM_UNASSIGNED;
m_nDisguiseClass = TF_CLASS_UNDEFINED;
m_hDisguiseWeapon = NULL;
m_flNextThink = 0.0f;
m_nCloakLevel = 0;
m_nLoadoutPosition = LOADOUT_POSITION_PRIMARY;
m_pClassImage = FindControl<CTFClassImage>( "PlayerStatusClassImage", false );
m_pClassImageBG = FindControl<CTFImagePanel>( "PlayerStatusClassImageBG", false );
m_pSpyImage = FindControl<CTFImagePanel>( "PlayerStatusSpyImage", false );
m_pSpyOutlineImage = FindControl<CTFImagePanel>( "PlayerStatusSpyOutlineImage", false );
m_pPlayerModelPanel = FindControl<CTFPlayerModelPanel>( "classmodelpanel", false );
m_pPlayerModelPanelBG = FindControl<CTFImagePanel>( "classmodelpanelBG", false );
m_pCarryingWeaponPanel = FindControl< EditablePanel >( "CarryingWeapon", false );
if ( m_pCarryingWeaponPanel )
{
m_pCarryingLabel = m_pCarryingWeaponPanel->FindControl< CExLabel >( "CarryingLabel" );
m_pCarryingOwnerLabel = m_pCarryingWeaponPanel->FindControl< Label >( "OwnerLabel" );
m_pCarryingBG = m_pCarryingWeaponPanel->FindControl< CTFImagePanel >( "CarryingBackground" );
}
BaseClass::ApplySchemeSettings( pScheme );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerClass::OnThink()
{
if ( m_flNextThink > gpGlobals->curtime )
return;
m_flNextThink = gpGlobals->curtime + 0.5f;
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer )
return;
bool bTeamChange = false;
// set our background colors
if ( m_nTeam != pPlayer->GetTeamNumber() )
{
bTeamChange = true;
m_nTeam = pPlayer->GetTeamNumber();
}
int nCloakLevel = 0;
bool bCloakChange = false;
float flInvis = pPlayer->GetPercentInvisible();
if ( flInvis > 0.9 )
{
nCloakLevel = 2;
}
else if ( flInvis > 0.1 )
{
nCloakLevel = 1;
}
if ( nCloakLevel != m_nCloakLevel )
{
m_nCloakLevel = nCloakLevel;
bCloakChange = true;
}
bool bLoadoutPositionChange = false;
int nLoadoutSlot = pPlayer->GetActiveTFWeapon() ? pPlayer->GetActiveTFWeapon()->GetAttributeContainer()->GetItem()->GetStaticData()->GetLoadoutSlot( m_nClass ) : LOADOUT_POSITION_PRIMARY;
if ( m_nLoadoutPosition != nLoadoutSlot )
{
m_nLoadoutPosition = nLoadoutSlot;
bLoadoutPositionChange = true;
}
bool bPlayerClassModeChange = false;
if ( m_bUsePlayerModel != cl_hud_playerclass_use_playermodel.GetBool() )
{
m_bUsePlayerModel = cl_hud_playerclass_use_playermodel.GetBool();
bPlayerClassModeChange = true;
}
#ifdef STAGING_ONLY
if ( m_nLOD != cl_hud_playerclass_playermodel_lod.GetInt() && m_pPlayerModelPanel )
{
m_nLOD = cl_hud_playerclass_playermodel_lod.GetInt();
m_pPlayerModelPanel->SetLOD( m_nLOD );
}
#endif // STAGING_ONLY
bool bForceEyeUpdate = false;
// set our class image
if ( m_nClass != pPlayer->GetPlayerClass()->GetClassIndex() || bTeamChange || bCloakChange || bLoadoutPositionChange || bPlayerClassModeChange ||
(
m_nClass == TF_CLASS_SPY &&
(
m_nDisguiseClass != pPlayer->m_Shared.GetDisguiseClass() ||
m_nDisguiseTeam != pPlayer->m_Shared.GetDisguiseTeam() ||
m_hDisguiseWeapon != pPlayer->m_Shared.GetDisguiseWeapon()
)
)
)
{
bForceEyeUpdate = true;
m_nClass = pPlayer->GetPlayerClass()->GetClassIndex();
if ( m_nClass == TF_CLASS_SPY && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
{
if ( !pPlayer->m_Shared.InCond( TF_COND_DISGUISING ) )
{
m_nDisguiseTeam = pPlayer->m_Shared.GetDisguiseTeam();
m_nDisguiseClass = pPlayer->m_Shared.GetDisguiseClass();
m_hDisguiseWeapon = pPlayer->m_Shared.GetDisguiseWeapon();
}
}
else
{
m_nDisguiseTeam = TEAM_UNASSIGNED;
m_nDisguiseClass = TF_CLASS_UNDEFINED;
m_hDisguiseWeapon = NULL;
}
if ( m_bUsePlayerModel && m_pPlayerModelPanel && m_pPlayerModelPanelBG )
{
m_pPlayerModelPanel->SetVisible( true );
m_pPlayerModelPanelBG->SetVisible( true );
UpdateModelPanel();
}
else if ( m_pClassImage && m_pSpyImage )
{
if ( m_pPlayerModelPanel )
m_pPlayerModelPanel->SetVisible( false );
if ( m_pPlayerModelPanelBG )
m_pPlayerModelPanelBG->SetVisible( false );
m_pClassImage->SetVisible( true );
m_pClassImageBG->SetVisible( true );
int iCloakState = 0;
if ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) )
{
iCloakState = m_nCloakLevel;
}
if ( m_nDisguiseTeam != TEAM_UNASSIGNED || m_nDisguiseClass != TF_CLASS_UNDEFINED )
{
m_pSpyImage->SetVisible( true );
m_pClassImage->SetClass( m_nDisguiseTeam, m_nDisguiseClass, iCloakState );
}
else
{
m_pSpyImage->SetVisible( false );
m_pClassImage->SetClass( m_nTeam, m_nClass, iCloakState );
}
}
}
if ( m_pCarryingWeaponPanel )
{
// Don't show if we're disguised (the panels overlap)
bool bShowCarryingWeaponPanel = m_nDisguiseClass == TF_CLASS_UNDEFINED;
if ( pPlayer->GetActiveTFWeapon() && pPlayer->GetActiveTFWeapon()->GetAttributeContainer() )
{
CEconItemView* pItem = pPlayer->GetActiveTFWeapon()->GetAttributeContainer()->GetItem();
if ( pItem )
{
CSteamID playerSteamID;
pPlayer->GetSteamID( &playerSteamID );
// We're holding a weapon we dont own!
if ( playerSteamID.GetAccountID() != pItem->GetAccountID() && m_pCarryingLabel )
{
locchar_t wszLocString [128];
// Construct and set the weapon's name
g_pVGuiLocalize->ConstructString_safe( wszLocString, L"%s1", 1, CEconItemLocalizedFullNameGenerator( GLocalizationProvider(), pItem->GetItemDefinition(), pItem->GetItemQuality() ).GetFullName() );
m_pCarryingWeaponPanel->SetDialogVariable( "carrying", wszLocString );
// Get and set the rarity color of the weapon
const char* pszColorName = GetItemSchema()->GetRarityColor( pItem->GetItemDefinition()->GetRarity() );
pszColorName = pszColorName ? pszColorName : "TanLight";
if ( pszColorName )
{
m_pCarryingLabel->SetColorStr( pszColorName );
}
bool bHasOwner = false;
locchar_t wszPlayerName [128];
CBasePlayer *pOwner = GetPlayerByAccountID( pItem->GetAccountID() );
// Bots will not work here, so don't fill this out if there's no owner
if ( pOwner )
{
// Fill out the actual owner's name
locchar_t wszStolenString[128];
g_pVGuiLocalize->ConvertANSIToUnicode( pOwner->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
g_pVGuiLocalize->ConstructString_safe( wszStolenString, g_pVGuiLocalize->Find( "TF_WhoDropped" ), 1, wszPlayerName );
m_pCarryingOwnerLabel->SetText( wszStolenString );
bHasOwner = true;
}
else
{
m_pCarryingOwnerLabel->SetText( "" );
}
int nMaxWide = 0, nMaxTall = 0;
// Resize the panel to just be the width of whichever label is longer
int nTall, nWide;
m_pCarryingLabel->SizeToContents();
m_pCarryingLabel->GetContentSize( nWide, nTall );
nMaxWide = Max( nMaxWide, nWide );
nMaxTall = Max( nMaxTall, nTall );
m_pCarryingOwnerLabel->SizeToContents();
m_pCarryingOwnerLabel->GetContentSize( nWide, nTall );
nMaxWide = Max( nMaxWide, nWide );
nMaxTall = Max( nMaxTall, nTall );
m_pCarryingBG->SetWide( nMaxWide + ( m_pCarryingLabel->GetXPos() * 2 ) );
m_pCarryingBG->SetTall( bHasOwner ? m_pCarryingOwnerLabel->GetYPos() + m_pCarryingOwnerLabel->GetTall() + YRES( 2 )
: m_pCarryingLabel->GetYPos() + m_pCarryingLabel->GetTall() + YRES( 2 ) );
}
else
{
bShowCarryingWeaponPanel = false;
}
}
}
else
{
bShowCarryingWeaponPanel = false;
}
if ( CTFPlayerDestructionLogic::GetRobotDestructionLogic() && ( CTFPlayerDestructionLogic::GetRobotDestructionLogic()->GetType() == CTFPlayerDestructionLogic::TYPE_PLAYER_DESTRUCTION ) )
{
if ( pPlayer->HasTheFlag() )
{
bShowCarryingWeaponPanel = false;
}
}
m_pCarryingWeaponPanel->SetVisible( bShowCarryingWeaponPanel );
}
if ( m_bUsePlayerModel && m_pPlayerModelPanel )
{
bool bPlaySparks = false;
int iKillStreak = pPlayer->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills );
if ( iKillStreak != m_nKillStreak && iKillStreak > 0 )
{
bPlaySparks = true;
}
m_nKillStreak = iKillStreak;
m_pPlayerModelPanel->SetEyeGlowEffect( pPlayer->GetEyeGlowEffect(), pPlayer->GetEyeGlowColor( false ), pPlayer->GetEyeGlowColor( true ), bForceEyeUpdate, bPlaySparks );
}
}
static void HudPlayerClassUsePlayerModelDialogCallback( bool bConfirmed, void *pContext )
{
cl_hud_playerclass_use_playermodel.SetValue( bConfirmed );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerClass::UpdateModelPanel()
{
if ( !m_bUsePlayerModel )
{
return;
}
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer || !pPlayer->IsAlive() )
{
return;
}
if ( !cl_hud_playerclass_playermodel_showed_confirm_dialog.GetBool() )
{
// only show this message one time
ShowConfirmDialog( "#GameUI_HudPlayerClassUsePlayerModelDialogTitle",
"#GameUI_HudPlayerClassUsePlayerModelDialogMessage",
"#GameUI_HudPlayerClassUsePlayerModelDialogConfirm",
"#GameUI_HudPlayerClassUsePlayerModelDialogCancel",
&HudPlayerClassUsePlayerModelDialogCallback );
cl_hud_playerclass_playermodel_showed_confirm_dialog.SetValue( true );
}
// hide old UI
if ( m_pSpyImage )
m_pSpyImage->SetVisible( false );
if ( m_pClassImage )
m_pClassImage->SetVisible( false );
if ( m_pClassImageBG )
m_pClassImageBG->SetVisible( false );
if ( m_pPlayerModelPanel && m_pPlayerModelPanel->IsVisible() )
{
int nClass;
int nTeam;
int nItemSlot = m_nLoadoutPosition;
CEconItemView *pWeapon = NULL;
bool bDisguised = pPlayer->m_Shared.InCond( TF_COND_DISGUISED );
if ( bDisguised )
{
nClass = pPlayer->m_Shared.GetDisguiseClass();
nTeam = pPlayer->m_Shared.GetDisguiseTeam();
if ( pPlayer->m_Shared.GetDisguiseWeapon() )
{
CAttributeContainer *pCont = pPlayer->m_Shared.GetDisguiseWeapon()->GetAttributeContainer();
pWeapon = pCont ? pCont->GetItem() : NULL;
if ( pWeapon )
{
nItemSlot = pWeapon->GetStaticData()->GetLoadoutSlot( nClass );
}
}
}
else
{
nClass = pPlayer->GetPlayerClass()->GetClassIndex();
nTeam = pPlayer->GetTeamNumber();
CTFWeaponBase *pEnt = dynamic_cast< CTFWeaponBase* >( pPlayer->GetEntityForLoadoutSlot( nItemSlot ) );
if ( pEnt )
{
pWeapon = pEnt->GetAttributeContainer()->GetItem();
}
}
bool bIsRobot = false;
int iRobot = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iRobot, appear_as_mvm_robot );
bIsRobot = iRobot ? true : false;
m_pPlayerModelPanel->ClearCarriedItems();
m_pPlayerModelPanel->SetToPlayerClass( nClass, bIsRobot );
m_pPlayerModelPanel->SetTeam( nTeam );
if ( pWeapon )
{
m_pPlayerModelPanel->AddCarriedItem( pWeapon );
}
for ( int wbl = pPlayer->GetNumWearables()-1; wbl >= 0; wbl-- )
{
C_TFWearable *pItem = dynamic_cast<C_TFWearable*>( pPlayer->GetWearable( wbl ) );
if ( !pItem )
continue;
if ( pItem->IsViewModelWearable() )
continue;
if ( pItem->IsDisguiseWearable() && !bDisguised )
continue;
if ( !pItem->IsDisguiseWearable() && bDisguised )
continue;
CAttributeContainer *pCont = pItem->GetAttributeContainer();
CEconItemView *pEconItemView = pCont ? pCont->GetItem() : NULL;
if ( pEconItemView && pEconItemView->IsValid() )
{
m_pPlayerModelPanel->AddCarriedItem( pEconItemView );
}
}
m_pPlayerModelPanel->HoldItemInSlot( nItemSlot );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerClass::FireGameEvent( IGameEvent * event )
{
const char* pszEventName = event->GetName();
if ( FStrEq( "localplayer_changedisguise", pszEventName ) )
{
if ( m_pSpyImage && m_pSpyOutlineImage )
{
bool bFadeIn = event->GetBool( "disguised", false );
if ( bFadeIn )
{
m_pSpyImage->SetAlpha( 0 );
}
else
{
m_pSpyImage->SetAlpha( 255 );
}
m_pSpyOutlineImage->SetAlpha( 0 );
m_pSpyImage->SetVisible( true );
m_pSpyOutlineImage->SetVisible( true );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( bFadeIn ? "HudSpyDisguiseFadeIn" : "HudSpyDisguiseFadeOut" );
}
UpdateModelPanel();
}
else if ( FStrEq( "post_inventory_application", pszEventName ) )
{
// Force a refresh. if this is for the local player
int iUserID = event->GetInt( "userid" );
C_TFPlayer* pPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( pPlayer && pPlayer->GetUserID() == iUserID )
{
UpdateModelPanel();
}
}
else if ( FStrEq( "localplayer_pickup_weapon", pszEventName ) )
{
UpdateModelPanel();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFHealthPanel::CTFHealthPanel( Panel *parent, const char *name ) : vgui::Panel( parent, name )
{
m_flHealth = 1.0f;
m_iMaterialIndex = surface()->DrawGetTextureId( "hud/health_color" );
if ( m_iMaterialIndex == -1 ) // we didn't find it, so create a new one
{
m_iMaterialIndex = surface()->CreateNewTextureID();
surface()->DrawSetTextureFile( m_iMaterialIndex, "hud/health_color", true, false );
}
m_iDeadMaterialIndex = surface()->DrawGetTextureId( "hud/health_dead" );
if ( m_iDeadMaterialIndex == -1 ) // we didn't find it, so create a new one
{
m_iDeadMaterialIndex = surface()->CreateNewTextureID();
surface()->DrawSetTextureFile( m_iDeadMaterialIndex, "hud/health_dead", true, false );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHealthPanel::Paint()
{
BaseClass::Paint();
int x, y, w, h;
GetBounds( x, y, w, h );
Vertex_t vert[4];
float uv1 = 0.0f;
float uv2 = 1.0f;
int xpos = 0, ypos = 0;
if ( m_flHealth <= 0 )
{
// Draw the dead material
surface()->DrawSetTexture( m_iDeadMaterialIndex );
vert[0].Init( Vector2D( xpos, ypos ), Vector2D( uv1, uv1 ) );
vert[1].Init( Vector2D( xpos + w, ypos ), Vector2D( uv2, uv1 ) );
vert[2].Init( Vector2D( xpos + w, ypos + h ), Vector2D( uv2, uv2 ) );
vert[3].Init( Vector2D( xpos, ypos + h ), Vector2D( uv1, uv2 ) );
surface()->DrawSetColor( Color(255,255,255,255) );
}
else
{
float flDamageY = h * ( 1.0f - m_flHealth );
// blend in the red "damage" part
surface()->DrawSetTexture( m_iMaterialIndex );
Vector2D uv11( uv1, uv2 - m_flHealth );
Vector2D uv21( uv2, uv2 - m_flHealth );
Vector2D uv22( uv2, uv2 );
Vector2D uv12( uv1, uv2 );
vert[0].Init( Vector2D( xpos, flDamageY ), uv11 );
vert[1].Init( Vector2D( xpos + w, flDamageY ), uv21 );
vert[2].Init( Vector2D( xpos + w, ypos + h ), uv22 );
vert[3].Init( Vector2D( xpos, ypos + h ), uv12 );
surface()->DrawSetColor( GetFgColor() );
}
surface()->DrawTexturedPolygon( 4, vert );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFHudPlayerHealth::CTFHudPlayerHealth( Panel *parent, const char *name ) : EditablePanel( parent, name )
{
m_pHealthImage = new CTFHealthPanel( this, "PlayerStatusHealthImage" );
m_pHealthImageBG = new ImagePanel( this, "PlayerStatusHealthImageBG" );
m_pHealthBonusImage = new ImagePanel( this, "PlayerStatusHealthBonusImage" );
m_pBuildingHealthImageBG = new ImagePanel( this, "BuildingStatusHealthImageBG" );
m_pBleedImage = new ImagePanel( this, "PlayerStatusBleedImage" );
m_pHookBleedImage = new ImagePanel( this, "PlayerStatusHookBleedImage" );
m_pMarkedForDeathImage = new ImagePanel( this, "PlayerStatusMarkedForDeathImage" );
m_pMarkedForDeathImageSilent = new ImagePanel( this, "PlayerStatusMarkedForDeathSilentImage" );
m_pMilkImage = new ImagePanel( this, "PlayerStatusMilkImage" );
m_pWheelOfDoomImage = new ImagePanel( this, "PlayerStatus_WheelOfDoom" );
m_flNextThink = 0.0f;
m_nBonusHealthOrigX = -1;
m_nBonusHealthOrigY = -1;
m_nBonusHealthOrigW = -1;
m_nBonusHealthOrigH = -1;
// Vaccinator
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_MEDIGUN_UBER_BULLET_RESIST, BUFF_CLASS_BULLET_RESIST, new ImagePanel( this, "PlayerStatus_MedicUberBulletResistImage" ), "../HUD/defense_buff_bullet_blue", "../HUD/defense_buff_bullet_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_MEDIGUN_UBER_BLAST_RESIST, BUFF_CLASS_BLAST_RESIST, new ImagePanel( this, "PlayerStatus_MedicUberBlastResistImage" ), "../HUD/defense_buff_explosion_blue", "../HUD/defense_buff_explosion_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_MEDIGUN_UBER_FIRE_RESIST, BUFF_CLASS_FIRE_RESIST, new ImagePanel( this, "PlayerStatus_MedicUberFireResistImage" ), "../HUD/defense_buff_fire_blue", "../HUD/defense_buff_fire_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_MEDIGUN_SMALL_BULLET_RESIST, BUFF_CLASS_BULLET_RESIST, new ImagePanel( this, "PlayerStatus_MedicSmallBulletResistImage" ), "../HUD/defense_buff_bullet_blue", "../HUD/defense_buff_bullet_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_MEDIGUN_SMALL_BLAST_RESIST, BUFF_CLASS_BLAST_RESIST, new ImagePanel( this, "PlayerStatus_MedicSmallBlastResistImage" ), "../HUD/defense_buff_explosion_blue", "../HUD/defense_buff_explosion_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_MEDIGUN_SMALL_FIRE_RESIST, BUFF_CLASS_FIRE_RESIST, new ImagePanel( this, "PlayerStatus_MedicSmallFireResistImage" ), "../HUD/defense_buff_fire_blue", "../HUD/defense_buff_fire_red" ) );
// Soldier buffs
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_OFFENSEBUFF, BUFF_CLASS_SOLDIER_OFFENSE, new ImagePanel( this, "PlayerStatus_SoldierOffenseBuff" ), "../Effects/soldier_buff_offense_blue", "../Effects/soldier_buff_offense_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_DEFENSEBUFF, BUFF_CLASS_SOLDIER_DEFENSE, new ImagePanel( this, "PlayerStatus_SoldierDefenseBuff" ), "../Effects/soldier_buff_defense_blue", "../Effects/soldier_buff_defense_red" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_REGENONDAMAGEBUFF, BUFF_CLASS_SOLDIER_HEALTHONHIT, new ImagePanel( this, "PlayerStatus_SoldierHealOnHitBuff" ), "../Effects/soldier_buff_healonhit_blue", "../Effects/soldier_buff_healonhit_red" ) );
// Powerup Rune status
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_STRENGTH, RUNE_CLASS_STRENGTH, new ImagePanel( this, "PlayerStatus_RuneStrength" ), "../Effects/powerup_strength_hud", "../Effects/powerup_strength_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_HASTE, RUNE_CLASS_HASTE, new ImagePanel( this, "PlayerStatus_RuneHaste" ), "../Effects/powerup_haste_hud", "../Effects/powerup_haste_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_REGEN, RUNE_CLASS_REGEN, new ImagePanel( this, "PlayerStatus_RuneRegen" ), "../Effects/powerup_regen_hud", "../Effects/powerup_regen_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_RESIST, RUNE_CLASS_RESIST, new ImagePanel( this, "PlayerStatus_RuneResist" ), "../Effects/powerup_resist_hud", "../Effects/powerup_resist_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_VAMPIRE, RUNE_CLASS_VAMPIRE, new ImagePanel( this, "PlayerStatus_RuneVampire" ), "../Effects/powerup_vampire_hud", "../Effects/powerup_vampire_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_REFLECT, RUNE_CLASS_REFLECT, new ImagePanel( this, "PlayerStatus_RuneReflect" ), "../Effects/powerup_reflect_hud", "../Effects/powerup_reflect_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_PRECISION, RUNE_CLASS_PRECISION, new ImagePanel( this, "PlayerStatus_RunePrecision" ), "../Effects/powerup_precision_hud", "../Effects/powerup_precision_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_AGILITY, RUNE_CLASS_AGILITY, new ImagePanel( this, "PlayerStatus_RuneAgility" ), "../Effects/powerup_agility_hud", "../Effects/powerup_agility_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_KNOCKOUT, RUNE_CLASS_KNOCKOUT, new ImagePanel( this, "PlayerStatus_RuneKnockout" ), "../Effects/powerup_knockout_hud", "../Effects/powerup_knockout_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_KING, RUNE_CLASS_KING, new ImagePanel( this, "PlayerStatus_RuneKing" ), "../Effects/powerup_king_hud", "../Effects/powerup_king_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_PLAGUE, RUNE_CLASS_PLAGUE, new ImagePanel( this, "PlayerStatus_RunePlague" ), "../Effects/powerup_plague_hud", "../Effects/powerup_plague_hud" ) );
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_RUNE_SUPERNOVA, RUNE_CLASS_SUPERNOVA, new ImagePanel( this, "PlayerStatus_RuneSupernova" ), "../Effects/powerup_supernova_hud", "../Effects/powerup_supernova_hud" ) );
#ifdef STAGING_ONLY
// Spy Mark
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_TRANQ_MARKED, DEBUFF_CLASS_SPY_MARKED, new ImagePanel( this, "PlayerStatus_SpyMarked" ), "../Effects/tranq_debuff", "../Effects/tranq_debuff" ) );
#endif // STAGING_ONLY
// Parachute
m_vecBuffInfo.AddToTail( new CTFBuffInfo( TF_COND_PARACHUTE_DEPLOYED, BUFF_CLASS_PARACHUTE, new ImagePanel( this, "PlayerStatus_Parachute" ), "../HUD/hud_parachute_active", "../HUD/hud_parachute_active" ) );
m_iAnimState = HUD_HEALTH_NO_ANIM;
m_bAnimate = true;
}
CTFHudPlayerHealth::~CTFHudPlayerHealth()
{
m_vecBuffInfo.PurgeAndDeleteElements();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerHealth::Reset()
{
m_flNextThink = gpGlobals->curtime + 0.05f;
m_nHealth = -1;
m_bBuilding = false;
m_iAnimState = HUD_HEALTH_NO_ANIM;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerHealth::ApplySchemeSettings( IScheme *pScheme )
{
// load control settings...
LoadControlSettings( GetResFilename() );
if ( m_pHealthBonusImage )
{
m_pHealthBonusImage->GetBounds( m_nBonusHealthOrigX, m_nBonusHealthOrigY, m_nBonusHealthOrigW, m_nBonusHealthOrigH );
}
m_flNextThink = 0.0f;
BaseClass::ApplySchemeSettings( pScheme );
m_pBuildingHealthImageBG->SetVisible( m_bBuilding );
m_pPlayerLevelLabel = dynamic_cast<CExLabel*>( FindChildByName( "PlayerStatusPlayerLevel" ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerHealth::SetHealth( int iNewHealth, int iMaxHealth, int iMaxBuffedHealth )
{
// set our health
m_nHealth = iNewHealth;
m_nMaxHealth = iMaxHealth;
m_pHealthImage->SetHealth( (float)(m_nHealth) / (float)(m_nMaxHealth) );
if ( m_pHealthImage )
{
m_pHealthImage->SetFgColor( Color( 255, 255, 255, 255 ) );
}
if ( m_nHealth <= 0 )
{
if ( m_pHealthImageBG->IsVisible() )
{
m_pHealthImageBG->SetVisible( false );
}
if ( m_pBuildingHealthImageBG->IsVisible() )
{
m_pBuildingHealthImageBG->SetVisible( false );
}
HideHealthBonusImage();
}
else
{
if ( !m_pHealthImageBG->IsVisible() )
{
m_pHealthImageBG->SetVisible( true );
}
m_pBuildingHealthImageBG->SetVisible( m_bBuilding );
// are we getting a health bonus?
if ( m_nHealth > m_nMaxHealth )
{
if ( m_pHealthBonusImage && m_nBonusHealthOrigW != -1 )
{
if ( !m_pHealthBonusImage->IsVisible() )
{
m_pHealthBonusImage->SetVisible( true );
}
if ( m_bAnimate && m_iAnimState != HUD_HEALTH_BONUS_ANIM )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudHealthDyingPulseStop" );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudHealthBonusPulse" );
m_iAnimState = HUD_HEALTH_BONUS_ANIM;
}
m_pHealthBonusImage->SetDrawColor( Color( 255, 255, 255, 255 ) );
// scale the flashing image based on how much health bonus we currently have
float flBoostMaxAmount = ( iMaxBuffedHealth ) - m_nMaxHealth;
float flPercent = MIN( ( m_nHealth - m_nMaxHealth ) / flBoostMaxAmount, 1.0f );
int nPosAdj = RoundFloatToInt( flPercent * m_nHealthBonusPosAdj );
int nSizeAdj = 2 * nPosAdj;
m_pHealthBonusImage->SetBounds( m_nBonusHealthOrigX - nPosAdj,
m_nBonusHealthOrigY - nPosAdj,
m_nBonusHealthOrigW + nSizeAdj,
m_nBonusHealthOrigH + nSizeAdj );
}
}
// are we close to dying?
else if ( m_nHealth < m_nMaxHealth * m_flHealthDeathWarning )
{
if ( m_pHealthBonusImage && m_nBonusHealthOrigW != -1 )
{
if ( !m_pHealthBonusImage->IsVisible() )
{
m_pHealthBonusImage->SetVisible( true );
}
if ( m_bAnimate && m_iAnimState != HUD_HEALTH_DYING_ANIM )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudHealthBonusPulseStop" );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudHealthDyingPulse" );
m_iAnimState = HUD_HEALTH_DYING_ANIM;
}
m_pHealthBonusImage->SetDrawColor( m_clrHealthDeathWarningColor );
// scale the flashing image based on how much health bonus we currently have
float flBoostMaxAmount = m_nMaxHealth * m_flHealthDeathWarning;
float flPercent = ( flBoostMaxAmount - m_nHealth ) / flBoostMaxAmount;
int nPosAdj = RoundFloatToInt( flPercent * m_nHealthBonusPosAdj );
int nSizeAdj = 2 * nPosAdj;
m_pHealthBonusImage->SetBounds( m_nBonusHealthOrigX - nPosAdj,
m_nBonusHealthOrigY - nPosAdj,
m_nBonusHealthOrigW + nSizeAdj,
m_nBonusHealthOrigH + nSizeAdj );
}
if ( m_pHealthImage )
{
m_pHealthImage->SetFgColor( m_clrHealthDeathWarningColor );
}
}
// turn it off
else
{
HideHealthBonusImage();
}
}
// set our health display value
if ( m_nHealth > 0 )
{
SetDialogVariable( "Health", m_nHealth );
}
else
{
SetDialogVariable( "Health", "" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerHealth::SetLevel( int nLevel )
{
if ( m_pPlayerLevelLabel )
{
bool bVisible = ( nLevel >= 0 ) ? true : false;
if ( bVisible )
{
m_pPlayerLevelLabel->SetText( CFmtStr( "%d", nLevel ) );
}
if ( m_pPlayerLevelLabel->IsVisible() != bVisible )
{
m_pPlayerLevelLabel->SetVisible( bVisible );
}
}
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerHealth::HideHealthBonusImage( void )
{
if ( m_pHealthBonusImage && m_pHealthBonusImage->IsVisible() )
{
if ( m_nBonusHealthOrigW != -1 )
{
m_pHealthBonusImage->SetBounds( m_nBonusHealthOrigX, m_nBonusHealthOrigY, m_nBonusHealthOrigW, m_nBonusHealthOrigH );
}
m_pHealthBonusImage->SetVisible( false );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudHealthBonusPulseStop" );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudHealthDyingPulseStop" );
m_iAnimState = HUD_HEALTH_NO_ANIM;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static void SetPlayerHealthImagePanelVisibility( CTFPlayer *pPlayer, ETFCond eCond, vgui::ImagePanel *pImagePanel, int& nXOffset, const Color& colorIfVisible )
{
Assert( pImagePanel != NULL );
if ( pPlayer->m_Shared.InCond( eCond ) && !pImagePanel->IsVisible() )
{
pImagePanel->SetVisible( true );
pImagePanel->SetDrawColor( colorIfVisible );
// Reposition ourselves and increase the offset if we are active
int x,y;
pImagePanel->GetPos( x, y );
pImagePanel->SetPos( nXOffset, y );
nXOffset += 100.f;
}
}
void CTFBuffInfo::Update( CTFPlayer *pPlayer )
{
Assert( m_pImagePanel != NULL && pPlayer != NULL );
if ( pPlayer->m_Shared.InCond( m_eCond ) )
{
if( m_pzsBlueImage && m_pzsBlueImage[0] && m_pzsRedImage && m_pzsRedImage[0] )
{
if( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
m_pImagePanel->SetImage( m_pzsBlueImage );
else
m_pImagePanel->SetImage( m_pzsRedImage );
}
}
}
void CTFHudPlayerHealth::OnThink()
{
if ( m_flNextThink < gpGlobals->curtime )
{
C_TFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
if ( pPlayer )
{
SetHealth( pPlayer->GetHealth(), pPlayer->GetMaxHealth(), pPlayer->m_Shared.GetMaxBuffedHealth() );
int color_offset = ((int)(gpGlobals->realtime*10)) % 5;
int color_fade = 160 + (color_offset*10);
// Find our starting point, just above the health '+'
int nXOffset,y;
m_pHealthImage->GetPos( nXOffset, y );
// Nudge over a bit to get centered
nXOffset += 25;
// Turn all the panels off, and below conditionally turn them on
FOR_EACH_VEC( m_vecBuffInfo, i )
{
m_vecBuffInfo[ i ]->m_pImagePanel->SetVisible( false );
}
CUtlVector<BuffClass_t> m_vecActiveClasses;
// Cycle through all the buffs and update them
FOR_EACH_VEC( m_vecBuffInfo, i )
{
// Skip if this class of buff is already being drawn
if( m_vecActiveClasses.Find( m_vecBuffInfo[i]->m_eClass ) != m_vecActiveClasses.InvalidIndex() )
continue;
m_vecBuffInfo[i]->Update( pPlayer );
SetPlayerHealthImagePanelVisibility( pPlayer, m_vecBuffInfo[i]->m_eCond, m_vecBuffInfo[i]->m_pImagePanel, nXOffset, Color( 255, 255, 255, color_fade ) );
// This class of buff is now active.
if( m_vecBuffInfo[i]->m_pImagePanel->IsVisible() )
{
m_vecActiveClasses.AddToTail( m_vecBuffInfo[i]->m_eClass );
}
}
// Turn all the panels off, and below conditionally turn them on
m_pBleedImage->SetVisible( false );
m_pHookBleedImage->SetVisible( false );
m_pMilkImage->SetVisible( false );
m_pMarkedForDeathImage->SetVisible( false );
m_pMarkedForDeathImageSilent->SetVisible( false );
// Old method for goofy color manipulation
int nBloodX = nXOffset;
SetPlayerHealthImagePanelVisibility( pPlayer, TF_COND_BLEEDING, m_pBleedImage, nXOffset, Color( color_fade, 0, 0, 255 ) );
SetPlayerHealthImagePanelVisibility( pPlayer, TF_COND_GRAPPLINGHOOK_BLEEDING, m_pHookBleedImage, nBloodX, Color( 255, 255, 255, 255 ) ); // draw this on top of bleeding
SetPlayerHealthImagePanelVisibility( pPlayer, TF_COND_MAD_MILK, m_pMilkImage, nXOffset, Color( color_fade, color_fade, color_fade, 255 ) );
SetPlayerHealthImagePanelVisibility( pPlayer, TF_COND_MARKEDFORDEATH, m_pMarkedForDeathImage, nXOffset, Color( 255 - color_fade, 245 - color_fade, 245 - color_fade, 255 ) );
SetPlayerHealthImagePanelVisibility( pPlayer, TF_COND_MARKEDFORDEATH_SILENT, m_pMarkedForDeathImageSilent, nXOffset, Color( 125 - color_fade, 255 - color_fade, 255 - color_fade, 255 ) );
SetPlayerHealthImagePanelVisibility( pPlayer, TF_COND_PASSTIME_PENALTY_DEBUFF, m_pMarkedForDeathImageSilent, nXOffset, Color( 125 - color_fade, 255 - color_fade, 255 - color_fade, 255 ) );
UpdateHalloweenStatus();
}
m_flNextThink = gpGlobals->curtime + 0.05f;
}
}
void CTFHudPlayerHealth::UpdateHalloweenStatus( void )
{
if ( TFGameRules()->IsHalloweenEffectStatusActive() )
{
int status = TFGameRules()->GetHalloweenEffectStatus();
if ( status == EFFECT_WHAMMY )
{
m_pWheelOfDoomImage->SetImage( "..\\HUD\\death_wheel_whammy" );
}
else
{
m_pWheelOfDoomImage->SetImage( VarArgs( "..\\HUD\\death_wheel_%d", status - 1 ) );
}
float timeLeft = TFGameRules()->GetHalloweenEffectTimeLeft();
const float warnExpireTime = 3.0f;
const float blinkInterval = 0.25f;
if ( timeLeft < warnExpireTime )
{
int blink = (int)( timeLeft / blinkInterval );
m_pWheelOfDoomImage->SetVisible( blink & 0x1 );
}
else
{
m_pWheelOfDoomImage->SetVisible( true );
}
}
else
{
m_pWheelOfDoomImage->SetVisible( false );
}
}
DECLARE_HUDELEMENT( CTFHudPlayerStatus );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFHudPlayerStatus::CTFHudPlayerStatus( const char *pElementName ) : CHudElement( pElementName ), BaseClass( NULL, "HudPlayerStatus" )
{
Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
m_pHudPlayerClass = new CTFHudPlayerClass( this, "HudPlayerClass" );
m_pHudPlayerHealth = new CTFHudPlayerHealth( this, "HudPlayerHealth" );
SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerStatus::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
// HACK: Work around the scheme application order failing
// to reload the player class hud element's scheme in minmode.
static ConVarRef cl_hud_minmode( "cl_hud_minmode", true );
if ( cl_hud_minmode.IsValid() && cl_hud_minmode.GetBool() )
{
m_pHudPlayerClass->InvalidateLayout( false, true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFHudPlayerStatus::ShouldDraw( void )
{
CTFPlayer *pTFPlayer = CTFPlayer::GetLocalTFPlayer();
if ( pTFPlayer && pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
return false;
if ( CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() )
return false;
if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
return false;
return CHudElement::ShouldDraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudPlayerStatus::Reset()
{
if ( m_pHudPlayerClass )
{
m_pHudPlayerClass->Reset();
}
if ( m_pHudPlayerHealth )
{
m_pHudPlayerHealth->Reset();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFClassImage::SetClass( int iTeam, int iClass, int iCloakstate )
{
char szImage[128];
szImage[0] = '\0';
if ( iTeam == TF_TEAM_BLUE )
{
Q_strncpy( szImage, g_szBlueClassImages[ iClass ], sizeof(szImage) );
}
else
{
Q_strncpy( szImage, g_szRedClassImages[ iClass ], sizeof(szImage) );
}
switch( iCloakstate )
{
case 2:
Q_strncat( szImage, "_cloak", sizeof(szImage), COPY_ALL_CHARACTERS );
break;
case 1:
Q_strncat( szImage, "_halfcloak", sizeof(szImage), COPY_ALL_CHARACTERS );
break;
default:
break;
}
if ( Q_strlen( szImage ) > 0 )
{
SetImage( szImage );
}
}