//-----------------------------------------------------------------------------
// Purpose: Handle ammo input to the sentrygun
//-----------------------------------------------------------------------------
void CSentrygunControlPanel::AddAmmo( void )
{
C_BaseObject *pObj = GetOwningObject();
if (pObj)
{
pObj->SendClientCommand( "addammo" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle clicking on the Occupy button
//-----------------------------------------------------------------------------
void CVehicleWagonControlPanel::GetInRam( void )
{
C_BaseObject *pObj = GetOwningObject();
if (pObj)
{
pObj->SendClientCommand( "toggle_use" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle clicking on the Connect/Disconnect button
//-----------------------------------------------------------------------------
void CBuffStationControlPanel::ConnectToStation( void )
{
C_BaseObject *pObj = GetOwningObject();
if (pObj)
{
pObj->SendClientCommand( "toggle_connect" );
}
}
void CRotationSlider::OnSliderMoved( int position )
{
C_BaseObject *pObj = m_hObject.Get();
if (pObj && pObj->IsPreviewingYaw())
{
m_flYaw = anglemod(position);
pObj->PreviewYaw( m_flInitialYaw - m_flYaw );
}
}
//-----------------------------------------------------------------------------
// Buys stuff
//-----------------------------------------------------------------------------
void CResupplyControlPanel::Buy( ResupplyBuyType_t type )
{
C_BaseObject *pObj = GetOwningObject();
if (pObj)
{
char szbuf[48];
Q_snprintf( szbuf, sizeof( szbuf ), "buy %d", type );
pObj->SendClientCommand( szbuf );
}
}
//-----------------------------------------------------------------------------
// When the slider is activated, deactivated, or moves
//-----------------------------------------------------------------------------
void CRotationSlider::OnMousePressed( vgui::MouseCode code )
{
BaseClass::OnMousePressed( code );
if (code != vgui::MOUSE_LEFT)
return;
C_BaseObject *pObj = m_hObject.Get();
if (pObj)
{
m_flInitialYaw = pObj->GetAbsAngles().y;
pObj->PreviewYaw( m_flInitialYaw );
pObj->ActivateYawPreview( true );
}
}
void CRotationSlider::OnMouseReleased( vgui::MouseCode code )
{
BaseClass::OnMouseReleased( code );
if (code != vgui::MOUSE_LEFT)
return;
C_BaseObject *pObj = m_hObject.Get();
if (pObj)
{
char szbuf[48];
Q_snprintf( szbuf, sizeof( szbuf ), "yaw %0.2f\n", m_flInitialYaw - m_flYaw );
pObj->SendClientCommand( szbuf );
pObj->ActivateYawPreview( false );
SetValue(0);
m_flYaw = 0;
}
}
//-----------------------------------------------------------------------------
// 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 );
}
else
{
m_pBuildingPanel->SetVisible( false );
m_pRunningPanel->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 );
}
}
}
//-----------------------------------------------------------------------------
// Set the appropriate texture...
//-----------------------------------------------------------------------------
void CObjectBuildAlphaProxy::OnBind( C_BaseEntity *pEntity )
{
if( !m_pAlphaVar )
return;
// It needs to be a TF2 C_BaseObject to have this proxy applied
C_BaseObject *pObject = dynamic_cast< C_BaseObject * >( pEntity );
if ( !pObject )
return;
float build_amount = pObject->m_flCycle; //pObject->GetPercentageConstructed();
float frac;
if ( build_amount <= buildstart )
{
frac = 0.0f;
}
else if ( build_amount >= buildend )
{
frac = 1.0f;
}
else
{
// Avoid div by zero
if ( buildend == buildstart )
{
frac = 1.0f;
}
else
{
frac = ( build_amount - buildstart ) / ( buildend - buildstart );
frac = clamp( frac, 0.0f, 1.0f );
}
}
if ( !pObject->IsBuilding() )
{
frac = 1.0f;
}
m_pAlphaVar->SetFloatValue( frac );
}
void CHudMenuEngyBuild::OnTick( void )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
int iAccount = pLocalPlayer->GetAmmoCount( TF_AMMO_METAL );
for ( int i=0;i<4; i++ )
{
int iRemappedObjectID = GetBuildingIDFromSlot( i + 1 );
// update this slot
C_BaseObject *pObj = NULL;
if ( pLocalPlayer )
{
pObj = pLocalPlayer->GetObjectOfType( iRemappedObjectID );
}
m_pAvailableObjects[i]->SetVisible( false );
m_pAlreadyBuiltObjects[i]->SetVisible( false );
m_pCantAffordObjects[i]->SetVisible( false );
// If the building is already built
if ( pObj != NULL && !pObj->IsPlacing() )
{
m_pAlreadyBuiltObjects[i]->SetVisible( true );
}
// See if we can afford it
else if ( iAccount < GetObjectInfo( iRemappedObjectID )->m_Cost )
{
m_pCantAffordObjects[i]->SetVisible( true );
}
else
{
// we can buy it
m_pAvailableObjects[i]->SetVisible( true );
}
}
}
void HintEventFn_BuildObject( CHintData *pData, C_HintEvent_Base *pEvent )
{
if ( pEvent->GetType() == HINTEVENT_OBJECT_BUILT_BY_LOCAL_PLAYER )
{
C_BaseObject *pObj = ((C_HintEvent_ObjectBuiltByLocalPlayer*)pEvent)->m_pObject;
if ( pObj->GetType() == pData->m_ObjectType )
{
// Ok, they just built the object that any hints of this type are referring to, so disable
// all further hints of this type.
KeyValues *pkvStats = GetHintDisplayStats();
if ( pkvStats )
{
KeyValues *pkvStatSection = pkvStats->FindKey( pData->name, true );
if ( pkvStatSection )
{
pkvStatSection->SetString( "times_shown", VarArgs( "%i", 100 ) );
}
}
}
}
}
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 );
}
}
//-----------------------------------------------------------------------------
// Purpose: Status string for hud
//-----------------------------------------------------------------------------
void C_ObjectSapper::GetStatusText( wchar_t *pStatus, int iMaxStatusLen )
{
float flHealthPercent = (float)GetHealth() / (float)GetMaxHealth();
wchar_t wszHealthPercent[32];
_snwprintf(wszHealthPercent, sizeof(wszHealthPercent)/sizeof(wchar_t) - 1, L"%d%%", (int)( flHealthPercent * 100 ) );
wchar_t *pszTemplate;
if ( IsBuilding() )
{
pszTemplate = g_pVGuiLocalize->Find( "#TF_ObjStatus_Sapper_Building" );
}
else
{
pszTemplate = g_pVGuiLocalize->Find( "#TF_ObjStatus_Sapper" );
}
if ( pszTemplate )
{
wchar_t wszTargetHealthPercent[32];
wszTargetHealthPercent[0] = '\0';
C_BaseObject *pParent = GetParentObject();
Assert( pParent );
if ( pParent )
{
float flTargetHealthPercent = (float)pParent->GetHealth() / (float)pParent->GetMaxHealth();
_snwprintf(wszTargetHealthPercent, sizeof(wszTargetHealthPercent)/sizeof(wchar_t) - 1, L"%d%%", (int)( flTargetHealthPercent * 100 ) );
}
g_pVGuiLocalize->ConstructString( pStatus, iMaxStatusLen, pszTemplate,
2,
wszHealthPercent,
wszTargetHealthPercent);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFreezePanel::FireGameEvent( IGameEvent * event )
{
const char *pEventName = event->GetName();
if ( Q_strcmp( "player_death", pEventName ) == 0 )
{
// see if the local player died
int iPlayerIndexVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && iPlayerIndexVictim == pLocalPlayer->entindex() )
{
// the local player is dead, see if this is a new nemesis or a revenge
if ( event->GetInt( "dominated" ) > 0 )
{
m_iShowNemesisPanel = SHOW_NEW_NEMESIS;
}
else if ( event->GetInt( "revenge" ) > 0 )
{
m_iShowNemesisPanel = SHOW_REVENGE;
}
else
{
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
}
}
}
else if ( Q_strcmp( "hide_freezepanel", pEventName ) == 0 )
{
Hide();
}
else if ( Q_strcmp( "freezecam_started", pEventName ) == 0 )
{
ShowCalloutsIn( 1.0 );
ShowSnapshotPanelIn( 1.25 );
}
else if ( Q_strcmp( "teamplay_win_panel", pEventName ) == 0 )
{
Hide();
}
else if ( Q_strcmp( "show_freezepanel", pEventName ) == 0 )
{
C_TF_PlayerResource *tf_PR = dynamic_cast<C_TF_PlayerResource *>(g_PR);
if ( !tf_PR )
{
m_pNemesisSubPanel->SetDialogVariable( "nemesisname", NULL );
return;
}
Show();
ShowSnapshotPanel( false );
m_bHoldingAfterScreenshot = false;
if ( m_iBasePanelOriginalX > -1 && m_iBasePanelOriginalY > -1 )
{
m_pBasePanel->SetPos( m_iBasePanelOriginalX, m_iBasePanelOriginalY );
}
// Get the entity who killed us
m_iKillerIndex = event->GetInt( "killer" );
C_BaseEntity *pKiller = ClientEntityList().GetBaseEntity( m_iKillerIndex );
int xp,yp;
GetPos( xp, yp );
if ( TFGameRules()->RoundHasBeenWon() )
{
SetPos( xp, m_iYBase - YRES(50) );
}
else
{
SetPos( xp, m_iYBase );
}
if ( pKiller )
{
CTFPlayer *pPlayer = ToTFPlayer ( pKiller );
int iMaxBuffedHealth = 0;
if ( pPlayer )
{
iMaxBuffedHealth = pPlayer->m_Shared.GetMaxBuffedHealth();
}
int iKillerHealth = pKiller->GetHealth();
if ( !pKiller->IsAlive() )
{
iKillerHealth = 0;
}
m_pKillerHealth->SetHealth( iKillerHealth, pKiller->GetMaxHealth(), iMaxBuffedHealth );
if ( pKiller->IsPlayer() )
{
C_TFPlayer *pVictim = C_TFPlayer::GetLocalTFPlayer();
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
//If this was just a regular kill but this guy is our nemesis then just show it.
if ( pVictim && pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Nemesis_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Nemesis" );
}
}
else
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer" );
}
}
m_pBasePanel->SetDialogVariable( "killername", g_PR->GetPlayerName( m_iKillerIndex ) );
if ( m_pAvatar )
{
m_pAvatar->SetPlayer( (C_BasePlayer*)pKiller );
}
}
else if ( pKiller->IsBaseObject() )
{
C_BaseObject *pObj = assert_cast<C_BaseObject *>( pKiller );
C_TFPlayer *pOwner = pObj->GetOwner();
Assert( pOwner && "Why does this object not have an owner?" );
if ( pOwner )
{
m_iKillerIndex = pOwner->entindex();
m_pBasePanel->SetDialogVariable( "killername", g_PR->GetPlayerName( m_iKillerIndex ) );
if ( m_pAvatar )
{
m_pAvatar->SetPlayer( pOwner );
}
pKiller = pOwner;
}
if ( m_pFreezeLabel )
{
if ( pKiller && !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_KillerObject_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_KillerObject" );
}
}
const char *pszStatusName = pObj->GetStatusName();
wchar_t *wszLocalized = g_pVGuiLocalize->Find( pszStatusName );
if ( !wszLocalized )
{
m_pBasePanel->SetDialogVariable( "objectkiller", pszStatusName );
}
else
{
m_pBasePanel->SetDialogVariable( "objectkiller", wszLocalized );
}
}
else if ( m_pFreezeLabel )
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer" );
}
}
}
// see if we should show nemesis panel
const wchar_t *pchNemesisText = NULL;
switch ( m_iShowNemesisPanel )
{
case SHOW_NO_NEMESIS:
{
C_TFPlayer *pVictim = C_TFPlayer::GetLocalTFPlayer();
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
//If this was just a regular kill but this guy is our nemesis then just show it.
if ( pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
pchNemesisText = g_pVGuiLocalize->Find( "#TF_FreezeNemesis" );
}
}
break;
case SHOW_NEW_NEMESIS:
{
C_TFPlayer *pVictim = C_TFPlayer::GetLocalTFPlayer();
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
// check to see if killer is still the nemesis of victim; victim may have managed to kill him after victim's
// death by grenade or some such, extracting revenge and clearing nemesis condition
if ( pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
pchNemesisText = g_pVGuiLocalize->Find( "#TF_NewNemesis" );
}
}
break;
case SHOW_REVENGE:
pchNemesisText = g_pVGuiLocalize->Find( "#TF_GotRevenge" );
break;
default:
Assert( false ); // invalid value
break;
}
m_pNemesisSubPanel->SetDialogVariable( "nemesisname", pchNemesisText );
ShowNemesisPanel( NULL != pchNemesisText );
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseObject::HighlightBuildPoints( int flags )
{
C_TFPlayer *pLocal = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocal )
return;
if ( !GetNumBuildPoints() || !InLocalTeam() )
return;
C_TFWeaponBuilder *pBuilderWpn = dynamic_cast< C_TFWeaponBuilder * >( pLocal->GetActiveWeaponForSelection() );
if ( !pBuilderWpn )
return;
if ( !pBuilderWpn->IsPlacingObject() )
return;
C_BaseObject *pPlacementObj = pBuilderWpn->GetPlacementModel();
if ( !pPlacementObj || pPlacementObj == this )
return;
// Near enough?
if ( (GetAbsOrigin() - pLocal->GetAbsOrigin()).LengthSqr() < MAX_VISIBLE_BUILDPOINT_DISTANCE )
{
bool bRestoreModel = false;
Vector vecPrevAbsOrigin = pPlacementObj->GetAbsOrigin();
QAngle vecPrevAbsAngles = pPlacementObj->GetAbsAngles();
Vector orgColor;
render->GetColorModulation( orgColor.Base() );
float orgBlend = render->GetBlend();
bool bSameTeam = ( pPlacementObj->GetTeamNumber() == GetTeamNumber() );
if ( pPlacementObj->IsHostileUpgrade() && bSameTeam )
{
// Don't hilight hostile upgrades on friendly objects
return;
}
else if ( !bSameTeam )
{
// Don't hilight upgrades on enemy objects
return;
}
// Any empty buildpoints?
for ( int i = 0; i < GetNumBuildPoints(); i++ )
{
// Can this object build on this point?
if ( CanBuildObjectOnBuildPoint( i, pPlacementObj->GetType() ) )
{
Vector vecBPOrigin;
QAngle vecBPAngles;
if ( GetBuildPoint(i, vecBPOrigin, vecBPAngles) )
{
pPlacementObj->InvalidateBoneCaches();
Vector color( 0, 255, 0 );
render->SetColorModulation( color.Base() );
float frac = fmod( gpGlobals->curtime, 3 );
frac *= 2 * M_PI;
frac = cos( frac );
render->SetBlend( (175 + (int)( frac * 75.0f )) / 255.0 );
// FIXME: This truly sucks! The bone cache should use
// render location for this computation instead of directly accessing AbsAngles
// Necessary for bone cache computations to work
pPlacementObj->SetAbsOrigin( vecBPOrigin );
pPlacementObj->SetAbsAngles( vecBPAngles );
modelrender->DrawModel(
flags,
pPlacementObj,
pPlacementObj->GetModelInstance(),
pPlacementObj->index,
pPlacementObj->GetModel(),
vecBPOrigin,
vecBPAngles,
pPlacementObj->m_nSkin,
pPlacementObj->m_nBody,
pPlacementObj->m_nHitboxSet
);
bRestoreModel = true;
}
}
}
if ( bRestoreModel )
{
pPlacementObj->SetAbsOrigin(vecPrevAbsOrigin);
pPlacementObj->SetAbsAngles(vecPrevAbsAngles);
pPlacementObj->InvalidateBoneCaches();
render->SetColorModulation( orgColor.Base() );
render->SetBlend( orgBlend );
}
}
}
//-----------------------------------------------------------------------------
// 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;
// Get our target's ent index
Assert( m_iTargetEntIndex );
// 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 iColorNum = TEAM_UNASSIGNED;
// 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.InCond( TF_COND_STEALTHED ) ) // they're not cloaked
{
bDisguisedTarget = true;
pDisguiseTarget = ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() );
}
iColorNum = pPlayer->GetTeamNumber();
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) );
// Show their disguise team color.
iColorNum = pPlayer->m_Shared.GetDisguiseTeam();
}
}
else
{
// The target is a disguised friendly spy. They appear to the player with no disguise. Add the disguise
// team & class to the target ID element.
bool bDisguisedAsEnemy = ( pPlayer->m_Shared.GetDisguiseTeam() != pPlayer->GetTeamNumber() );
const wchar_t *wszAlignment = g_pVGuiLocalize->Find( bDisguisedAsEnemy ? "#TF_enemy" : "#TF_friendly" );
int classindex = pPlayer->m_Shared.GetDisguiseClass();
const wchar_t *wszClassName = g_pVGuiLocalize->Find( g_aPlayerClassNames[classindex] );
// build a string with disguise information
g_pVGuiLocalize->ConstructString( sDataString, sizeof(sDataString), g_pVGuiLocalize->Find( "#TF_playerid_friendlyspy_disguise" ),
2, wszAlignment, wszClassName );
}
}
if ( pPlayer->IsPlayerClass( TF_CLASS_MEDIC ) )
{
wchar_t wszChargeLevel[ 10 ];
_snwprintf( wszChargeLevel, ARRAYSIZE(wszChargeLevel) - 1, L"%.0f", pPlayer->MedicGetChargeLevel() * 100 );
wszChargeLevel[ ARRAYSIZE(wszChargeLevel)-1 ] = '\0';
g_pVGuiLocalize->ConstructString( sDataString, sizeof(sDataString), g_pVGuiLocalize->Find( "#TF_playerid_mediccharge" ), 1, wszChargeLevel );
}
if (pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR || pPlayer->InSameTeam(pLocalTFPlayer) || (bDisguisedEnemy && pPlayer->m_Shared.GetDisguiseTeam() == pLocalTFPlayer->GetTeamNumber()))
{
printFormatString = "#TF_playerid_sameteam";
bShowHealth = true;
}
else if ( pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) && !pPlayer->m_Shared.InCond( TF_COND_STEALTHED ) )
{
// Spy can see enemy's health.
printFormatString = "#TF_playerid_diffteam";
bShowHealth = true;
}
if ( bShowHealth )
{
C_TF_PlayerResource *tf_PR = dynamic_cast<C_TF_PlayerResource *>(g_PR);
if ( tf_PR )
{
flMaxHealth = tf_PR->GetMaxHealth( m_iTargetEntIndex );
iMaxBuffedHealth = pPlayer->m_Shared.GetMaxBuffedHealth();
if ( bDisguisedEnemy )
{
flHealth = (float)pPlayer->m_Shared.GetDisguiseHealth();
}
else
{
flHealth = (float)pPlayer->GetHealth();
}
}
else
{
bShowHealth = false;
}
}
if ( printFormatString )
{
wchar_t *pszPrepend = GetPrepend();
if ( !pszPrepend || !pszPrepend[0] )
{
pszPrepend = L"";
}
g_pVGuiLocalize->ConstructString( sIDString, sizeof(sIDString), g_pVGuiLocalize->Find(printFormatString), 2, pszPrepend, wszPlayerName );
}
}
else
{
// see if it is an object
if ( pEnt->IsBaseObject() )
{
C_BaseObject *pObj = assert_cast<C_BaseObject *>( pEnt );
pObj->GetTargetIDString( sIDString, sizeof(sIDString) );
pObj->GetTargetIDDataString( sDataString, sizeof(sDataString) );
bShowHealth = true;
flHealth = pObj->GetHealth();
flMaxHealth = pObj->GetMaxHealth();
C_TFPlayer *pBuilder = pObj->GetBuilder();
iColorNum = pBuilder ? pBuilder->GetTeamNumber() : pObj->GetTeamNumber();
}
else if ( pEnt->IsNPC() )
{
C_AI_BaseNPC *pNPC = assert_cast<C_AI_BaseNPC *>( pEnt );
pNPC->GetTargetIDString( sIDString, sizeof(sIDString) );
pNPC->GetTargetIDDataString( sDataString, sizeof(sDataString) );
bShowHealth = true;
flHealth = pNPC->GetHealth();
flMaxHealth = pNPC->GetMaxHealth();
iMaxBuffedHealth = pNPC->GetMaxBuffedHealth();
iColorNum = pNPC->GetTeamNumber();
}
}
// Setup health icon
if ( !pEnt->IsAlive() )
{
flHealth = 0; // fixup for health being 1 when dead
}
SetColorForTargetTeam( iColorNum );
m_pTargetHealth->SetHealth( flHealth, flMaxHealth, iMaxBuffedHealth );
m_pTargetHealth->SetVisible( bShowHealth );
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);
// 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);
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_bLayoutOnUpdate || (iPostDataW != iDataW) || (iPostNameW != iNameW) )
{
InvalidateLayout( true );
m_bLayoutOnUpdate = false;
}
}
}
//-----------------------------------------------------------------------------
// 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() );
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
{
if ( !m_pAlertTray->IsTrayOut() )
{
m_pAlertTray->ShowTray();
}
m_pAlertTray->SetAlertType( alertLevel );
m_pWrenchIcon->SetVisible( false );
m_pSapperIcon->SetVisible( false );
if ( m_pAlertTray->GetAlertType() != BUILDING_HUD_ALERT_NONE &&
m_pAlertTray->GetPercentDeployed() >= 1.0f )
{
switch( m_pAlertTray->GetAlertType() )
{
case BUILDING_HUD_ALERT_LOW_AMMO:
case BUILDING_HUD_ALERT_LOW_HEALTH:
case BUILDING_HUD_ALERT_VERY_LOW_AMMO:
case BUILDING_HUD_ALERT_VERY_LOW_HEALTH:
m_pWrenchIcon->SetVisible( true );
break;
case BUILDING_HUD_ALERT_SAPPER:
m_pSapperIcon->SetVisible( true );
break;
case BUILDING_HUD_ALERT_NONE:
default:
break;
}
}
}
}