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.
 
 
 
 
 
 

659 lines
22 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_hud_arena_winpanel.h"
#include "tf_hud_statpanel.h"
#include "tf_spectatorgui.h"
#include "vgui_controls/AnimationController.h"
#include "iclientmode.h"
#include "engine/IEngineSound.h"
#include "c_tf_playerresource.h"
#include "c_tf_team.h"
#include "tf_clientscoreboard.h"
#include <vgui_controls/Label.h>
#include <vgui_controls/ImagePanel.h>
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include "vgui_avatarimage.h"
#include "fmtstr.h"
#include "teamplayroundbased_gamerules.h"
#include "tf_gamerules.h"
#include "tf_hud_menu_taunt_selection.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ConVar tf_arena_max_streak;
extern ConVar mp_bonusroundtime;
extern const char *FormatSeconds( int seconds );
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFArenaWinPanel::CTFArenaWinPanel( IViewPort *pViewPort ) : EditablePanel( NULL, "ArenaWinPanel" )
{
SetAlpha( 0 );
SetScheme( "ClientScheme" );
m_pTeamScorePanel = new EditablePanel( this, "ArenaWinPanelScores" );
m_pWinnerPanel = new EditablePanel( this, "ArenaWinPanelWinnersPanel" );
m_pLoserPanel = new EditablePanel( this, "ArenaWinPanelLosersPanel" );
m_flTimeUpdateTeamScore = 0;
m_flFlipScoresTimes = 0;
m_iBlueTeamScore = 0;
m_iRedTeamScore = 0;
ListenForGameEvent( "arena_win_panel" );
ListenForGameEvent( "teamplay_round_start" );
ListenForGameEvent( "teamplay_game_over" );
ListenForGameEvent( "tf_game_over" );
m_bShouldBeVisible = false;
vgui::ivgui()->AddTickSignal( GetVPanel(), 50 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::Reset( void )
{
Update();
m_bShouldBeVisible = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::Update( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::SetVisible( bool state )
{
if ( state == IsVisible() )
return;
int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "mid" );
if ( state )
{
gHUD.LockRenderGroup( iRenderGroup );
}
else
{
gHUD.UnlockRenderGroup( iRenderGroup );
}
BaseClass::SetVisible( state );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::FireGameEvent( IGameEvent * event )
{
const char *pEventName = event->GetName();
if ( Q_strcmp( "teamplay_round_start", pEventName ) == 0 )
{
m_bShouldBeVisible = false;
}
else if ( Q_strcmp( "teamplay_game_over", pEventName ) == 0 )
{
m_bShouldBeVisible = false;
}
else if ( Q_strcmp( "tf_game_over", pEventName ) == 0 )
{
m_bShouldBeVisible = false;
}
else if ( Q_strcmp( "arena_win_panel", pEventName ) == 0 )
{
if ( !g_PR )
return;
m_vecPlayerScore.RemoveAll();
InvalidateLayout( false, true );
if ( TFGameRules() && TFGameRules()->IsInArenaMode() == true && tf_arena_max_streak.GetInt() > 0 && tf_arena_use_queue.GetBool() == true )
{
m_pArenaStreakPanel->SetVisible( true );
m_pArenaStreakLabel->SetVisible( true );
wchar_t wzStreaNum[16];
wchar_t wzStreakString[256]=L"";
_snwprintf( wzStreaNum, ARRAYSIZE( wzStreaNum ), L"%i", tf_arena_max_streak.GetInt() );
g_pVGuiLocalize->ConstructString_safe( wzStreakString, g_pVGuiLocalize->Find( "#TF_Arena_PlayingTo" ), 1, wzStreaNum );
m_pTeamScorePanel->SetDialogVariable( "arenastreaktext", wzStreakString );
}
else
{
m_pArenaStreakPanel->SetVisible( false );
m_pArenaStreakLabel->SetVisible( false );
}
m_iWinningPlayerTeam = event->GetInt( "winning_team" );
int iWinReason = event->GetInt( "winreason" );
SetDialogVariable( "WinningTeamLabel", "" );
SetDialogVariable( "AdvancingTeamLabel", "" );
SetDialogVariable( "WinReasonLabel", "" );
SetDialogVariable( "DetailsLabel", "" );
vgui::ImagePanel *pImagePanelBG = dynamic_cast<vgui::ImagePanel *>( FindChildByName("WinPanelBG") );
Assert( pImagePanelBG );
if ( !pImagePanelBG )
return;
// set the appropriate background image and label text
const wchar_t *pTeamLabel = L"";
const wchar_t *pTopPlayersLabel = L"";
const wchar_t *pLocalizedTeamName = L"";
const wchar_t *pLocalizedLoserTeamName = L"";
C_TFTeam *pBlueTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
const wchar_t *pBlueTeamName = pBlueTeam ? pBlueTeam->Get_Localized_Name() : L"BLU";
C_TFTeam *pRedTeam = GetGlobalTFTeam( TF_TEAM_RED );
const wchar_t *pRedTeamName = pRedTeam ? pRedTeam->Get_Localized_Name() : L"RED";
switch ( m_iWinningPlayerTeam )
{
case TF_TEAM_BLUE:
pImagePanelBG->SetImage( "../hud/winpanel_blue_bg_main.vmt" );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_BlueMVPs" );
pLocalizedTeamName = pBlueTeamName;
pLocalizedLoserTeamName = pRedTeamName;
break;
case TF_TEAM_RED:
pImagePanelBG->SetImage( "../hud/winpanel_red_bg_main.vmt" );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_RedMVPs" );
pLocalizedTeamName = pRedTeamName;
pLocalizedLoserTeamName = pBlueTeamName;
break;
case TEAM_UNASSIGNED: // stalemate
pImagePanelBG->SetImage( "../hud/winpanel_black_bg_main.vmt" );
pTeamLabel = g_pVGuiLocalize->Find( "#Winpanel_Stalemate" );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_TopPlayers" );
break;
default:
Assert( false );
break;
}
SetDialogVariable( "TopPlayersLabel", pTopPlayersLabel );
wchar_t wzTeamWin[256] = L"";
if ( TFGameRules() && TFGameRules()->IsInTournamentMode() )
{
g_pVGuiLocalize->ConstructString_safe( wzTeamWin, g_pVGuiLocalize->Find( "#Winpanel_TournamentTeamWins" ), 1, pLocalizedTeamName );
g_pVGuiLocalize->ConstructString_safe( m_wzTeamLose, g_pVGuiLocalize->Find( "#Winpanel_TournamentTeamLost" ), 2, pLocalizedLoserTeamName );
wchar_t wzTeamMPVs[256];
g_pVGuiLocalize->ConstructString_safe( wzTeamMPVs, g_pVGuiLocalize->Find( "#Winpanel_TournamentMVPs" ), 1, pLocalizedTeamName );
if ( m_iWinningPlayerTeam != TEAM_UNASSIGNED )
{
SetDialogVariable( "TopPlayersLabel", wzTeamMPVs );
}
}
else if ( m_iWinningPlayerTeam != TEAM_UNASSIGNED )
{
g_pVGuiLocalize->ConstructString_safe( wzTeamWin, g_pVGuiLocalize->Find( "#Winpanel_TeamWins" ), 2, pLocalizedTeamName, g_pVGuiLocalize->Find( "#Winpanel_Team1" ) );
g_pVGuiLocalize->ConstructString_safe( m_wzTeamLose, g_pVGuiLocalize->Find( "#Winpanel_TeamLost" ), 2, pLocalizedLoserTeamName, g_pVGuiLocalize->Find( "#Winpanel_Team1" ) );
}
if ( m_iWinningPlayerTeam != TEAM_UNASSIGNED )
{
pTeamLabel = wzTeamWin;
}
SetDialogVariable( "WinningTeamLabel", pTeamLabel );
SetDialogVariable( "LosingTeamLabel", "" );
wchar_t wzWinReason[256] = L"";
switch ( iWinReason )
{
case WINREASON_ALL_POINTS_CAPTURED:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_AllPointsCaptured" ), 1, pLocalizedTeamName );
break;
case WINREASON_OPPONENTS_DEAD:
if ( TFGameRules() && TFGameRules()->IsInArenaMode() == true )
{
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_Arena" ), 1, pLocalizedTeamName );
}
else
{
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_OpponentsDead" ), 1, pLocalizedTeamName );
}
break;
case WINREASON_STALEMATE:
if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() )
{
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_Stalemate" ), 0 );
}
break;
default:
Assert( false );
break;
}
SetDialogVariable( "WinReasonLabel", wzWinReason );
m_bWasFlawlessVictory = IsFlawlessVictory();
if ( WINREASON_ALL_POINTS_CAPTURED == iWinReason )
{
// if this was a full round that ended with point capture or flag capture, show the winning cappers
const char *pCappers = event->GetString( "cappers" );
int iCappers = Q_strlen( pCappers );
if ( iCappers > 0 )
{
char szPlayerNames[256]="";
wchar_t wzPlayerNames[256]=L"";
wchar_t wzCapMsg[512]=L"";
for ( int i = 0; i < iCappers; i++ )
{
Q_strncat( szPlayerNames, g_PR->GetPlayerName( (int) pCappers[i] ), ARRAYSIZE( szPlayerNames ) );
if ( i < iCappers - 1 )
{
Q_strncat( szPlayerNames, ", ", ARRAYSIZE( szPlayerNames ) );
}
}
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerNames, wzPlayerNames, sizeof( wzPlayerNames ) );
g_pVGuiLocalize->ConstructString_safe( wzCapMsg, g_pVGuiLocalize->Find( "#Winpanel_WinningCapture" ), 1, wzPlayerNames );
SetDialogVariable( "DetailsLabel", wzCapMsg );
}
}
else if ( TFGameRules()->IsInArenaMode() == true && m_iWinningPlayerTeam != TEAM_UNASSIGNED )
{
if ( m_bWasFlawlessVictory )
{
SetDialogVariable( "DetailsLabel", g_pVGuiLocalize->Find( "#TF_Arena_FlawlessVictory" ) );
}
}
// get the current & previous team scores
int iBlueTeamPrevScore = event->GetInt( "blue_score_prev", 0 );
int iRedTeamPrevScore = event->GetInt( "red_score_prev", 0 );
m_iBlueTeamScore = event->GetInt( "blue_score", 0 );
m_iRedTeamScore = event->GetInt( "red_score", 0 );
if ( m_pTeamScorePanel )
{
m_pTeamScorePanel->SetDialogVariable( "blueteamname", pBlueTeamName );
m_pTeamScorePanel->SetDialogVariable( "redteamname", pRedTeamName );
// set the previous team scores in scoreboard
m_pTeamScorePanel->SetDialogVariable( "blueteamscore", iBlueTeamPrevScore );
m_pTeamScorePanel->SetDialogVariable( "redteamscore", iRedTeamPrevScore );
if ( ( m_iBlueTeamScore != iBlueTeamPrevScore ) || ( m_iRedTeamScore != iRedTeamPrevScore ) )
{
// if the new scores are different, set ourselves to update the scoreboard to the new values after a short delay, so players
// see the scores tick up
m_flTimeUpdateTeamScore = gpGlobals->curtime + 3.5f;
}
// only show team scores if round is complete
m_pTeamScorePanel->SetVisible( true );
}
if ( !g_TF_PR )
return;
int iPanelIndex = 0;
// look for the top 6 players sent in the event
for ( int i = 1; i <= 6; i++ )
{
iPanelIndex = (iPanelIndex % 3) + 1;
EditablePanel *pParentPanel = NULL;
if ( i <= 3 )
{
pParentPanel = m_pWinnerPanel;
}
else
{
pParentPanel = m_pLoserPanel;
}
vgui::Label *pPlayerName = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dName", iPanelIndex ) ) );
vgui::Label *pPlayerClass = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dClass", iPanelIndex ) ) );
vgui::Label *pPlayerDamage = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dDamage", iPanelIndex ) ) );
vgui::Label *pPlayerHealing = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dHealing", iPanelIndex ) ) );
vgui::Label *pPlayerLifetime = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dLifetime", iPanelIndex ) ) );
vgui::Label *pPlayerKills = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dKills", iPanelIndex ) ) );
CAvatarImagePanel *pPlayerAvatar = dynamic_cast<CAvatarImagePanel *>( pParentPanel->FindChildByName( CFmtStr( "Player%dAvatar", iPanelIndex) ) );
if ( !pPlayerName || !pPlayerClass || !pPlayerDamage || !pPlayerHealing || !pPlayerLifetime || !pPlayerKills || !pPlayerAvatar )
continue;
pPlayerName->SetText( "" );
pPlayerClass->SetText( "" );
pPlayerDamage->SetText( "" );
pPlayerHealing->SetText( "" );
pPlayerLifetime->SetText( "" );
pPlayerKills->SetText( "" );
pPlayerAvatar->SetPlayer( NULL );
char szPlayerIndexVal[64]="", szPlayerDamageVal[64]="", szPlayerHealingVal[64]="", szPlayerTimeAliveVal[64]="", szPlayerKillingBlowsVal[64]="";
// get player index and round points from the event
Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "player_%d", i );
Q_snprintf( szPlayerDamageVal, ARRAYSIZE( szPlayerDamageVal ), "player_%d_damage", i );
Q_snprintf( szPlayerHealingVal, ARRAYSIZE( szPlayerHealingVal ), "player_%d_healing", i );
Q_snprintf( szPlayerTimeAliveVal, ARRAYSIZE( szPlayerTimeAliveVal ), "player_%d_lifetime", i );
Q_snprintf( szPlayerKillingBlowsVal, ARRAYSIZE( szPlayerKillingBlowsVal ), "player_%d_kills", i );
int iPlayerIndex = event->GetInt( szPlayerIndexVal, 0 );
if ( iPlayerIndex == 0 )
continue;
if ( g_TF_PR->IsConnected( iPlayerIndex ) == false )
continue;
int iDamageDone = event->GetInt( szPlayerDamageVal, 0 );
int iHealingDone = event->GetInt( szPlayerHealingVal, 0 );
int iTimeAlive = event->GetInt( szPlayerTimeAliveVal, 0 );
int iKillingBlows = event->GetInt( szPlayerKillingBlowsVal, 0 );
PlayerArenaRoundScore_t &playerRoundScore = m_vecPlayerScore[m_vecPlayerScore.AddToTail()];
playerRoundScore.iPlayerIndex = iPlayerIndex;
playerRoundScore.iTotalDamage = iDamageDone;
playerRoundScore.iTotalHealing = iHealingDone;
playerRoundScore.iTimeAlive = iTimeAlive;
playerRoundScore.iKillingBlows = iKillingBlows;
}
m_bShouldBeVisible = true;
SetupPlayerStats();
MoveToFront();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFArenaWinPanel::IsFlawlessVictory( void )
{
C_TFTeam *pTeam = GetGlobalTFTeam( m_iWinningPlayerTeam );
bool bAllAlive = true;
if ( pTeam && g_TF_PR )
{
if ( pTeam->GetNumPlayers() == 1 )
return false;
if ( g_TF_PR->GetNumPlayersForTeam( m_iWinningPlayerTeam, true ) != pTeam->GetNumPlayers() )
{
bAllAlive = false;
}
}
return bAllAlive;
}
//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::SetupPlayerStats( void )
{
if ( !g_TF_PR )
return;
m_pWinnerPanel->SetVisible( true );
m_pLoserPanel->SetVisible( false );
m_flFlipScoresTimes = gpGlobals->curtime + ( ( TFGameRules() ? TFGameRules()->GetBonusRoundTime() : 5.0f ) * 0.5f );
int iWinnersAdded = 1;
int iLosersAdded = 1;
int iPlayerAdded = 0;
EditablePanel *pParentPanel = m_pWinnerPanel;
// look for the top 6 players sent in the event
for ( int i = 0; i < m_vecPlayerScore.Count(); i++ )
{
bool bShow = true;
int iPlayerIndex = m_vecPlayerScore[i].iPlayerIndex;
int iIndex = 0;
if ( m_iWinningPlayerTeam != TEAM_UNASSIGNED )
{
if ( m_iWinningPlayerTeam == g_TF_PR->GetTeam( iPlayerIndex ) )
{
pParentPanel = m_pWinnerPanel;
iIndex = iWinnersAdded;
iWinnersAdded++;
}
else
{
pParentPanel = m_pLoserPanel;
iIndex = iLosersAdded;
iLosersAdded++;
}
}
else
{
if ( i >= ( m_vecPlayerScore.Count() * 0.5f ) && pParentPanel != m_pLoserPanel )
{
iPlayerAdded = 0;
pParentPanel = m_pLoserPanel;
}
iIndex = (iPlayerAdded + 1) % 4;
iPlayerAdded++;
}
int iDamageDone = m_vecPlayerScore[i].iTotalDamage;
int iHealingDone = m_vecPlayerScore[i].iTotalHealing;
int iTimeAlive = m_vecPlayerScore[i].iTimeAlive;
int iKillingBlows = m_vecPlayerScore[i].iKillingBlows;
CAvatarImagePanel *pPlayerAvatar = dynamic_cast<CAvatarImagePanel *>( pParentPanel->FindChildByName( CFmtStr( "Player%dAvatar", iIndex) ) );
if ( pPlayerAvatar )
{
pPlayerAvatar->SetShouldScaleImage( true );
pPlayerAvatar->SetShouldDrawFriendIcon( false );
if ( bShow )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayerIndex );
pPlayerAvatar->SetPlayer( pPlayer );
}
pPlayerAvatar->SetVisible( bShow );
}
vgui::Label *pPlayerName = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dName", iIndex ) ) );
vgui::Label *pPlayerClass = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dClass", iIndex ) ) );
vgui::Label *pPlayerDamage = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dDamage", iIndex ) ) );
vgui::Label *pPlayerHealing = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dHealing", iIndex ) ) );
vgui::Label *pPlayerLifetime = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dLifetime", iIndex ) ) );
vgui::Label *pPlayerKills = dynamic_cast<Label *>( pParentPanel->FindChildByName( CFmtStr( "Player%dKills", iIndex ) ) );
if ( !pPlayerName || !pPlayerClass || !pPlayerDamage || !pPlayerHealing || !pPlayerLifetime || !pPlayerKills )
continue;
if ( bShow )
{
// set the player labels to team color
Color clr = g_TF_PR->GetTeamColor( g_TF_PR->GetTeam( iPlayerIndex ) );
pPlayerName->SetFgColor( clr );
pPlayerClass->SetFgColor( clr );
pPlayerDamage->SetFgColor( clr );
pPlayerHealing->SetFgColor( clr );
pPlayerLifetime->SetFgColor( clr );
pPlayerKills->SetFgColor( clr );
// set label contents
pPlayerName->SetText( g_TF_PR->GetPlayerName( iPlayerIndex ) );
pPlayerClass->SetText( g_aPlayerClassNames[g_TF_PR->GetPlayerClass( iPlayerIndex )] );
pPlayerDamage->SetText( CFmtStr( "%d", iDamageDone ) );
pPlayerHealing->SetText( CFmtStr( "%d", iHealingDone ) );
pPlayerLifetime->SetText( CFmtStr( "%s", FormatSeconds( iTimeAlive ) ) );
pPlayerKills->SetText( CFmtStr( "%d", iKillingBlows ) );
}
// show or hide labels for this player position
pPlayerName->SetVisible( bShow );
pPlayerClass->SetVisible( bShow );
pPlayerDamage->SetVisible( bShow );
pPlayerHealing->SetVisible( bShow );
pPlayerLifetime->SetVisible( bShow );
pPlayerKills->SetVisible( bShow );
}
}
//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "resource/UI/HudArenaWinPanel.res" );
m_pArenaStreakPanel = m_pTeamScorePanel->FindChildByName( "ArenaStreaksBG" );
m_pArenaStreakLabel = m_pTeamScorePanel->FindChildByName("ArenaStreakLabel" );
}
//-----------------------------------------------------------------------------
// Purpose: panel think method
//-----------------------------------------------------------------------------
void CTFArenaWinPanel::OnTick()
{
// if we've scheduled ourselves to update the team scores, handle it now
if ( m_flTimeUpdateTeamScore > 0 && ( gpGlobals->curtime > m_flTimeUpdateTeamScore ) && m_pTeamScorePanel )
{
// play a sound
CLocalPlayerFilter filter;
C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Hud.EndRoundScored" );
// update the team scores
m_pTeamScorePanel->SetDialogVariable( "blueteamscore", m_iBlueTeamScore );
m_pTeamScorePanel->SetDialogVariable( "redteamscore", m_iRedTeamScore );
m_flTimeUpdateTeamScore = 0;
}
if ( m_flFlipScoresTimes > 0 && ( gpGlobals->curtime > m_flFlipScoresTimes ) )
{
//flip the scores
m_pWinnerPanel->SetVisible( false );
m_pLoserPanel->SetVisible( true );
m_flFlipScoresTimes = 0;
if ( m_iWinningPlayerTeam != TEAM_UNASSIGNED )
{
const wchar_t *pTopPlayersLabel = NULL;
vgui::ImagePanel *pImagePanelBG = dynamic_cast<vgui::ImagePanel *>( FindChildByName("WinPanelBG") );
if ( pImagePanelBG == NULL )
return;
switch ( m_iWinningPlayerTeam )
{
case TF_TEAM_BLUE:
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_RedMVPs" );
pImagePanelBG->SetImage( "../hud/winpanel_red_bg_main.vmt" );
break;
case TF_TEAM_RED:
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_BlueMVPs" );
pImagePanelBG->SetImage( "../hud/winpanel_blue_bg_main.vmt" );
break;
default:
Assert( false );
break;
}
SetDialogVariable( "TopPlayersLabel", pTopPlayersLabel );
SetDialogVariable( "LosingTeamLabel", m_wzTeamLose );
SetDialogVariable( "WinningTeamLabel", "" );
if ( m_bWasFlawlessVictory )
{
CLocalPlayerFilter filter;
if ( m_iWinningPlayerTeam == GetLocalPlayerTeam() )
{
C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Announcer.AM_FlawlessVictoryRandom" );
}
else if ( GetLocalPlayerTeam() == TEAM_SPECTATOR )
{
C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Announcer.AM_FlawlessVictory01" );
}
else
{
C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Announcer.AM_FlawlessDefeatRandom" );
}
}
}
}
if ( m_bShouldBeVisible == true )
{
IViewPortPanel *scoreboard = gViewPortInterface->FindPanelByName( PANEL_SCOREBOARD );
if ( ( scoreboard && scoreboard->IsVisible() ) || IsInFreezeCam() )
{
SetVisible( false );
return;
}
CHudMenuTauntSelection *pMenuTauntSelection = ( CHudMenuTauntSelection * )GET_HUDELEMENT( CHudMenuTauntSelection );
if ( pMenuTauntSelection && pMenuTauntSelection->IsVisible() )
{
SetVisible( false );
return;
}
if ( TFGameRules() && TFGameRules()->State_Get() != GR_STATE_TEAM_WIN )
{
m_bShouldBeVisible = false;
}
}
SetVisible( m_bShouldBeVisible );
}