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.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/tf/tf_hud_target_id.cpp

1564 lines
46 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: HUD Target ID element
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_hud_target_id.h"
#include "c_tf_playerresource.h"
#include "iclientmode.h"
#include "vgui/ILocalize.h"
#include "c_baseobject.h"
#include "c_team.h"
#include "tf_gamerules.h"
#include "tf_hud_statpanel.h"
#if defined( REPLAY_ENABLED )
#include "replay/iclientreplaycontext.h"
#include "replay/ireplaymoviemanager.h"
#include "replay/ienginereplay.h"
#endif // REPLAY_ENABLED
#include "tf_weapon_bonesaw.h"
#include "sourcevr/isourcevirtualreality.h"
#include "tf_revive.h"
#include "tf_logic_robot_destruction.h"
#include "entity_capture_flag.h"
#include "vgui_avatarimage.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "renderparm.h"
#include "tf_dropped_weapon.h"
#include "econ/econ_item_description.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ConVar cl_hud_minmode;
DECLARE_HUDELEMENT( CMainTargetID );
DECLARE_HUDELEMENT( CSpectatorTargetID );
DECLARE_HUDELEMENT( CSecondaryTargetID );
using namespace vgui;
enum
{
SPECTATOR_TARGET_ID_NORMAL = 0,
SPECTATOR_TARGET_ID_BOTTOM_LEFT,
SPECTATOR_TARGET_ID_BOTTOM_CENTER,
SPECTATOR_TARGET_ID_BOTTOM_RIGHT,
};
void SpectatorTargetLocationCallback( IConVar *var, const char *oldString, float oldFloat )
{
CSpectatorTargetID *pSpecTargetID = (CSpectatorTargetID *)GET_HUDELEMENT( CSpectatorTargetID );
if ( pSpecTargetID )
{
pSpecTargetID->InvalidateLayout();
}
}
ConVar tf_spectator_target_location( "tf_spectator_target_location", "0", FCVAR_ARCHIVE, "Determines the location of the spectator targetID panel.", true, 0, true, 3, SpectatorTargetLocationCallback );
ConVar tf_hud_target_id_disable_floating_health( "tf_hud_target_id_disable_floating_health", "0", FCVAR_ARCHIVE, "Set to disable floating health bar" );
ConVar tf_hud_target_id_alpha( "tf_hud_target_id_alpha", "100", FCVAR_ARCHIVE, "Alpha value of target id background, default 100" );
ConVar tf_hud_target_id_offset( "tf_hud_target_id_offset", "0", FCVAR_ARCHIVE, "RES file Y offset for target id" );
ConVar tf_hud_target_id_show_avatars( "tf_hud_target_id_show_avatars", "2", FCVAR_ARCHIVE, "Display Steam avatars on TargetID when using floating health icons. 1 = everyone, 2 = friends only." );
#ifdef STAGING_ONLY
ConVar tf_bountymode_showhealth( "tf_bountymode_showhealth", "0", FCVAR_ARCHIVE, "Show floating health icon over enemy players. 1 = show health, 2 = show health and level", true, 0, true, 2 );
#endif // STAGING_ONLY
bool ShouldHealthBarBeVisible( CBaseEntity *pTarget, CTFPlayer *pLocalPlayer )
{
if ( !pTarget || !pLocalPlayer )
return false;
if ( tf_hud_target_id_disable_floating_health.GetBool() )
return false;
if ( pTarget->IsHealthBarVisible() )
return true;
if ( !pTarget->IsPlayer() )
return false;
if ( pLocalPlayer->IsPlayerClass( TF_CLASS_SPY ) )
return true;
if ( pLocalPlayer->InSameTeam( pTarget ) )
return true;
if ( pLocalPlayer->InSameDisguisedTeam( pTarget ) )
return true;
int iSeeEnemyHealth = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLocalPlayer, iSeeEnemyHealth, see_enemy_health )
if ( iSeeEnemyHealth )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTargetID::CTargetID( const char *pElementName ) :
CHudElement( pElementName ), BaseClass( NULL, pElementName )
{
vgui::Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
m_hFont = g_hFontTrebuchet24;
m_flLastChangeTime = 0;
m_iLastEntIndex = 0;
m_nOriginalY = 0;
m_bArenaPanelVisible = false;
SetHiddenBits( HIDEHUD_MISCSTATUS );
m_pTargetNameLabel = NULL;
m_pTargetDataLabel = NULL;
m_pBGPanel = NULL;
m_pMoveableIcon = NULL;
m_pMoveableSymbolIcon = NULL;
m_pMoveableIconBG = NULL;
m_pMoveableKeyLabel = NULL;
m_pTargetHealth = new CTFSpectatorGUIHealth( this, "SpectatorGUIHealth" );
m_pTargetAmmoIcon = NULL;
m_pTargetKillStreakIcon = NULL;
m_bLayoutOnUpdate = false;
m_pFloatingHealthIcon = NULL;
m_iLastScannedEntIndex = 0;
m_pAvatarImage = NULL;
RegisterForRenderGroup( "mid" );
RegisterForRenderGroup( "commentary" );
m_iRenderPriority = 5;
ListenForGameEvent( "show_class_layout" );
RegisterForRenderGroup( "arena_target_id" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::LevelShutdown( void )
{
if ( m_pFloatingHealthIcon )
{
m_pFloatingHealthIcon->MarkForDeletion();
m_pFloatingHealthIcon = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Setup
//-----------------------------------------------------------------------------
void CTargetID::Reset( void )
{
m_pTargetHealth->Reset();
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
if ( pScheme )
{
m_LabelColorDefault = pScheme->GetColor( "Label.TextColor", Color( 255, 255, 255, 255 ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::FireGameEvent( IGameEvent * event )
{
const char *eventName = event->GetName();
if ( FStrEq( "show_class_layout", eventName ) )
{
if ( TFGameRules() && TFGameRules()->IsInArenaMode() && GetLocalPlayerTeam() > LAST_SHARED_TEAM )
{
m_bArenaPanelVisible = event->GetBool( "show", false );
}
else
{
m_bArenaPanelVisible = false;
}
InvalidateLayout( true );
}
}
//-----------------------------------------------------------------------------
bool CTargetID::DrawHealthIcon()
{
C_BaseEntity *pEnt = cl_entitylist->GetEnt( GetTargetIndex() );
if ( pEnt && pEnt->IsBaseObject() )
return true;
if ( tf_hud_target_id_disable_floating_health.GetBool() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Find out which player to pull an avatar image from. pTFPlayer is the player under the crosshair.
//-----------------------------------------------------------------------------
C_TFPlayer *CTargetID::GetTargetForSteamAvatar( C_TFPlayer *pTFPlayer )
{
if ( !tf_hud_target_id_show_avatars.GetBool() )
return NULL;
if ( !pTFPlayer || ( g_TF_PR && g_TF_PR->IsFakePlayer( pTFPlayer->entindex() ) ) )
return NULL;
C_TFPlayer *pTFLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pTFLocalPlayer )
return NULL;
// Health icon inside the panel (too busy - figure this out later)
if ( DrawHealthIcon() )
return NULL;
// Save room when healing or being healed
if ( pTFLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && pTFLocalPlayer->MedicGetHealTarget() == pTFPlayer )
return NULL;
C_TFPlayer *pTFHealer = NULL;
float flHealerChargeLevel = -1.f;
pTFLocalPlayer->GetHealer( &pTFHealer, &flHealerChargeLevel );
if ( pTFHealer && pTFHealer->entindex() == m_iTargetEntIndex )
return NULL;
if ( pTFPlayer->IsPlayerClass( TF_CLASS_SPY ) && pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
{
C_TFPlayer *pDisguiseTarget = ToTFPlayer( pTFPlayer->m_Shared.GetDisguiseTarget() );
if ( pDisguiseTarget && ( pTFLocalPlayer->InSameTeam( pDisguiseTarget ) || pDisguiseTarget == pTFLocalPlayer ) )
{
// Bots don't (currently) have avatars.
if ( pDisguiseTarget->IsBot() )
return NULL;
if ( tf_hud_target_id_show_avatars.GetInt() == 2 && !pTFLocalPlayer->IsPlayerOnSteamFriendsList( pDisguiseTarget ) )
return NULL;
return pDisguiseTarget;
}
}
if ( pTFLocalPlayer->IsPlayerOnSteamFriendsList( pTFPlayer ) )
return pTFPlayer;
if ( tf_hud_target_id_show_avatars.GetInt() == 1 )
return pTFPlayer;
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::ApplySchemeSettings( vgui::IScheme *scheme )
{
LoadControlSettings( "resource/UI/TargetID.res" );
BaseClass::ApplySchemeSettings( scheme );
m_pTargetNameLabel = dynamic_cast<Label *>(FindChildByName("TargetNameLabel"));
m_pTargetDataLabel = dynamic_cast<Label *>(FindChildByName("TargetDataLabel"));
m_pBGPanel = dynamic_cast<CTFImagePanel *> ( FindChildByName("TargetIDBG") );
m_pMoveableSubPanel = dynamic_cast<vgui::EditablePanel *> ( FindChildByName("MoveableSubPanel") );
if ( m_pMoveableSubPanel )
{
m_pMoveableIcon = dynamic_cast<CIconPanel *> ( m_pMoveableSubPanel->FindChildByName("MoveableIcon") );
m_pMoveableSymbolIcon = dynamic_cast<vgui::ImagePanel *> ( m_pMoveableSubPanel->FindChildByName("MoveableSymbolIcon") );
m_pMoveableIconBG = dynamic_cast<CIconPanel *> ( m_pMoveableSubPanel->FindChildByName("MoveableIconBG") );
m_pMoveableKeyLabel = dynamic_cast<Label *>( m_pMoveableSubPanel->FindChildByName("MoveableKeyLabel") );
}
m_hFont = scheme->GetFont( "TargetID", true );
m_pTargetAmmoIcon = dynamic_cast<vgui::ImagePanel *>( FindChildByName( "AmmoIcon" ) );
m_pTargetKillStreakIcon = dynamic_cast<vgui::ImagePanel *>( FindChildByName( "KillStreakIcon" ) );
m_pAvatarImage = dynamic_cast< CAvatarImagePanel* >( FindChildByName( "AvatarImage" ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
m_iRenderPriority = inResourceData->GetInt( "priority" );
int x;
GetPos( x, m_nOriginalY );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTargetID::GetRenderGroupPriority( void )
{
return m_iRenderPriority;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::UpdateFloatingHealthIconVisibility( bool bVisible )
{
if ( m_pFloatingHealthIcon && ( m_pFloatingHealthIcon->IsVisible() != bVisible ) )
{
m_pFloatingHealthIcon->SetVisible( bVisible );
}
}
//-----------------------------------------------------------------------------
// Purpose: clear out string etc between levels
//-----------------------------------------------------------------------------
void CTargetID::VidInit()
{
CHudElement::VidInit();
m_flLastChangeTime = 0;
m_iLastEntIndex = 0;
}
bool CTargetID::IsValidIDTarget( int nEntIndex, float flOldTargetRetainFOV, float &flNewTargetRetainFOV )
{
bool bReturn = false;
flNewTargetRetainFOV = 0.0f;
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return false;
#ifdef STAGING_ONLY
if ( pLocalTFPlayer->m_Shared.InCond( TF_COND_STEALTHED_PHASE ) )
return false;
#endif // STAGING_ONLY
if ( nEntIndex )
{
C_BaseEntity *pEnt = cl_entitylist->GetEnt( nEntIndex );
if ( pEnt )
{
Vector vDiff = pEnt->EyePosition() - pLocalTFPlayer->EyePosition();
float flDist;
flDist = VectorNormalize( vDiff );
if ( flOldTargetRetainFOV != 0.0f )
{
// It has a FOV that maintains previous targets
Vector vForward;
pLocalTFPlayer->EyeVectors( &vForward );
float fAngle = 1.0f - vDiff.Dot( vForward );
fAngle = RemapVal( fAngle, 0.0f, 1.0f, 0.0f, 90.0f );
if ( fAngle > flOldTargetRetainFOV )
{
return false;
}
}
C_TFPlayer *pPlayer = ToTFPlayer( pEnt );
int iHideEnemyHealth = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLocalTFPlayer, iHideEnemyHealth, hide_enemy_health );
bool bInSameTeam = pLocalTFPlayer->InSameDisguisedTeam( pEnt );
bool bSpy = pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) && iHideEnemyHealth == 0;
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
// We don't want to show health bars to the spy in MVM because it's distracting
bSpy = false;
// Are we disguised as the enemy?
if ( pLocalTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pLocalTFPlayer->m_Shared.GetDisguiseTeam() != pLocalTFPlayer->GetTeamNumber() )
{
// Get the target's apparent team
int iTheirApparentTeam = pEnt->GetTeamNumber();
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
{
iTheirApparentTeam = pPlayer->m_Shared.GetDisguiseTeam();
}
// Are we disguised as they appear?
if ( pLocalTFPlayer->m_Shared.GetDisguiseTeam() == iTheirApparentTeam )
{
// Don't show the health
bInSameTeam = false;
}
}
}
bool bSpectator = pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR;
int iSeeEnemyHealth = 0;
bool bStealthed = false;
bool bHealthBarVisible = ShouldHealthBarBeVisible( pEnt, pLocalTFPlayer );
bool bShow = bHealthBarVisible;
if ( pPlayer )
{
if ( pPlayer->m_Shared.IsStealthed() )
{
bStealthed = true;
bHealthBarVisible = false;
bShow = false;
}
if ( !bStealthed )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLocalTFPlayer, iSeeEnemyHealth, see_enemy_health );
}
bool bMaintainInFOV = !pLocalTFPlayer->InSameTeam( pEnt );
if ( bHealthBarVisible )
{
bool bEnemyPlayer = pPlayer->GetTeamNumber() != pLocalTFPlayer->GetTeamNumber();
bool bEnemyMiniBoss = pPlayer->IsMiniBoss() && bEnemyPlayer;
bShow = bEnemyMiniBoss;
#ifdef STAGING_ONLY
bShow |= TFGameRules() && TFGameRules()->IsBountyMode() && tf_bountymode_showhealth.GetInt() && bEnemyPlayer;
#endif // STAGING_ONLY
if ( bShow )
{
bMaintainInFOV = false;
// Minibosses keep the health indicator up within a small FOV until a different valid target is selected
// The FOV needs to grow exponentially when a target is getting near
if ( bEnemyMiniBoss )
{
bMaintainInFOV = true;
}
}
}
if ( bMaintainInFOV )
{
const float flMaxDist = 800.0f;
float fInterp = RemapVal( flMaxDist - MIN( flDist, flMaxDist ), 0.0f, flMaxDist, 0.0f, 1.0f );
fInterp *= fInterp;
flNewTargetRetainFOV = fInterp * 13.0f + 0.75f;
}
bReturn = ( bSpectator || pLocalTFPlayer->InSameTeam( pEnt ) || ( ( bInSameTeam || bSpy || iSeeEnemyHealth ) && !bStealthed ) );
}
if ( bShow || bHealthBarVisible )
{
// See if we're re-targeting our previous
if ( m_pFloatingHealthIcon )
{
if ( m_pFloatingHealthIcon->GetEntity() && m_pFloatingHealthIcon->GetEntity() == pEnt )
{
UpdateFloatingHealthIconVisibility( true );
}
else
{
// New target - clear previous
m_pFloatingHealthIcon->MarkForDeletion();
m_pFloatingHealthIcon = NULL;
}
}
//Recreate the floating health icon if there isn't one, we're not a spectator, and
// we're not a spy or this was a robot from Robot Destruction-Mode
if ( !m_pFloatingHealthIcon && !bSpectator && ( !bSpy || bHealthBarVisible ) && !DrawHealthIcon() )
{
m_pFloatingHealthIcon = CFloatingHealthIcon::AddFloatingHealthIcon( pEnt );
}
}
else if ( pEnt->IsBaseObject() && ( bInSameTeam || bSpy ) )
{
bReturn = true;
}
else if ( pEnt->IsVisibleToTargetID() )
{
bReturn = true;
}
else
{
UpdateFloatingHealthIconVisibility( false );
}
}
}
return bReturn;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTargetID::ShouldDraw( void )
{
if ( !CHudElement::ShouldDraw() )
{
UpdateFloatingHealthIconVisibility( false );
return false;
}
if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
{
UpdateFloatingHealthIconVisibility( false );
return false;
}
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
{
UpdateFloatingHealthIconVisibility( false );
return false;
}
if ( pLocalTFPlayer->IsTaunting() )
{
UpdateFloatingHealthIconVisibility( false );
return false;
}
// Get our target's ent index
m_iTargetEntIndex = CalculateTargetIndex(pLocalTFPlayer);
if ( !m_iTargetEntIndex )
{
if ( m_flTargetRetainFOV == 0.0f )
{
// Check to see if we should clear our ID
if ( m_flLastChangeTime && ( gpGlobals->curtime > m_flLastChangeTime ) )
{
m_flLastChangeTime = 0;
m_iLastEntIndex = 0;
}
else
{
// Keep re-using the old one
m_iTargetEntIndex = m_iLastEntIndex;
}
}
// If we're showing a floating health icon, and no longer have a target,
// hide it and see if it's the same entity next time
UpdateFloatingHealthIconVisibility( false );
}
else
{
m_flLastChangeTime = gpGlobals->curtime;
if ( m_iTargetEntIndex != m_iLastScannedEntIndex )
{
// If we switched to another, valid target for a floating health icon, recreate it on the next pass
if ( m_pFloatingHealthIcon )
{
m_pFloatingHealthIcon->MarkForDeletion();
m_pFloatingHealthIcon = NULL;
}
m_iLastScannedEntIndex = m_iTargetEntIndex;
}
}
float flTargetRetainFOV = 0.0f;
bool bReturn = IsValidIDTarget( m_iTargetEntIndex, 0.0f, flTargetRetainFOV );
if ( !bReturn )
{
m_iLastEntIndex = 0;
}
else
{
if ( !IsVisible() || (m_iTargetEntIndex != m_iLastEntIndex) )
{
m_iLastEntIndex = m_iTargetEntIndex;
m_bLayoutOnUpdate = true;
m_flTargetRetainFOV = flTargetRetainFOV;
if ( m_pAvatarImage )
{
m_pAvatarImage->SetVisible( false );
}
}
UpdateID();
}
return bReturn;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::PerformLayout( void )
{
int iXIndent = XRES(5);
int iXPostdent = XRES(10);
int iWidth = iXIndent + iXPostdent;
if ( DrawHealthIcon() )
{
iWidth += m_pTargetHealth->GetWide();
}
if ( m_pAvatarImage && m_pAvatarImage->IsVisible() )
{
iWidth += m_pAvatarImage->GetWide() + XRES( 2 );
}
int iTextW, iTextH;
int iDataW, iDataH;
if ( m_pTargetNameLabel && m_pTargetDataLabel )
{
m_pTargetNameLabel->GetContentSize( iTextW, iTextH );
m_pTargetDataLabel->GetContentSize( iDataW, iDataH );
iWidth += MAX(iTextW,iDataW);
if ( m_pBGPanel )
{
m_pBGPanel->SetSize( iWidth, GetTall() );
}
int x1 = 0, y1 = 0;
int x2 = 0, y2 = 0;
int x3 = 0, y3 = 0;
m_pTargetNameLabel->GetPos( x1, y1 );
m_pTargetDataLabel->GetPos( x2, y2 );
if ( m_pTargetKillStreakIcon )
{
m_pTargetKillStreakIcon->GetPos( x3, y3 );
}
int iWideExtra = 0;
if ( DrawHealthIcon() )
{
iWideExtra += m_pTargetHealth->GetWide();
}
if ( m_pAvatarImage && m_pAvatarImage->IsVisible() )
{
iWideExtra += m_pAvatarImage->GetWide() + XRES( 4 );
}
int nBuffer = ( m_pAvatarImage && m_pAvatarImage->IsVisible() ) ? 6 : 8;
m_pTargetNameLabel->SetPos( XRES( nBuffer ) + iWideExtra, y1 );
m_pTargetDataLabel->SetPos( XRES( nBuffer ) + iWideExtra, y2 );
if ( m_pTargetKillStreakIcon )
{
int nKSBuffer = ( cl_hud_minmode.GetBool() ) ? 6 : 9;
m_pTargetKillStreakIcon->SetPos( XRES( nKSBuffer ) + iWideExtra, y3 );
}
}
// Put the moveable icon to the right hand of our panel
if ( m_pMoveableSubPanel && m_pMoveableSubPanel->IsVisible() )
{
if ( m_pMoveableKeyLabel && m_pMoveableIcon && m_pMoveableSymbolIcon && m_pMoveableIconBG )
{
m_pMoveableKeyLabel->SizeToContents();
int iIndent = XRES(4);
int iMoveWide = MAX( XRES(16) + m_pMoveableKeyLabel->GetWide() + iIndent, (m_pMoveableIcon->GetWide()) + iIndent + XRES(8) );
m_pMoveableKeyLabel->SetWide( iMoveWide );
m_pMoveableSubPanel->SetSize( iMoveWide, GetTall() );
m_pMoveableSubPanel->SetPos( iWidth - iIndent, 0 );
int x,y;
m_pMoveableKeyLabel->GetPos( x, y );
m_pMoveableSymbolIcon->SetPos( (iMoveWide - m_pMoveableSymbolIcon->GetWide()) * 0.5, y - m_pMoveableSymbolIcon->GetTall() );
m_pMoveableSymbolIcon->GetPos( x, y );
m_pMoveableIcon->SetPos( (iMoveWide - m_pMoveableIcon->GetWide()) * 0.5, y - m_pMoveableIcon->GetTall() );
m_pMoveableIconBG->SetSize( m_pMoveableSubPanel->GetWide(), m_pMoveableSubPanel->GetTall() );
}
}
if ( m_pMoveableSubPanel && m_pMoveableSubPanel->IsVisible() )
{
// Now add our extra width to the total size
iWidth += m_pMoveableSubPanel->GetWide();
}
SetSize( iWidth, GetTall() );
int nOffset = m_bArenaPanelVisible ? YRES (120) : 0; // HACK: move the targetID up a bit so it won't overlap the panel
if( UseVR() )
{
SetPos( ScreenWidth() - iWidth - m_iXOffset, m_nOriginalY - nOffset + YRES( tf_hud_target_id_offset.GetInt() ) );
}
else
{
SetPos( (ScreenWidth() - iWidth) * 0.5, m_nOriginalY - nOffset + YRES( tf_hud_target_id_offset.GetInt() ) );
}
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTargetID::CalculateTargetIndex( C_TFPlayer *pLocalTFPlayer )
{
int iIndex = pLocalTFPlayer->GetIDTarget();
// If our target entity is already in our secondary ID, don't show it in primary.
CSecondaryTargetID *pSecondaryID = GET_HUDELEMENT( CSecondaryTargetID );
if ( pSecondaryID && pSecondaryID != this && pSecondaryID->GetTargetIndex() == iIndex )
{
iIndex = 0;
}
return iIndex;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTargetID::UpdateID( void )
{
wchar_t sIDString[ MAX_ID_STRING ] = L"";
wchar_t sDataString[ MAX_ID_STRING ] = L"";
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return;
// Default the labels' colors
Color colorName = m_LabelColorDefault;
Color colorData = m_LabelColorDefault;
// Get our target's ent index
// Is this an entindex sent by the server?
if ( m_iTargetEntIndex )
{
C_BaseEntity *pEnt = cl_entitylist->GetEnt( m_iTargetEntIndex );
if ( !pEnt )
return;
bool bShowHealth = false;
float flHealth = 0;
float flMaxHealth = 1;
int iMaxBuffedHealth = 0;
int iTargetTeam = pEnt->GetTeamNumber();
const char *pszActionCommand = NULL;
const char *pszActionIcon = NULL;
m_pTargetHealth->SetBuilding( false );
m_pTargetHealth->SetLevel( -1 );
// Some entities we always want to check, cause the text may change
// even while we're looking at it
// Is it a player?
if ( IsPlayerIndex( m_iTargetEntIndex ) )
{
const char *printFormatString = NULL;
wchar_t wszPlayerName[ MAX_PLAYER_NAME_LENGTH ];
bool bDisguisedTarget = false;
bool bDisguisedEnemy = false;
C_TFPlayer *pPlayer = static_cast<C_TFPlayer*>( pEnt );
if ( !pPlayer )
return;
C_TFPlayer *pDisguiseTarget = NULL;
g_pVGuiLocalize->ConvertANSIToUnicode( pPlayer->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
// determine if the target is a disguised spy (either friendly or enemy)
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && // they're disguised
//!pPlayer->m_Shared.InCond( TF_COND_DISGUISING ) && // they're not in the process of disguising
!pPlayer->m_Shared.IsStealthed() ) // they're not cloaked
{
bDisguisedTarget = true;
pDisguiseTarget = ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() );
if ( pLocalTFPlayer->InSameTeam( pEnt ) == false )
{
iTargetTeam = pPlayer->m_Shared.GetDisguiseTeam();
}
}
if ( bDisguisedTarget )
{
// is the target a disguised enemy spy?
if ( pPlayer->IsEnemyPlayer() )
{
if ( pDisguiseTarget )
{
bDisguisedEnemy = true;
// change the player name
g_pVGuiLocalize->ConvertANSIToUnicode( pDisguiseTarget->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
// change the team / team color
}
}
}
bool bInSameTeam = pLocalTFPlayer->InSameDisguisedTeam( pEnt );
bool bSpy = pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY );
bool bMedic = pLocalTFPlayer->IsPlayerClass( TF_CLASS_MEDIC );
bool bHeavy = pLocalTFPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS );
// See if the player wants to fill in the data string
bool bIsAmmoData = false;
bool bIsKillStreakData = false;
pPlayer->GetTargetIDDataString( bDisguisedTarget, sDataString, sizeof(sDataString), bIsAmmoData, bIsKillStreakData );
if ( pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR || bInSameTeam || bSpy || bDisguisedEnemy || bMedic || bHeavy )
{
printFormatString = "#TF_playerid_sameteam";
bShowHealth = true;
}
else if ( pLocalTFPlayer->m_Shared.GetState() == TF_STATE_DYING )
{
// We're looking at an enemy who killed us.
printFormatString = "#TF_playerid_diffteam";
bShowHealth = true;
}
if ( bShowHealth )
{
if ( g_TF_PR )
{
if ( bDisguisedEnemy )
{
flHealth = (float)pPlayer->m_Shared.GetDisguiseHealth();
flMaxHealth = (float)pPlayer->m_Shared.GetDisguiseMaxHealth();
iMaxBuffedHealth = pPlayer->m_Shared.GetDisguiseMaxBuffedHealth();
}
else
{
flHealth = (float)pPlayer->GetHealth();
flMaxHealth = g_TF_PR->GetMaxHealth( m_iTargetEntIndex );
iMaxBuffedHealth = pPlayer->m_Shared.GetMaxBuffedHealth();
}
}
else
{
bShowHealth = false;
}
}
if ( printFormatString )
{
const wchar_t *pszPrepend = GetPrepend();
if ( !pszPrepend || !pszPrepend[0] )
{
pszPrepend = L"";
}
g_pVGuiLocalize->ConstructString_safe( sIDString, g_pVGuiLocalize->Find(printFormatString), 2, pszPrepend, wszPlayerName );
}
// Show target's clip state to attached medics
bool bShowClipInfo = bIsAmmoData &&
sDataString[0] &&
ToTFPlayer( pLocalTFPlayer->MedicGetHealTarget() ) == pPlayer;
if ( m_pTargetAmmoIcon && m_pTargetAmmoIcon->IsVisible() != bShowClipInfo )
{
m_pTargetAmmoIcon->SetVisible( bShowClipInfo );
}
bool bShowKillStreak = bIsKillStreakData && sDataString[0];
if ( m_pTargetKillStreakIcon && m_pTargetKillStreakIcon->IsVisible() != bShowKillStreak )
{
m_pTargetKillStreakIcon->SetVisible( bShowKillStreak );
}
}
else
{
// see if it is an object
if ( pEnt->IsBaseObject() )
{
C_BaseObject *pObj = assert_cast<C_BaseObject *>( pEnt );
pObj->GetTargetIDString( sIDString, sizeof(sIDString), false );
pObj->GetTargetIDDataString( sDataString, sizeof(sDataString) );
bShowHealth = true;
flHealth = pObj->GetHealth();
flMaxHealth = pObj->GetMaxHealth();
m_pTargetHealth->SetBuilding( true );
if ( m_pTargetKillStreakIcon )
{
m_pTargetKillStreakIcon->SetVisible( false );
}
// Switch the icon to the right object
if ( pObj->GetBuilder() == pLocalTFPlayer )
{
int iObj = pObj->GetType();
if ( iObj >= OBJ_DISPENSER && iObj <= OBJ_SENTRYGUN )
{
if ( pLocalTFPlayer->CanPickupBuilding(pObj) )
{
pszActionCommand = "+attack2";
}
switch ( iObj )
{
default:
case OBJ_DISPENSER:
pszActionIcon = "obj_status_dispenser";
break;
case OBJ_TELEPORTER:
{
pszActionIcon = (pObj->GetObjectMode() == MODE_TELEPORTER_ENTRANCE) ? "obj_status_tele_entrance" : "obj_status_tele_exit";
}
break;
case OBJ_SENTRYGUN:
{
int iLevel = pObj->GetUpgradeLevel();
if ( iLevel == 3 )
{
pszActionIcon = "obj_status_sentrygun_3";
}
else
{
pszActionIcon = (iLevel == 2) ? "obj_status_sentrygun_2" : "obj_status_sentrygun_1";
}
}
break;
}
}
}
}
// Generic
else if ( pEnt->IsVisibleToTargetID() )
{
CCaptureFlag *pFlag = dynamic_cast< CCaptureFlag * >( pEnt );
if ( pFlag && pFlag->GetPointValue() > 0 )
{
bShowHealth = false;
g_pVGuiLocalize->ConvertANSIToUnicode( CFmtStr("%d Points", pFlag->GetPointValue() ), sIDString, sizeof(sIDString) );
}
else
{
CTFDroppedWeapon *pDroppedWeapon = dynamic_cast< CTFDroppedWeapon * >( pEnt );
if ( pDroppedWeapon )
{
CEconItemView* pDroppedEconItem = pDroppedWeapon->GetItem();
if ( pLocalTFPlayer->GetDroppedWeaponInRange() != NULL )
{
pszActionIcon = "obj_weapon_pickup";
pszActionCommand = "+use_action_slot_item";
}
if ( FStrEq( pDroppedEconItem->GetStaticData()->GetItemClass(), "tf_weapon_medigun" ) )
{
wchar_t wszChargeLevel[10];
_snwprintf( wszChargeLevel, ARRAYSIZE( wszChargeLevel ) - 1, L"%.0f", pDroppedWeapon->GetChargeLevel() * 100 );
wszChargeLevel[ARRAYSIZE( wszChargeLevel ) - 1] = '\0';
g_pVGuiLocalize->ConstructString_safe( sIDString, L"%s1 (%s2%)", 2, CEconItemLocalizedFullNameGenerator( GLocalizationProvider(), pDroppedEconItem->GetItemDefinition(), pDroppedEconItem->GetItemQuality() ).GetFullName(), wszChargeLevel );
}
else
{
g_pVGuiLocalize->ConstructString_safe( sIDString, L"%s1", 1, CEconItemLocalizedFullNameGenerator( GLocalizationProvider(), pDroppedEconItem->GetItemDefinition(), pDroppedEconItem->GetItemQuality() ).GetFullName() );
}
locchar_t wszPlayerName [128];
CBasePlayer *pOwner = GetPlayerByAccountID( pDroppedEconItem->GetAccountID() );
// Bots will not work here, so don't fill this out.
if ( pOwner )
{
g_pVGuiLocalize->ConvertANSIToUnicode( pOwner->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
g_pVGuiLocalize->ConstructString_safe( sDataString, g_pVGuiLocalize->Find( "#TF_WhoDropped" ), 1, wszPlayerName );
// Get the rarity color
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
if ( pScheme )
{
const char* pszColorName = GetItemSchema()->GetRarityColor( pDroppedEconItem->GetItemDefinition()->GetRarity() );
pszColorName = pszColorName ? pszColorName : "TanLight";
colorName = pScheme->GetColor( pszColorName, Color( 255, 255, 255, 255 ) );
}
}
}
else if ( pLocalTFPlayer->InSameTeam( pEnt ) )
{
bShowHealth = true;
flHealth = pEnt->GetHealth();
flMaxHealth = pEnt->GetMaxHealth();
iMaxBuffedHealth = pEnt->GetMaxHealth();
// Display respawn timer on revive markers by hacking bountymode's player level display
if ( !pEnt->IsPlayer() )
{
CTFReviveMarker *pMarker = dynamic_cast< CTFReviveMarker* >( pEnt );
if ( pMarker && pMarker->GetOwner() )
{
float flRespawn = TFGameRules()->GetNextRespawnWave( pMarker->GetTeamNumber(), pMarker->GetOwner() ) - gpGlobals->curtime;
m_pTargetHealth->SetLevel( (int)flRespawn );
g_pVGuiLocalize->ConvertANSIToUnicode( pMarker->GetOwner()->GetPlayerName(), sIDString, sizeof(sIDString) );
}
}
}
}
}
}
// Setup health icon
if ( !pEnt->IsAlive() && ( pEnt->IsPlayer() || pEnt->IsBaseObject() ) )
{
flHealth = 0; // fixup for health being 1 when dead
}
m_pTargetHealth->SetHealth( flHealth, flMaxHealth, iMaxBuffedHealth );
m_pTargetHealth->SetVisible( DrawHealthIcon() );
if ( m_pMoveableSubPanel )
{
bool bShowActionKey = pszActionCommand != NULL;
if ( m_pMoveableSubPanel->IsVisible() != bShowActionKey )
{
m_pMoveableSubPanel->SetVisible( bShowActionKey );
m_bLayoutOnUpdate = true;
}
if ( m_pMoveableSubPanel->IsVisible() )
{
const char *pBoundKey = engine->Key_LookupBinding( pszActionCommand );
m_pMoveableSubPanel->SetDialogVariable( "movekey", pBoundKey );
}
if ( m_pMoveableIcon )
{
if ( pszActionIcon )
{
m_pMoveableIcon->SetIcon( pszActionIcon );
}
m_pMoveableIcon->SetVisible( pszActionIcon != NULL );
}
}
if ( m_pAvatarImage && pEnt->IsPlayer() )
{
C_BasePlayer *pTFTarget = GetTargetForSteamAvatar( ToTFPlayer( pEnt ) );
bool bShowAvatar = ( pTFTarget ) ? true : false;
if ( m_pAvatarImage->IsVisible() != bShowAvatar )
{
m_pAvatarImage->SetVisible( bShowAvatar );
if ( bShowAvatar )
{
m_pAvatarImage->SetPlayer( pTFTarget );
m_pAvatarImage->SetShouldDrawFriendIcon( false );
m_pAvatarImage->SetAlpha( tf_hud_target_id_alpha.GetInt() );
}
}
}
if ( m_pTargetNameLabel && m_pTargetDataLabel )
{
int iNameW, iDataW, iIgnored;
m_pTargetNameLabel->GetContentSize( iNameW, iIgnored );
m_pTargetDataLabel->GetContentSize( iDataW, iIgnored );
// Target name
if ( sIDString[0] )
{
sIDString[ ARRAYSIZE(sIDString)-1 ] = '\0';
m_pTargetNameLabel->SetVisible(true);
m_pTargetNameLabel->SetFgColor( colorName );
// TODO: Support if( hud_centerid.GetInt() == 0 )
SetDialogVariable( "targetname", sIDString );
}
else
{
m_pTargetNameLabel->SetVisible(false);
m_pTargetNameLabel->SetText("");
}
// Extra target data
if ( sDataString[0] )
{
sDataString[ ARRAYSIZE(sDataString)-1 ] = '\0';
m_pTargetDataLabel->SetVisible(true);
m_pTargetDataLabel->SetFgColor( colorData );
SetDialogVariable( "targetdata", sDataString );
}
else
{
m_pTargetDataLabel->SetVisible(false);
m_pTargetDataLabel->SetText("");
}
int iPostNameW, iPostDataW;
m_pTargetNameLabel->GetContentSize( iPostNameW, iIgnored );
m_pTargetDataLabel->GetContentSize( iPostDataW, iIgnored );
if ( m_pBGPanel )
{
m_pBGPanel->SetBGTeam( iTargetTeam );
m_pBGPanel->UpdateBGImage();
m_pBGPanel->SetAlpha( tf_hud_target_id_alpha.GetInt() );
}
if ( m_bLayoutOnUpdate || (iPostDataW != iDataW) || (iPostNameW != iNameW) )
{
InvalidateLayout( true );
m_bLayoutOnUpdate = false;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CSecondaryTargetID::CSecondaryTargetID( const char *pElementName ) : CTargetID( pElementName )
{
m_wszPrepend[0] = '\0';
RegisterForRenderGroup( "mid" );
m_bWasHidingLowerElements = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CSecondaryTargetID::ShouldDraw( void )
{
bool bDraw = BaseClass::ShouldDraw();
if ( bDraw )
{
if ( !m_bWasHidingLowerElements )
{
HideLowerPriorityHudElementsInGroup( "mid" );
m_bWasHidingLowerElements = true;
}
}
else
{
if ( m_bWasHidingLowerElements )
{
UnhideLowerPriorityHudElementsInGroup( "mid" );
m_bWasHidingLowerElements = false;
}
}
return bDraw;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CSecondaryTargetID::CalculateTargetIndex( C_TFPlayer *pLocalTFPlayer )
{
// If we're a medic & we're healing someone, target him.
CBaseEntity *pHealTarget = pLocalTFPlayer->MedicGetHealTarget();
if ( pHealTarget )
{
if ( pHealTarget->entindex() != m_iTargetEntIndex )
{
g_pVGuiLocalize->ConstructString_safe( m_wszPrepend, g_pVGuiLocalize->Find("#TF_playerid_healtarget" ), 0 );
}
return pHealTarget->entindex();
}
// If we have a healer, target him.
C_TFPlayer *pHealer;
float flHealerChargeLevel;
pLocalTFPlayer->GetHealer( &pHealer, &flHealerChargeLevel );
if ( pHealer )
{
if ( pHealer->entindex() != m_iTargetEntIndex )
{
g_pVGuiLocalize->ConstructString_safe( m_wszPrepend, g_pVGuiLocalize->Find("#TF_playerid_healer" ), 0 );
}
return pHealer->entindex();
}
if ( m_iTargetEntIndex )
{
m_wszPrepend[0] = '\0';
}
return 0;
}
// Separately declared versions of the hud element for alive and dead so they
// can have different positions
bool CMainTargetID::ShouldDraw( void )
{
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return false;
if ( pLocalTFPlayer->GetObserverMode() > OBS_MODE_NONE )
return false;
return BaseClass::ShouldDraw();
}
bool CSpectatorTargetID::ShouldDraw( void )
{
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return false;
if ( pLocalTFPlayer->GetObserverMode() <= OBS_MODE_NONE ||
pLocalTFPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
return false;
if ( pLocalTFPlayer->m_bIsCoaching )
{
return false;
}
// Hide panel for freeze-cam screenshot?
extern bool IsTakingAFreezecamScreenshot();
extern ConVar hud_freezecamhide;
if ( IsTakingAFreezecamScreenshot() && hud_freezecamhide.GetBool() )
return false;
#if defined( REPLAY_ENABLED )
if ( g_pEngineClientReplay->IsPlayingReplayDemo() )
return false;
#endif
return BaseClass::ShouldDraw();
}
int CSpectatorTargetID::CalculateTargetIndex( C_TFPlayer *pLocalTFPlayer )
{
int iIndex = BaseClass::CalculateTargetIndex( pLocalTFPlayer );
#if defined( REPLAY_ENABLED )
// Don't execute this if we're watching a replay
if ( ( !g_pEngineClientReplay || !g_pEngineClientReplay->IsPlayingReplayDemo() ) && pLocalTFPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pLocalTFPlayer->GetObserverTarget() )
#else
if ( pLocalTFPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pLocalTFPlayer->GetObserverTarget() )
#endif
{
iIndex = pLocalTFPlayer->GetObserverTarget()->entindex();
}
return iIndex;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSpectatorTargetID::ApplySchemeSettings( vgui::IScheme *scheme )
{
BaseClass::ApplySchemeSettings( scheme );
if ( m_pBGPanel )
{
m_pBGPanel->SetVisible( false );
}
m_pBGPanel_Spec_Blue = FindChildByName("TargetIDBG_Spec_Blue");
m_pBGPanel_Spec_Red = FindChildByName("TargetIDBG_Spec_Red");
if ( m_pBGPanel_Spec_Blue )
{
m_pBGPanel_Spec_Blue->SetVisible( true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSpectatorTargetID::PerformLayout( void )
{
int iXIndent = XRES(5);
int iXPostdent = XRES(10);
int iWidth = m_pTargetHealth->GetWide() + iXIndent + iXPostdent;
int iTextW, iTextH;
int iDataW, iDataH;
if ( m_pTargetNameLabel && m_pTargetDataLabel )
{
m_pTargetNameLabel->GetContentSize( iTextW, iTextH );
m_pTargetDataLabel->GetContentSize( iDataW, iDataH );
iWidth += MAX(iTextW,iDataW);
SetSize( iWidth, GetTall() );
int nOffset = m_bArenaPanelVisible ? YRES (120) : 0; // HACK: move the targetID up a bit so it won't overlap the panel
int x1 = 0, y1 = 0;
int x2 = 0, y2 = 0;
int x3 = 0, y3 = 0;
m_pTargetNameLabel->GetPos( x1, y1 );
m_pTargetDataLabel->GetPos( x2, y2 );
if ( m_pTargetKillStreakIcon )
{
m_pTargetKillStreakIcon->GetPos( x3, y3 );
}
// Shift Labels
{
int nBuffer = ( m_pAvatarImage && m_pAvatarImage->IsVisible() ) ? 6 : 8;
m_pTargetNameLabel->SetPos( XRES( nBuffer ) + m_pTargetHealth->GetWide(), y1 );
m_pTargetDataLabel->SetPos( XRES( nBuffer ) + m_pTargetHealth->GetWide(), y2 );
if ( m_pTargetKillStreakIcon )
{
m_pTargetKillStreakIcon->SetPos( XRES( 10 ) + m_pTargetHealth->GetWide(), y3 );
}
}
if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_NORMAL )
{
SetPos( (ScreenWidth() - iWidth) * 0.5, m_nOriginalY - nOffset );
}
else
{
int iBottomBarHeight = 0;
if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
{
iBottomBarHeight = g_pSpectatorGUI->GetBottomBarHeight();
}
int iYPos = ScreenHeight() - GetTall() - iBottomBarHeight - m_iYOffset;
if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_BOTTOM_LEFT )
{
SetPos( m_iXOffset, iYPos );
}
else if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_BOTTOM_CENTER )
{
SetPos( (ScreenWidth() - iWidth) * 0.5, iYPos );
}
else if ( tf_spectator_target_location.GetInt() == SPECTATOR_TARGET_ID_BOTTOM_RIGHT )
{
SetPos( ScreenWidth() - iWidth - m_iXOffset, iYPos );
}
}
if ( m_pBGPanel_Spec_Blue )
{
m_pBGPanel_Spec_Blue->SetSize( iWidth, GetTall() );
}
if ( m_pBGPanel_Spec_Red )
{
m_pBGPanel_Spec_Red->SetSize( iWidth, GetTall() );
}
if ( m_pBGPanel_Spec_Blue && m_pBGPanel_Spec_Red )
{
if ( m_iTargetEntIndex )
{
C_BaseEntity *pEnt = cl_entitylist->GetEnt( m_iTargetEntIndex );
if ( pEnt )
{
bool bRed = ( pEnt->GetTeamNumber() == TF_TEAM_RED );
m_pBGPanel_Spec_Blue->SetVisible( !bRed );
m_pBGPanel_Spec_Red->SetVisible( bRed );
m_pBGPanel_Spec_Blue->SetAlpha( tf_hud_target_id_alpha.GetInt() );
m_pBGPanel_Spec_Red->SetAlpha( tf_hud_target_id_alpha.GetInt() );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CFloatingHealthIcon::CFloatingHealthIcon( vgui::Panel *parent, const char *name ) : EditablePanel( parent, name )
{
m_flPrevHealth = -1.f;
m_nPrevLevel = 0;
SetVisible( false );
SetBounds( 0, 0, 128, 128 );
vgui::ivgui()->AddTickSignal( GetVPanel(), 50 );
OnTick();
m_pTargetHealth = new CTFSpectatorGUIHealth( this, "SpectatorGUIHealth" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::Reset( void )
{
m_pTargetHealth->Reset();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::SetEntity( C_BaseEntity *pEntity )
{
m_hEntity = pEntity;
if ( !m_pTargetHealth )
return;
m_pTargetHealth->SetAllowAnimations( false );
m_pTargetHealth->HideHealthBonusImage();
bool bBuilding = false;
if ( m_hEntity->IsPlayer() )
{
C_TFPlayer *pPlayer = ToTFPlayer( m_hEntity );
bBuilding = ( pPlayer && pPlayer->IsMiniBoss() ) ? true : false;
}
m_pTargetHealth->SetBuilding( bBuilding );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CFloatingHealthIcon* CFloatingHealthIcon::AddFloatingHealthIcon( C_BaseEntity *pEntity )
{
CFloatingHealthIcon *pHealthIcon = new CFloatingHealthIcon( g_pClientMode->GetViewport(), "HealthIcon" );
vgui::SETUP_PANEL( pHealthIcon );
pHealthIcon->SetEntity( pEntity );
return pHealthIcon;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "resource/UI/HealthIconPanel.res" );
SetVisible( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::OnTick( void )
{
if ( !m_pTargetHealth )
return;
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !ShouldHealthBarBeVisible( m_hEntity, pLocalTFPlayer ) )
{
SetVisible( false );
return;
}
C_TFPlayer *pTargetPlayer = ToTFPlayer( m_hEntity );
if ( pTargetPlayer && pTargetPlayer->m_Shared.IsStealthed() )
{
SetVisible( false );
return;
}
// Defaults for all entities
float flHealth = m_hEntity->GetHealth();
float flMaxHealth = m_hEntity->GetMaxHealth();
float iMaxBuffedHealth = m_hEntity->GetMaxHealth();
if ( pTargetPlayer && pTargetPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTargetPlayer->IsEnemyPlayer() )
{
flHealth = (float)pTargetPlayer->m_Shared.GetDisguiseHealth();
flMaxHealth = (float)pTargetPlayer->m_Shared.GetDisguiseMaxHealth();
iMaxBuffedHealth = pTargetPlayer->m_Shared.GetDisguiseMaxBuffedHealth();
}
if ( flHealth != m_flPrevHealth )
{
m_pTargetHealth->SetHealth( flHealth, flMaxHealth, iMaxBuffedHealth );
m_flPrevHealth = flHealth;
}
#ifdef STAGING_ONLY
if ( TFGameRules() && TFGameRules()->IsBountyMode() && tf_bountymode_showhealth.GetInt() == 2 )
{
if ( m_hEntity->IsPlayer() )
{
if ( !pTargetPlayer || pTargetPlayer->IsMiniBoss() )
return;
int nPlayerLevel = pTargetPlayer->GetExperienceLevel();
if ( nPlayerLevel != m_nPrevLevel )
{
m_pTargetHealth->SetLevel( nPlayerLevel );
m_nPrevLevel = nPlayerLevel;
}
}
}
#endif // STAGING_ONLY
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ConVar tf_healthicon_height_offset( "tf_healthicon_height_offset", "10", FCVAR_ARCHIVE, "Offset of the health icon away from the top of the target." );
void CFloatingHealthIcon::Paint( void )
{
if ( !CalculatePosition() )
return;
BaseClass::Paint();
}
//-----------------------------------------------------------------------------
bool CFloatingHealthIcon::CalculatePosition( )
{
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return false;
if ( !m_hEntity || m_hEntity->IsDormant() )
{
return false;
}
Vector vecTarget = m_hEntity->GetAbsOrigin();
// Reposition based on our target's position
Vector vecDistance = vecTarget - pLocalTFPlayer->GetAbsOrigin();
vecTarget.z += VEC_HULL_MAX_SCALED( m_hEntity->GetBaseAnimating() ).z + tf_healthicon_height_offset.GetInt() + m_hEntity->GetHealthBarHeightOffset();
int iX, iY;
GetVectorInHudSpace( vecTarget, iX, iY ); // TODO: GetVectorInHudSpace or GetVectorInScreenSpace?
SetPos( iX - ( GetWide() / 2 ), iY - GetTall() );
return true;
}
//-----------------------------------------------------------------------------
void CFloatingHealthIcon::SetVisible( bool state )
{
if ( state )
{
CalculatePosition();
}
BaseClass::SetVisible( state );
}
//-----------------------------------------------------------------------------
bool CFloatingHealthIcon::IsVisible( void )
{
if ( !m_pTargetHealth )
return false;
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return false;
//if ( pLocalTFPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
if ( pLocalTFPlayer->GetObserverMode() > OBS_MODE_NONE )
return false;
if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
return false;
return BaseClass::IsVisible();
}