//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ClientsideProjectileNailCallback(const CEffectData &data)
{
C_TFPlayer *pPlayer = dynamic_cast<C_TFPlayer*>(ClientEntityList().GetBaseEntityFromHandle(data.m_hEntity));
if (pPlayer)
{
C_LocalTempEntity *pNail = ClientsideProjectileCallback(data, NAILGUN_NAIL_GRAVITY);
if (pNail)
{
switch (pPlayer->GetTeamNumber())
{
case TF_TEAM_RED:
pNail->m_nSkin = 0;
break;
case TF_TEAM_BLUE:
pNail->m_nSkin = 1;
break;
case TF_TEAM_GREEN:
pNail->m_nSkin = 2;
break;
case TF_TEAM_YELLOW:
pNail->m_nSkin = 3;
break;
}
bool bCritical = ((data.m_nDamageType & DMG_CRITICAL) != 0);
pPlayer->m_Shared.SetParticleToMercColor(
pNail->AddParticleEffect(GetNailTrailParticleName(pPlayer->GetTeamNumber(), bCritical))
);
pNail->AddEffects(EF_NOSHADOW);
pNail->flags |= FTENT_USEFASTCOLLISIONS;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ClientsideProjectileSyringeCallback( const CEffectData &data )
{
// Get the syringe and add it to the client entity list, so we can attach a particle system to it.
C_TFPlayer *pPlayer = dynamic_cast<C_TFPlayer*>( ClientEntityList().GetBaseEntityFromHandle( data.m_hEntity ) );
if ( pPlayer )
{
C_LocalTempEntity *pSyringe = ClientsideProjectileCallback( data, SYRINGE_GRAVITY );
if ( pSyringe )
{
switch (pPlayer->GetTeamNumber())
{
case TF_TEAM_RED:
pSyringe->m_nSkin = 0;
break;
case TF_TEAM_BLUE:
pSyringe->m_nSkin = 1;
break;
case TF_TEAM_GREEN:
pSyringe->m_nSkin = 2;
break;
case TF_TEAM_YELLOW:
pSyringe->m_nSkin = 3;
break;
}
bool bCritical = ( ( data.m_nDamageType & DMG_CRITICAL ) != 0 );
pPlayer->m_Shared.SetParticleToMercColor(
pSyringe->AddParticleEffect(GetSyringeTrailParticleName(pPlayer->GetTeamNumber(), bCritical))
);
pSyringe->AddEffects( EF_NOSHADOW );
pSyringe->flags |= FTENT_USEFASTCOLLISIONS;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSpectatorGUI::UpdateReinforcements( void )
{
if( !m_pReinforcementsLabel )
return;
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer || pPlayer->IsHLTV() ||
(pPlayer->GetTeamNumber() != TF_TEAM_RED && pPlayer->GetTeamNumber() != TF_TEAM_BLUE && pPlayer->GetTeamNumber() != TF_TEAM_GREEN && pPlayer->GetTeamNumber() != TF_TEAM_YELLOW) ||
( pPlayer->m_Shared.GetState() != TF_STATE_OBSERVER ) && ( pPlayer->m_Shared.GetState() != TF_STATE_DYING ) ||
( pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM ) )
{
m_pReinforcementsLabel->SetVisible( false );
return;
}
wchar_t wLabel[128];
if ( TFGameRules()->InStalemate() )
{
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find( "#game_respawntime_stalemate" ), 0 );
}
else if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
{
// a team has won the round
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find( "#game_respawntime_next_round" ), 0 );
}
else
{
float flNextRespawn = TFGameRules()->GetNextRespawnWave( pPlayer->GetTeamNumber(), pPlayer );
if ( !flNextRespawn )
{
m_pReinforcementsLabel->SetVisible( false );
return;
}
int iRespawnWait = (flNextRespawn - gpGlobals->curtime);
if ( iRespawnWait <= 0 )
{
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find("#game_respawntime_now" ), 0 );
}
else if ( iRespawnWait <= 1.0 )
{
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find("#game_respawntime_in_sec" ), 0 );
}
else
{
char szSecs[6];
Q_snprintf( szSecs, sizeof(szSecs), "%d", iRespawnWait );
wchar_t wSecs[4];
g_pVGuiLocalize->ConvertANSIToUnicode(szSecs, wSecs, sizeof(wSecs));
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find("#game_respawntime_in_secs" ), 1, wSecs );
}
}
m_pReinforcementsLabel->SetVisible( true );
m_pReinforcementsLabel->SetText( wLabel, true );
}
const char *CHudChat::GetDisplayedSubtitlePlayerName( int clientIndex )
{
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( clientIndex ) );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer || !pLocalPlayer )
return BaseClass::GetDisplayedSubtitlePlayerName( clientIndex );
// If they are disguised as the enemy, and not on our team
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) &&
pPlayer->m_Shared.GetDisguiseTeam() != pPlayer->GetTeamNumber() &&
!pLocalPlayer->InSameTeam( pPlayer ) )
{
C_TFPlayer *pDisguiseTarget = ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() );
Assert( pDisguiseTarget );
if ( !pDisguiseTarget )
{
return BaseClass::GetDisplayedSubtitlePlayerName( clientIndex );
}
return pDisguiseTarget->GetPlayerName();
}
return BaseClass::GetDisplayedSubtitlePlayerName( clientIndex );
}
//-----------------------------------------------------------------------------
// Purpose: called to update the menu with new information
//-----------------------------------------------------------------------------
void CTFTeamMenu::Update( void )
{
BaseClass::Update();
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && ( pLocalPlayer->GetTeamNumber() != TEAM_UNASSIGNED ) )
{
#ifdef _X360
if ( m_pFooter )
{
m_pFooter->ShowButtonLabel( "cancel", true );
}
#else
if ( m_pCancelButton )
{
m_pCancelButton->SetVisible( true );
}
#endif
}
else
{
#ifdef _X360
if ( m_pFooter )
{
m_pFooter->ShowButtonLabel( "cancel", false );
}
#else
if ( m_pCancelButton && m_pCancelButton->IsVisible() )
{
m_pCancelButton->SetVisible( false );
}
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CBuildingStatusItem_SentryGun::GetBackgroundImage( void )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
const char *pResult = "obj_status_background_tall_blue";
if ( !pLocalPlayer )
{
return pResult;
}
switch( pLocalPlayer->GetTeamNumber() )
{
case TF_TEAM_BLUE:
pResult = "obj_status_background_tall_blue";
break;
case TF_TEAM_RED:
pResult = "obj_status_background_tall_red";
break;
default:
break;
}
return pResult;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFImagePanel::FireGameEvent(IGameEvent * event)
{
if ( FStrEq( "localplayer_changeteam", event->GetName() ) )
{
C_TFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
m_iBGTeam = pPlayer ? pPlayer->GetTeamNumber() : TEAM_UNASSIGNED;
UpdateBGImage();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFImagePanel::CTFImagePanel(Panel *parent, const char *name) : ScalableImagePanel(parent, name)
{
for ( int i = 0; i < TF_TEAM_COUNT; i++ )
{
m_szTeamBG[i][0] = '\0';
}
C_TFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
m_iBGTeam = pPlayer ? pPlayer->GetTeamNumber() : TEAM_UNASSIGNED;
ListenForGameEvent( "localplayer_changeteam" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatPanel::TestStatPanel( TFStatType_t statType, RecordBreakType_t recordType )
{
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer )
return;
m_iCurStatClass = pPlayer->GetPlayerClass()->GetClassIndex();
ClassStats_t &classStats = GetClassStats( m_iCurStatClass );;
m_iCurStatValue = classStats.max.m_iStat[statType];
m_iCurStatTeam = pPlayer->GetTeamNumber();
ShowStatPanel( m_iCurStatClass, m_iCurStatTeam, m_iCurStatValue, statType, recordType, false );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the user picks a team
//-----------------------------------------------------------------------------
void CTFTeamMenu::OnCommand( const char *command )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( Q_stricmp( command, "vguicancel" ) )
{
// we're selecting a team, so make sure it's not the team we're already on before sending to the server
if ( pLocalPlayer && ( Q_strstr( command, "jointeam " ) ) )
{
const char *pTeam = command + Q_strlen( "jointeam " );
int iTeam = TEAM_INVALID;
if ( Q_stricmp( pTeam, "spectate" ) == 0 )
{
iTeam = TEAM_SPECTATOR;
}
else if ( Q_stricmp( pTeam, "red" ) == 0 )
{
iTeam = TF_TEAM_RED;
}
else if ( Q_stricmp( pTeam, "blue" ) == 0 )
{
iTeam = TF_TEAM_BLUE;
}
if ( iTeam == TF_TEAM_RED && m_bRedDisabled )
{
return;
}
if ( iTeam == TF_TEAM_BLUE && m_bBlueDisabled )
{
return;
}
// are we selecting the team we're already on?
if ( pLocalPlayer->GetTeamNumber() != iTeam )
{
engine->ClientCmd( command );
}
}
else if ( pLocalPlayer && ( Q_strstr( command, "jointeam_nomenus " ) ) )
{
engine->ClientCmd( command );
}
}
BaseClass::OnCommand( command );
ShowPanel( false );
OnClose();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHudBuildingStatusContainer_Engineer::ShouldDraw( void )
{
// Don't draw in freezecam
C_TFPlayer *pPlayer = CTFPlayer::GetLocalTFPlayer();
if ( !pPlayer || !pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) || pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
{
return false;
}
if ( pPlayer->GetTeamNumber() <= TEAM_SPECTATOR )
{
return false;
}
return CHudElement::ShouldDraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_AI_BaseNPC::GetTargetIDString( wchar_t *sIDString, int iMaxLenInBytes )
{
sIDString[0] = '\0';
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return;
if ( InSameTeam( pLocalTFPlayer ) || pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) || pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
const char *pszClassname = GetClassname();
wchar_t *wszNPCName;
wszNPCName = g_pVGuiLocalize->Find( pszClassname );
if ( !wszNPCName )
{
wchar_t wszNPCNameBuf[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( pszClassname, wszNPCNameBuf, sizeof(wszNPCNameBuf) );
wszNPCName = wszNPCNameBuf;
}
const char *printFormatString = NULL;
if ( pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR || InSameTeam( pLocalTFPlayer ) )
{
printFormatString = "#TF_playerid_sameteam";
}
else if ( pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) )
{
// Spy can see enemy's health.
printFormatString = "#TF_playerid_diffteam";
}
wchar_t *wszPrepend = L"";
if ( printFormatString )
{
g_pVGuiLocalize->ConstructString( sIDString, iMaxLenInBytes, g_pVGuiLocalize->Find(printFormatString), 3, wszPrepend, wszNPCName );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: called to update the menu with new information
//-----------------------------------------------------------------------------
void CTFFourTeamMenu::Update(void)
{
BaseClass::Update();
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if (pLocalPlayer && (pLocalPlayer->GetTeamNumber() != TEAM_UNASSIGNED))
{
if (m_pCancelButton)
{
m_pCancelButton->SetVisible(true);
}
}
else
{
if (m_pCancelButton && m_pCancelButton->IsVisible())
{
m_pCancelButton->SetVisible(false);
}
}
}
//-----------------------------------------------------------------------------
Color CHudChat::GetClientColor( int clientIndex )
{
IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
if ( pScheme == NULL )
return Color( 255, 255, 255, 255 );
if ( clientIndex == 0 ) // console msg
{
return g_ColorGreen;
}
else if( g_PR )
{
int iTeam = g_PR->GetTeam( clientIndex );
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( clientIndex ) );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( IsVoiceSubtitle() == true )
{
// if this player is on the other team, disguised as my team, show disguised color
if ( pPlayer && pLocalPlayer && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) &&
pPlayer->m_Shared.GetDisguiseTeam() == pLocalPlayer->GetTeamNumber() )
{
iTeam = pPlayer->m_Shared.GetDisguiseTeam();
}
}
switch ( iTeam )
{
case TF_TEAM_RED : return pScheme->GetColor( "TFColors.ChatTextRed", g_ColorRed );
case TF_TEAM_BLUE : return pScheme->GetColor( "TFColors.ChatTextBlue", g_ColorBlue );;
default : return g_ColorGrey;
}
}
return g_ColorYellow;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFourTeamMenu::OnKeyCodePressed(KeyCode code)
{
if ((m_iTeamMenuKey != BUTTON_CODE_INVALID && m_iTeamMenuKey == code) ||
code == KEY_XBUTTON_BACK ||
code == KEY_XBUTTON_B)
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if (pLocalPlayer && (pLocalPlayer->GetTeamNumber() != TEAM_UNASSIGNED))
{
ShowPanel(false);
}
}
else if (code == KEY_SPACE)
{
engine->ClientCmd("jointeam auto");
ShowPanel(false);
OnClose();
}
else if (code == KEY_XBUTTON_A || code == KEY_XBUTTON_RTRIGGER)
{
// select the active focus
if (GetFocusNavGroup().GetCurrentFocus())
{
ipanel()->SendMessage(GetFocusNavGroup().GetCurrentFocus()->GetVPanel(), new KeyValues("PressButton"), GetVPanel());
}
}
else if (code == KEY_XBUTTON_RIGHT || code == KEY_XSTICK1_RIGHT)
{
CTFTeamButton *pButton;
pButton = dynamic_cast< CTFTeamButton *> (GetFocusNavGroup().GetCurrentFocus());
if (pButton)
{
pButton->OnCursorExited();
GetFocusNavGroup().RequestFocusNext(pButton->GetVPanel());
}
else
{
GetFocusNavGroup().RequestFocusNext(NULL);
}
pButton = dynamic_cast< CTFTeamButton * > (GetFocusNavGroup().GetCurrentFocus());
if (pButton)
{
pButton->OnCursorEntered();
}
}
else if (code == KEY_XBUTTON_LEFT || code == KEY_XSTICK1_LEFT)
{
CTFTeamButton *pButton;
pButton = dynamic_cast< CTFTeamButton *> (GetFocusNavGroup().GetCurrentFocus());
if (pButton)
{
pButton->OnCursorExited();
GetFocusNavGroup().RequestFocusPrev(pButton->GetVPanel());
}
else
{
GetFocusNavGroup().RequestFocusPrev(NULL);
}
pButton = dynamic_cast< CTFTeamButton * > (GetFocusNavGroup().GetCurrentFocus());
if (pButton)
{
pButton->OnCursorEntered();
}
}
else if (m_iScoreBoardKey != BUTTON_CODE_INVALID && m_iScoreBoardKey == code)
{
gViewPortInterface->ShowPanel(PANEL_SCOREBOARD, true);
gViewPortInterface->PostMessageToPanel(PANEL_SCOREBOARD, new KeyValues("PollHideCode", "code", code));
}
else
{
BaseClass::OnKeyCodePressed(code);
}
}
//-----------------------------------------------------------------------------
// Frame-based update
//-----------------------------------------------------------------------------
void CTFTeamMenu::OnTick()
{
// update the number of players on each team
// enable or disable buttons based on team limit
C_Team *pRed = GetGlobalTeam( TF_TEAM_RED );
C_Team *pBlue = GetGlobalTeam( TF_TEAM_BLUE );
if ( !pRed || !pBlue )
return;
// set our team counts
SetDialogVariable( "bluecount", pBlue->Get_Number_Players() );
SetDialogVariable( "redcount", pRed->Get_Number_Players() );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
CTFGameRules *pRules = TFGameRules();
if ( !pRules )
return;
// check if teams are unbalanced
m_bRedDisabled = m_bBlueDisabled = false;
int iHeavyTeam, iLightTeam;
bool bUnbalanced = pRules->AreTeamsUnbalanced( iHeavyTeam, iLightTeam );
int iCurrentTeam = pLocalPlayer->GetTeamNumber();
if ( ( bUnbalanced && iHeavyTeam == TF_TEAM_RED ) || ( pRules->WouldChangeUnbalanceTeams( TF_TEAM_RED, iCurrentTeam ) ) )
{
m_bRedDisabled = true;
}
if ( ( bUnbalanced && iHeavyTeam == TF_TEAM_BLUE ) || ( pRules->WouldChangeUnbalanceTeams( TF_TEAM_BLUE, iCurrentTeam ) ) )
{
m_bBlueDisabled = true;
}
if ( m_pSpecTeamButton && m_pSpecLabel )
{
ConVarRef mp_allowspectators( "mp_allowspectators" );
if ( mp_allowspectators.IsValid() )
{
if ( mp_allowspectators.GetBool() )
{
if ( !m_pSpecTeamButton->IsVisible() )
{
m_pSpecTeamButton->SetVisible( true );
m_pSpecLabel->SetVisible( true );
}
}
else
{
if ( m_pSpecTeamButton->IsVisible() )
{
m_pSpecTeamButton->SetVisible( false );
m_pSpecLabel->SetVisible( false );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSpectatorGUI::UpdateKeyLabels( void )
{
// get the desired player class
int iClass = TF_CLASS_UNDEFINED;
bool bIsHLTV = engine->IsHLTV();
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pPlayer )
{
iClass = pPlayer->m_Shared.GetDesiredPlayerClassIndex();
}
// if it's time to change the tip, or the player has changed desired class, update the tip
if ( ( gpGlobals->curtime >= m_flNextTipChangeTime ) || ( iClass != m_iTipClass ) )
{
if ( bIsHLTV )
{
const wchar_t *wzTip = g_pVGuiLocalize->Find( "#Tip_HLTV" );
if ( wzTip )
{
SetDialogVariable( "tip", wzTip );
}
}
else
{
wchar_t wzTipLabel[512]=L"";
const wchar_t *wzTip = g_TFTips.GetNextClassTip( iClass );
Assert( wzTip && wzTip[0] );
g_pVGuiLocalize->ConstructString( wzTipLabel, sizeof( wzTipLabel ), g_pVGuiLocalize->Find( "#Tip_Fmt" ), 1, wzTip );
SetDialogVariable( "tip", wzTipLabel );
}
m_flNextTipChangeTime = gpGlobals->curtime + 10.0f;
m_iTipClass = iClass;
}
if ( m_pClassOrTeamLabel )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
static wchar_t wzFinal[512] = L"";
const wchar_t *wzTemp = NULL;
if ( bIsHLTV )
{
wzTemp = g_pVGuiLocalize->Find( "#TF_Spectator_AutoDirector" );
}
else if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
wzTemp = g_pVGuiLocalize->Find( "#TF_Spectator_ChangeTeam" );
}
else
{
wzTemp = g_pVGuiLocalize->Find( "#TF_Spectator_ChangeClass" );
}
if ( wzTemp )
{
UTIL_ReplaceKeyBindings( wzTemp, 0, wzFinal, sizeof( wzFinal ) );
m_pClassOrTeamLabel->SetText( wzFinal );
}
}
}
if ( m_pSwitchCamModeKeyLabel )
{
if ( ( pPlayer && pPlayer->GetTeamNumber() > TEAM_SPECTATOR ) && ( ( mp_forcecamera.GetInt() == OBS_ALLOW_TEAM ) || ( mp_forcecamera.GetInt() == OBS_ALLOW_NONE ) || mp_fadetoblack.GetBool() ) )
{
if ( m_pSwitchCamModeKeyLabel->IsVisible() )
{
m_pSwitchCamModeKeyLabel->SetVisible( false );
Label *pLabel = dynamic_cast<Label *>( FindChildByName( "SwitchCamModeLabel" ) );
if ( pLabel )
{
pLabel->SetVisible( false );
}
}
}
else
{
if ( !m_pSwitchCamModeKeyLabel->IsVisible() )
{
m_pSwitchCamModeKeyLabel->SetVisible( true );
Label *pLabel = dynamic_cast<Label *>( FindChildByName( "SwitchCamModeLabel" ) );
if ( pLabel )
{
pLabel->SetVisible( true );
}
}
wchar_t wLabel[256] = L"";
const wchar_t *wzTemp = g_pVGuiLocalize->Find( "#TF_Spectator_SwitchCamModeKey" );
UTIL_ReplaceKeyBindings( wzTemp, 0, wLabel, sizeof( wLabel ) );
m_pSwitchCamModeKeyLabel->SetText( wLabel );
}
}
if ( m_pCycleTargetFwdKeyLabel )
{
if ( ( pPlayer && pPlayer->GetTeamNumber() > TEAM_SPECTATOR ) && ( mp_fadetoblack.GetBool() || ( mp_forcecamera.GetInt() == OBS_ALLOW_NONE ) ) )
{
if ( m_pCycleTargetFwdKeyLabel->IsVisible() )
{
m_pCycleTargetFwdKeyLabel->SetVisible( false );
Label *pLabel = dynamic_cast<Label *>( FindChildByName( "CycleTargetFwdLabel" ) );
if ( pLabel )
{
pLabel->SetVisible( false );
}
}
}
else
{
if ( !m_pCycleTargetFwdKeyLabel->IsVisible() )
{
m_pCycleTargetFwdKeyLabel->SetVisible( true );
Label *pLabel = dynamic_cast<Label *>( FindChildByName( "CycleTargetFwdLabel" ) );
if ( pLabel )
{
pLabel->SetVisible( true );
}
}
wchar_t wLabel[256] = L"";
const wchar_t *wzTemp = g_pVGuiLocalize->Find( "#TF_Spectator_CycleTargetFwdKey" );
UTIL_ReplaceKeyBindings( wzTemp, 0, wLabel, sizeof( wLabel ) );
m_pCycleTargetFwdKeyLabel->SetText( wLabel );
}
}
if ( m_pCycleTargetRevKeyLabel )
{
if ( ( pPlayer && pPlayer->GetTeamNumber() > TEAM_SPECTATOR ) && ( mp_fadetoblack.GetBool() || ( mp_forcecamera.GetInt() == OBS_ALLOW_NONE ) ) )
{
if ( m_pCycleTargetRevKeyLabel->IsVisible() )
{
m_pCycleTargetRevKeyLabel->SetVisible( false );
Label *pLabel = dynamic_cast<Label *>( FindChildByName( "CycleTargetRevLabel" ) );
if ( pLabel )
{
pLabel->SetVisible( false );
}
}
}
else
{
if ( !m_pCycleTargetRevKeyLabel->IsVisible() )
{
m_pCycleTargetRevKeyLabel->SetVisible( true );
Label *pLabel = dynamic_cast<Label *>( FindChildByName( "CycleTargetRevLabel" ) );
if ( pLabel )
{
pLabel->SetVisible( true );
}
}
wchar_t wLabel[256] = L"";
const wchar_t *wzTemp = g_pVGuiLocalize->Find( "#TF_Spectator_CycleTargetRevKey" );
UTIL_ReplaceKeyBindings( wzTemp, 0, wLabel, sizeof( wLabel ) );
m_pCycleTargetRevKeyLabel->SetText( wLabel );
}
}
if ( m_pMapLabel )
{
wchar_t wMapName[16];
wchar_t wLabel[256];
char szMapName[16];
char tempname[128];
Q_FileBase( engine->GetLevelName(), tempname, sizeof( tempname ) );
Q_strlower( tempname );
if ( IsX360() )
{
char *pExt = Q_stristr( tempname, ".360" );
if ( pExt )
{
*pExt = '\0';
}
}
Q_strncpy( szMapName, GetMapDisplayName( tempname ), sizeof( szMapName ) );
g_pVGuiLocalize->ConvertANSIToUnicode( szMapName, wMapName, sizeof(wMapName));
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find( "#Spec_Map" ), 1, wMapName );
m_pMapLabel->SetText( wLabel );
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when we get a stat update for the local player
//-----------------------------------------------------------------------------
void CTFStatPanel::MsgFunc_PlayerStatsUpdate( bf_read &msg )
{
// get the fixed-size information
int iClass = msg.ReadByte();
int iMsgType = msg.ReadByte();
int iSendBits = msg.ReadLong();
bool bAlive = true;
bool bSpawned = false;
switch ( iMsgType )
{
case STATMSG_RESET:
m_RoundStatsCurrentGame.Reset();
m_RoundStatsLifeStart.Reset();
return;
case STATMSG_PLAYERSPAWN:
case STATMSG_PLAYERRESPAWN:
bSpawned = true;
break;
case STATMSG_PLAYERDEATH:
bAlive = false;
break;
case STATMSG_UPDATE:
break;
default:
Assert( false );
}
Assert( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= TF_LAST_NORMAL_CLASS );
if ( iClass < TF_FIRST_NORMAL_CLASS || iClass > TF_LAST_NORMAL_CLASS )
return;
m_iClassCurrentLife = iClass;
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pPlayer )
{
m_iTeamCurrentLife = pPlayer->GetTeamNumber();
}
// Msg( "Stat update: (msg %d) ", iMsgType );
// the bitfield indicates which stats are contained in the message. Set the stats appropriately.
int iStat = TFSTAT_FIRST;
while ( iSendBits > 0 )
{
if ( iSendBits & 1 )
{
int iVal = msg.ReadLong();
// Msg( "#%d=%d ", iStat, iVal );
m_RoundStatsCurrentGame.m_iStat[iStat] = iVal;
}
iSendBits >>= 1;
iStat++;
}
// Msg( "\n" );
// Calculate stat values for current life. Take current game stats and subtract what the values were at the start of this life
for ( iStat = TFSTAT_FIRST; iStat < TFSTAT_MAX; iStat++ )
{
if ( iStat == TFSTAT_MAXSENTRYKILLS )
{
// max sentry kills is special, it is a max value. Always use absolute value, do not use delta from earlier value.
m_RoundStatsCurrentLife.m_iStat[TFSTAT_MAXSENTRYKILLS] = m_RoundStatsCurrentGame.m_iStat[TFSTAT_MAXSENTRYKILLS];
continue;
}
int iDelta = m_RoundStatsCurrentGame.m_iStat[iStat] - m_RoundStatsLifeStart.m_iStat[iStat];
Assert( iDelta >= 0 );
m_RoundStatsCurrentLife.m_iStat[iStat] = iDelta;
}
if ( iMsgType == STATMSG_PLAYERDEATH || iMsgType == STATMSG_PLAYERRESPAWN )
{
m_RoundStatsCurrentLife.m_iStat[TFSTAT_PLAYTIME] = gpGlobals->curtime - m_flTimeCurrentLifeStart;
}
if ( bSpawned )
{
// if the player just spawned, use current stats as baseline to calculate stats for next life
m_RoundStatsLifeStart = m_RoundStatsCurrentGame;
m_flTimeCurrentLifeStart = gpGlobals->curtime;
}
// sanity check: the message should contain exactly the # of bytes we expect based on the bit field
Assert( !msg.IsOverflowed() );
Assert( 0 == msg.GetNumBytesLeft() );
// if byte count isn't correct, bail out and don't use this data, rather than risk polluting player stats with garbage
if ( msg.IsOverflowed() || ( 0 != msg.GetNumBytesLeft() ) )
return;
UpdateStats( iMsgType );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CHudNotificationPanel::GetNotificationByType( int iType )
{
bool bOnBlueTeam = false;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
bOnBlueTeam = ( pLocalPlayer->GetTeamNumber() == TF_TEAM_BLUE );
}
const char *pszResult = "";
switch ( iType )
{
case HUD_NOTIFY_YOUR_FLAG_TAKEN:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_your_flag_taken_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_your_flag_taken_red.res";
}
break;
case HUD_NOTIFY_YOUR_FLAG_DROPPED:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_your_flag_dropped_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_your_flag_dropped_red.res";
}
break;
case HUD_NOTIFY_YOUR_FLAG_RETURNED:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_your_flag_returned_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_your_flag_returned_red.res";
}
break;
case HUD_NOTIFY_YOUR_FLAG_CAPTURED:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_your_flag_captured_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_your_flag_captured_red.res";
}
break;
case HUD_NOTIFY_ENEMY_FLAG_TAKEN:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_enemy_flag_taken_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_enemy_flag_taken_red.res";
}
break;
case HUD_NOTIFY_ENEMY_FLAG_DROPPED:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_enemy_flag_dropped_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_enemy_flag_dropped_red.res";
}
break;
case HUD_NOTIFY_ENEMY_FLAG_RETURNED:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_enemy_flag_returned_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_enemy_flag_returned_red.res";
}
break;
case HUD_NOTIFY_ENEMY_FLAG_CAPTURED:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_enemy_flag_captured_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_enemy_flag_captured_red.res";
}
break;
case HUD_NOTIFY_TOUCHING_ENEMY_CTF_CAP:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_touching_enemy_ctf_cap_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_touching_enemy_ctf_cap_red.res";
}
break;
case HUD_NOTIFY_NO_INVULN_WITH_FLAG:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_no_invuln_with_flag_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_no_invuln_with_flag_red.res";
}
break;
case HUD_NOTIFY_NO_TELE_WITH_FLAG:
if ( bOnBlueTeam )
{
pszResult = "resource/UI/notifications/notify_no_tele_with_flag_blue.res";
}
else
{
pszResult = "resource/UI/notifications/notify_no_tele_with_flag_red.res";
}
break;
case HUD_NOTIFY_SPECIAL:
pszResult = "resource/UI/notifications/notify_special.res";
break;
default:
break;
}
return pszResult;
}
//-----------------------------------------------------------------------------
// Purpose: Get ammo info from the weapon and update the displays.
//-----------------------------------------------------------------------------
void CTFHudWeaponAmmo::OnThink()
{
// Get the player and active weapon.
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer )
return;
C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if ( tf2c_ammobucket.GetBool() && m_pWeaponBucket && pWeapon )
{
const CHudTexture *pTexture = pWeapon->GetSpriteInactive(); // red team
if ( pPlayer )
{
if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
pTexture = pWeapon->GetSpriteActive();
}
}
if ( pTexture )
{
char szImage[64];
Q_snprintf( szImage, sizeof(szImage), "../%s", pTexture->szTextureFile );
m_pWeaponBucket->SetImage( szImage );
m_pWeaponBucket->SetVisible( true );
}
else
{
m_pWeaponBucket->SetVisible( false );
}
}
else
{
m_pWeaponBucket->SetVisible( false );
}
if ( m_flNextThink < gpGlobals->curtime )
{
hudlcd->SetGlobalStat( "(weapon_print_name)", pWeapon ? pWeapon->GetPrintName() : " " );
hudlcd->SetGlobalStat( "(weapon_name)", pWeapon ? pWeapon->GetName() : " " );
if ( !pPlayer || !pWeapon || !pWeapon->UsesPrimaryAmmo() )
{
hudlcd->SetGlobalStat( "(ammo_primary)", "n/a" );
hudlcd->SetGlobalStat( "(ammo_secondary)", "n/a" );
// turn off our ammo counts
UpdateAmmoLabels( false, false, false );
m_nAmmo = -1;
m_nAmmo2 = -1;
}
else
{
// Get the ammo in our clip.
int nAmmo1 = pWeapon->Clip1();
int nAmmo2 = 0;
// Clip ammo not used, get total ammo count.
if ( nAmmo1 < 0 )
{
nAmmo1 = pPlayer->GetAmmoCount( pWeapon->GetPrimaryAmmoType() );
}
// Clip ammo, so the second ammo is the total ammo.
else
{
nAmmo2 = pPlayer->GetAmmoCount( pWeapon->GetPrimaryAmmoType() );
}
hudlcd->SetGlobalStat( "(ammo_primary)", VarArgs( "%d", nAmmo1 ) );
hudlcd->SetGlobalStat( "(ammo_secondary)", VarArgs( "%d", nAmmo2 ) );
if ( m_nAmmo != nAmmo1 || m_nAmmo2 != nAmmo2 || m_hCurrentActiveWeapon.Get() != pWeapon )
{
m_nAmmo = nAmmo1;
m_nAmmo2 = nAmmo2;
m_hCurrentActiveWeapon = pWeapon;
if ( m_hCurrentActiveWeapon.Get()->UsesClipsForAmmo1() )
{
UpdateAmmoLabels( true, true, false );
SetDialogVariable( "Ammo", m_nAmmo );
SetDialogVariable( "AmmoInReserve", m_nAmmo2 );
}
else
{
UpdateAmmoLabels( false, false, true );
SetDialogVariable( "Ammo", m_nAmmo );
}
}
}
m_flNextThink = gpGlobals->curtime + 0.1f;
}
}
//-----------------------------------------------------------------------------
// Purpose: Updates the player list
//-----------------------------------------------------------------------------
void CTFDeathMatchScoreBoardDialog::UpdatePlayerList()
{
int iSelectedPlayerIndex = GetLocalPlayerIndex();
// Save off which player we had selected
SectionedListPanel *pList = GetSelectedPlayerList();
if ( pList )
{
int itemID = pList->GetSelectedItem();
if ( itemID >= 0 )
{
KeyValues *pInfo = pList->GetItemData( itemID );
if ( pInfo )
{
iSelectedPlayerIndex = pInfo->GetInt( "playerIndex" );
}
}
}
m_pPlayerListRed->RemoveAll();
C_TF_PlayerResource *tf_PR = dynamic_cast<C_TF_PlayerResource *>( g_PR );
if ( !tf_PR )
return;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
int localteam = pLocalPlayer->GetTeamNumber();
bool bMadeSelection = false;
for( int playerIndex = 1 ; playerIndex <= MAX_PLAYERS; playerIndex++ )
{
if( g_PR->IsConnected( playerIndex ) )
{
SectionedListPanel *pPlayerList = NULL;
switch ( g_PR->GetTeam( playerIndex ) )
{
case TF_TEAM_RED:
pPlayerList = m_pPlayerListRed;
break;
}
if ( null == pPlayerList )
continue;
const char *szName = tf_PR->GetPlayerName(playerIndex);
int score = tf_PR->GetTotalScore(playerIndex);
int kills = tf_PR->GetPlayerScore(playerIndex);
int deaths = tf_PR->GetDeaths(playerIndex);
int streak = tf_PR->GetKillstreak(playerIndex);
KeyValues *pKeyValues = new KeyValues( "data" );
pKeyValues->SetInt( "playerIndex", playerIndex );
pKeyValues->SetString( "name", szName );
pKeyValues->SetInt("score", score);
pKeyValues->SetInt("kills", kills);
pKeyValues->SetInt("deaths", deaths);
pKeyValues->SetInt("streak", streak);
// can only see class information if we're on the same team
if ( !AreEnemyTeams( g_PR->GetTeam( playerIndex ), localteam ) && !( localteam == TEAM_UNASSIGNED ) )
{
// class name
if( g_PR->IsConnected( playerIndex ) )
{
int iClass = tf_PR->GetPlayerClass( playerIndex );
if ( GetLocalPlayerIndex() == playerIndex && !tf_PR->IsAlive( playerIndex ) )
{
// If this is local player and he is dead, show desired class (which he will spawn as) rather than current class.
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
int iDesiredClass = pPlayer->m_Shared.GetDesiredPlayerClassIndex();
// use desired class unless it's random -- if random, his future class is not decided until moment of spawn
if ( TF_CLASS_RANDOM != iDesiredClass )
{
iClass = iDesiredClass;
}
}
else
{
// for non-local players, show the current class
iClass = tf_PR->GetPlayerClass( playerIndex );
}
}
}
else
{
C_TFPlayer *pPlayerOther = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
if ( pPlayerOther && pPlayerOther->m_Shared.IsPlayerDominated( pLocalPlayer->entindex() ) )
{
// if local player is dominated by this player, show a nemesis icon
pKeyValues->SetInt( "nemesis", m_iImageNemesis );
}
else if ( pLocalPlayer->m_Shared.IsPlayerDominated( playerIndex) )
{
// if this player is dominated by the local player, show the domination icon
pKeyValues->SetInt( "nemesis", m_iImageDominated );
}
}
// display whether player is alive or dead (all players see this for all other players on both teams)
pKeyValues->SetInt( "status", tf_PR->IsAlive( playerIndex ) ? 0 : m_iImageDead );
if ( g_PR->GetPing( playerIndex ) < 1 )
{
if ( g_PR->IsFakePlayer( playerIndex ) )
{
pKeyValues->SetString( "ping", "#TF_Scoreboard_Bot" );
}
else
{
pKeyValues->SetString( "ping", "" );
}
}
else
{
pKeyValues->SetInt( "ping", g_PR->GetPing( playerIndex ) );
}
UpdatePlayerAvatar( playerIndex, pKeyValues );
int itemID = pPlayerList->AddItem( 0, pKeyValues );
Color clr = tf_PR->GetPlayerColor(playerIndex);
pPlayerList->SetItemFgColor( itemID, clr );
if ( iSelectedPlayerIndex == playerIndex )
{
bMadeSelection = true;
pPlayerList->SetSelectedItem( itemID );
}
pKeyValues->deleteThis();
}
}
// If we're on spectator, find a default selection
if ( !bMadeSelection )
{
if ( m_pPlayerListRed->GetItemCount() > 0 )
{
m_pPlayerListRed->SetSelectedItem( 0 );
}
}
ResizeScoreboard();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseObject::GetTargetIDString( wchar_t *sIDString, int iMaxLenInBytes )
{
sIDString[0] = '\0';
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
if ( InSameTeam( pLocalPlayer ) || pLocalPlayer->IsPlayerClass( TF_CLASS_SPY ) || pLocalPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
wchar_t wszBuilderName[ MAX_PLAYER_NAME_LENGTH ];
const char *pszStatusName = GetStatusName();
wchar_t *wszObjectName = g_pVGuiLocalize->Find( pszStatusName );
if ( !wszObjectName )
{
wszObjectName = L"";
}
C_BasePlayer *pBuilder = GetOwner();
if ( pBuilder )
{
g_pVGuiLocalize->ConvertANSIToUnicode( pBuilder->GetPlayerName(), wszBuilderName, sizeof(wszBuilderName) );
}
else
{
wszBuilderName[0] = '\0';
}
// building or live, show health
const char *printFormatString;
if ( GetObjectInfo(GetType())->m_AltModes.Count() > 0 )
{
printFormatString = "#TF_playerid_object_mode";
pszStatusName = GetObjectInfo( GetType() )->m_AltModes.Element( m_iObjectMode * 3 + 1 );
wchar_t *wszObjectModeName = g_pVGuiLocalize->Find( pszStatusName );
if ( !wszObjectModeName )
{
wszObjectModeName = L"";
}
g_pVGuiLocalize->ConstructString( sIDString, iMaxLenInBytes, g_pVGuiLocalize->Find(printFormatString),
4,
wszObjectName,
wszBuilderName,
wszObjectModeName);
}
else
{
if ( m_bMiniBuilding )
printFormatString = "#TF_playerid_object_mini";
else
printFormatString = "#TF_playerid_object";
g_pVGuiLocalize->ConstructString( sIDString, iMaxLenInBytes, g_pVGuiLocalize->Find( printFormatString ),
3,
wszObjectName,
wszBuilderName );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTargetID::ShouldDraw( void )
{
if ( !CHudElement::ShouldDraw() )
return false;
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalTFPlayer )
return false;
// Get our target's ent index
m_iTargetEntIndex = CalculateTargetIndex(pLocalTFPlayer);
if ( !m_iTargetEntIndex )
{
// 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;
}
}
else
{
m_flLastChangeTime = gpGlobals->curtime;
}
bool bReturn = false;
if ( m_iTargetEntIndex )
{
C_BaseEntity *pEnt = cl_entitylist->GetEnt( m_iTargetEntIndex );
if ( pEnt )
{
if ( IsPlayerIndex( m_iTargetEntIndex ) )
{
C_TFPlayer *pPlayer = static_cast<C_TFPlayer*>( pEnt );
bool bDisguisedEnemy = false;
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
{
bDisguisedEnemy = (ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() ) != NULL);
}
bReturn = (pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR ||
pLocalTFPlayer->InSameTeam(pEnt) ||
(bDisguisedEnemy && pPlayer->m_Shared.GetDisguiseTeam() == pLocalTFPlayer->GetTeamNumber()) ||
(pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) && !pPlayer->m_Shared.InCond( TF_COND_STEALTHED )) );
}
else if ( pEnt->IsBaseObject() && (pLocalTFPlayer->InSameTeam( pEnt ) || pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) || pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR) )
{
bReturn = true;
}
else if ( pEnt->IsNPC() )
{
bReturn = ( pLocalTFPlayer->GetTeamNumber() == TEAM_SPECTATOR || pLocalTFPlayer->InSameTeam( pEnt ) || pLocalTFPlayer->IsPlayerClass( TF_CLASS_SPY ) );
}
}
}
if ( bReturn )
{
if ( !IsVisible() || (m_iTargetEntIndex != m_iLastEntIndex) )
{
m_iLastEntIndex = m_iTargetEntIndex;
m_bLayoutOnUpdate = true;
}
UpdateID();
}
return bReturn;
}
//-----------------------------------------------------------------------------
// 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 CTFHudFlagObjectives::UpdateStatus( void )
{
C_TFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
// are we carrying a flag?
CCaptureFlag *pPlayerFlag = NULL;
if ( pLocalPlayer && pLocalPlayer->HasItem() && ( pLocalPlayer->GetItem()->GetItemID() == TF_ITEM_CAPTURE_FLAG ) )
{
pPlayerFlag = dynamic_cast<CCaptureFlag*>( pLocalPlayer->GetItem() );
}
if ( pPlayerFlag )
{
m_bCarryingFlag = true;
// make sure the panels are on, set the initial alpha values,
// set the color of the flag we're carrying, and start the animations
if ( m_pCarriedImage && !m_bFlagAnimationPlayed )
{
m_bFlagAnimationPlayed = true;
// Set the correct flag image depending on the flag we're holding
switch (pPlayerFlag->GetTeamNumber())
{
case TF_TEAM_RED:
m_pCarriedImage->SetImage("../hud/objectives_flagpanel_carried_red");
break;
case TF_TEAM_BLUE:
m_pCarriedImage->SetImage("../hud/objectives_flagpanel_carried_blue");
break;
case TF_TEAM_GREEN:
m_pCarriedImage->SetImage("../hud/objectives_flagpanel_carried_green");
break;
case TF_TEAM_YELLOW:
m_pCarriedImage->SetImage("../hud/objectives_flagpanel_carried_yellow");
break;
}
if (m_pRedFlag && m_pRedFlag->IsVisible())
{
m_pRedFlag->SetVisible(false);
}
if ( m_pBlueFlag && m_pBlueFlag->IsVisible() )
{
m_pBlueFlag->SetVisible( false );
}
if (m_pGreenFlag && m_pGreenFlag->IsVisible())
{
m_pGreenFlag->SetVisible(false);
}
if (m_pYellowFlag && m_pYellowFlag->IsVisible())
{
m_pYellowFlag->SetVisible(false);
}
if ( !m_pCarriedImage->IsVisible() )
{
m_pCarriedImage->SetVisible( true );
}
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "FlagOutline" );
if ( m_pCapturePoint )
{
if ( !m_pCapturePoint->IsVisible() )
{
m_pCapturePoint->SetVisible( true );
}
if ( pLocalPlayer )
{
// go through all the capture zones and find ours
for ( int i = 0; i < g_CaptureZones.Count(); i++ )
{
C_BaseEntity *pZone = ClientEntityList().GetEnt( g_CaptureZones[i] );
if ( pZone )
{
if ( pZone->GetTeamNumber() == pLocalPlayer->GetTeamNumber() )
{
m_pCapturePoint->SetEntity( pZone );
}
}
}
}
}
}
}
else
{
// were we carrying the flag?
if ( m_bCarryingFlag )
{
m_bCarryingFlag = false;
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "FlagOutline" );
}
m_bFlagAnimationPlayed = false;
if ( m_pCarriedImage && m_pCarriedImage->IsVisible() )
{
m_pCarriedImage->SetVisible( false );
}
if ( m_pCapturePoint && m_pCapturePoint->IsVisible() )
{
m_pCapturePoint->SetVisible( false );
}
if ( m_pBlueFlag )
{
if ( !m_pBlueFlag->IsVisible() )
{
m_pBlueFlag->SetVisible( true );
}
m_pBlueFlag->UpdateStatus();
}
if ( m_pRedFlag )
{
if ( !m_pRedFlag->IsVisible() )
{
m_pRedFlag->SetVisible( true );
}
m_pRedFlag->UpdateStatus();
}
if (m_pGreenFlag)
{
if (!m_pGreenFlag->IsVisible())
{
m_pGreenFlag->SetVisible(true);
}
m_pGreenFlag->UpdateStatus();
}
if (m_pYellowFlag)
{
if (!m_pYellowFlag->IsVisible())
{
m_pYellowFlag->SetVisible(true);
}
m_pYellowFlag->UpdateStatus();
}
}
}
//-----------------------------------------------------------------------------
// Frame-based update
//-----------------------------------------------------------------------------
void CTFFourTeamMenu::OnTick()
{
if (TFGameRules() && !TFGameRules()->IsFourTeamGame())
return; // How did you even get here?
// update the number of players on each team
C_Team *pRed = GetGlobalTeam(TF_TEAM_RED);
C_Team *pBlue = GetGlobalTeam(TF_TEAM_BLUE);
C_Team *pGreen = GetGlobalTeam(TF_TEAM_GREEN);
C_Team *pYellow = GetGlobalTeam(TF_TEAM_YELLOW);
if (!pRed || !pBlue || !pGreen || !pYellow)
return;
// set our team counts
SetDialogVariable("redcount", pRed->Get_Number_Players());
SetDialogVariable("bluecount", pBlue->Get_Number_Players());
SetDialogVariable("greencount", pGreen->Get_Number_Players());
SetDialogVariable("yellowcount", pYellow->Get_Number_Players());
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if (!pLocalPlayer)
return;
CTFGameRules *pRules = TFGameRules();
if (!pRules)
return;
// check if teams are unbalanced
m_bRedDisabled = m_bBlueDisabled = false;
int iHeavyTeam, iLightTeam;
bool bUnbalanced = pRules->AreTeamsUnbalanced(iHeavyTeam, iLightTeam);
int iCurrentTeam = pLocalPlayer->GetTeamNumber();
if ((bUnbalanced && iHeavyTeam == TF_TEAM_RED) || (pRules->WouldChangeUnbalanceTeams(TF_TEAM_RED, iCurrentTeam)))
{
m_bRedDisabled = true;
}
if ((bUnbalanced && iHeavyTeam == TF_TEAM_BLUE) || (pRules->WouldChangeUnbalanceTeams(TF_TEAM_BLUE, iCurrentTeam)))
{
m_bBlueDisabled = true;
}
if (m_pSpecTeamButton && m_pSpecLabel)
{
ConVarRef mp_allowspectators("mp_allowspectators");
if (mp_allowspectators.IsValid())
{
if (mp_allowspectators.GetBool())
{
if (!m_pSpecTeamButton->IsVisible())
{
m_pSpecTeamButton->SetVisible(true);
m_pSpecLabel->SetVisible(true);
}
}
else
{
if (m_pSpecTeamButton->IsVisible())
{
m_pSpecTeamButton->SetVisible(false);
m_pSpecLabel->SetVisible(false);
}
}
}
}
}