d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/tf/tf_hud_winpanel.cpp

739 lines
27 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_hud_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_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_logic_halloween_2014.h"
#include "c_tf_team.h"
#include "tf_badge_panel.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
DECLARE_HUDELEMENT_DEPTH( CTFWinPanel, 1 );
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFWinPanel::CTFWinPanel( const char *pElementName ) : EditablePanel( NULL, "WinPanel" ), CHudElement( pElementName )
{
vgui::Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
m_bShouldBeVisible = false;
SetAlpha( 0 );
SetScheme( "ClientScheme" );
m_pTeamScorePanel = new EditablePanel( this, "TeamScoresPanel" );
m_pRedTeamName = new CExLabel( m_pTeamScorePanel, "RedTeamLabel", "" );
m_pBlueTeamName = new CExLabel( m_pTeamScorePanel, "BlueTeamLabel", "" );
m_pRedLeaderAvatarImage = new CAvatarImagePanel( m_pTeamScorePanel, "RedLeaderAvatar" );
m_pBlueLeaderAvatarImage = new CAvatarImagePanel( m_pTeamScorePanel, "BlueLeaderAvatar" );
m_pRedLeaderAvatarBG = new EditablePanel( m_pTeamScorePanel, "RedLeaderAvatarBG" );
m_pBlueLeaderAvatarBG = new EditablePanel( m_pTeamScorePanel, "BlueLeaderAvatarBG" );
m_flTimeUpdateTeamScore = 0;
m_iBlueTeamScore = 0;
m_iRedTeamScore = 0;
RegisterForRenderGroup( "mid" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWinPanel::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWinPanel::Reset()
{
m_bShouldBeVisible = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWinPanel::Init()
{
// listen for events
ListenForGameEvent( "teamplay_win_panel" );
ListenForGameEvent( "teamplay_round_start" );
ListenForGameEvent( "teamplay_game_over" );
ListenForGameEvent( "tf_game_over" );
ListenForGameEvent( "training_complete" );
ListenForGameEvent( "show_match_summary" );
m_bShouldBeVisible = false;
CHudElement::Init();
}
void CTFWinPanel::SetVisible( bool state )
{
if ( state == IsVisible() )
return;
if ( state )
{
HideLowerPriorityHudElementsInGroup( "mid" );
}
else
{
UnhideLowerPriorityHudElementsInGroup( "mid" );
}
BaseClass::SetVisible( state );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWinPanel::FireGameEvent( IGameEvent * event )
{
const char *pEventName = event->GetName();
if ( FStrEq( "teamplay_round_start", pEventName ) ||
FStrEq( "teamplay_game_over", pEventName ) ||
FStrEq( "tf_game_over", pEventName ) ||
FStrEq( "training_complete", pEventName ) ||
FStrEq( "show_match_summary", pEventName ) )
{
m_bShouldBeVisible = false;
}
else if ( Q_strcmp( "teamplay_win_panel", pEventName ) == 0 )
{
if ( !g_PR )
return;
vgui::IScheme* pScheme = scheme()->GetIScheme( GetScheme() );
int iWinningTeam = event->GetInt( "winning_team" );
int iWinReason = event->GetInt( "winreason" );
int iFlagCapLimit = event->GetInt( "flagcaplimit" );
bool bRoundComplete = (bool) event->GetInt( "round_complete" );
int iRoundsRemaining = event->GetInt( "rounds_remaining" );
bool bGameOver = event->GetBool( "game_over", false );
bool bUseMoreOpaqueBorder = false;
if ( TFGameRules() && bGameOver )
{
if ( TFGameRules()->IsMatchTypeCompetitive() )
{
bUseMoreOpaqueBorder = true;
}
}
// non-final rounds of stopwatch mode should say something different
CTeamRoundTimer *pTimer = NULL;
if ( TFGameRules() && TFGameRules()->IsInTournamentMode() && TFGameRules()->IsInStopWatch() )
{
int iActiveTimer = ObjectiveResource()->GetStopWatchTimer();
pTimer = dynamic_cast< CTeamRoundTimer* >( ClientEntityList().GetEnt( iActiveTimer ) );
if ( pTimer )
{
if ( pTimer->IsWatchingTimeStamps() )
{
iWinningTeam = TEAM_INVALID;
iWinReason = bRoundComplete ? WINREASON_STOPWATCH_WATCHING_FINAL_ROUND : WINREASON_STOPWATCH_WATCHING_ROUNDS;
}
else
{
if ( !TFGameRules()->HaveStopWatchWinner() && !bRoundComplete )
{
iWinningTeam = TEAM_INVALID;
iWinReason = WINREASON_STOPWATCH_PLAYING_ROUNDS;
}
}
}
}
LoadControlSettings( "resource/UI/WinPanel.res" );
InvalidateLayout( false, true );
SetDialogVariable( "WinningTeamLabel", "" );
SetDialogVariable( "AdvancingTeamLabel", "" );
SetDialogVariable( "WinReasonLabel", "" );
SetDialogVariable( "DetailsLabel", "" );
EditablePanel *pBGPanel = dynamic_cast<EditablePanel *>( FindChildByName("WinPanelBGBorder") );
Assert( pBGPanel );
if ( !pBGPanel )
return;
EditablePanel *pBlueBGPanel = FindControl< EditablePanel >( "BlueScoreBG", true );
Assert( pBlueBGPanel );
EditablePanel *pRedBGPanel = FindControl< EditablePanel >( "RedScoreBG", true );
Assert( pRedBGPanel );
if( !pBlueBGPanel || !pRedBGPanel )
return;
pBlueBGPanel->SetBorder( pScheme->GetBorder( bUseMoreOpaqueBorder ? "TFFatLineBorderBlueBGMoreOpaque" : "TFFatLineBorderBlueBG" ) );
pRedBGPanel->SetBorder( pScheme->GetBorder( bUseMoreOpaqueBorder ? "TFFatLineBorderRedBGMoreOpaque" : "TFFatLineBorderRedBG" ) ) ;
// we want to suppress the winreason for sd_doomsday_event and plr_hightower_event
if ( TFGameRules() )
{
if ( ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) && CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() ) ||
( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) ) )
{
iWinReason = WINREASON_NONE;
}
}
// this is an area defense, but not a round win, if this was a successful defend until time limit but not a complete round
bool bIsAreaDefense = ( ( WINREASON_DEFEND_UNTIL_TIME_LIMIT == iWinReason ) && !bRoundComplete );
// set the appropriate background image and label text
const wchar_t *pTeamLabel = L"";
const wchar_t *pTopPlayersLabel = L"";
const wchar_t *pLocalizedTeamName = L"";
const char *pWinTeamLabel = ( bRoundComplete ? "#Winpanel_TeamWins" : ( bIsAreaDefense ? "#Winpanel_TeamDefends" : "#Winpanel_TeamAdvances" ) );
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";
if ( TFGameRules() && TFGameRules()->IsInTournamentMode() )
{
pWinTeamLabel = ( bRoundComplete ? "#Winpanel_TournamentTeamWins" : ( bIsAreaDefense ? "#Winpanel_TournamentTeamDefends" : "#Winpanel_TournamentTeamAdvances" ) );
}
wchar_t wzTeamWin[256] = L"";
switch ( iWinningTeam )
{
case TF_TEAM_BLUE:
pBGPanel->SetBorder( pScheme->GetBorder( bUseMoreOpaqueBorder ? "TFFatLineBorderBlueBGMoreOpaque" : "TFFatLineBorderBlueBG" ) );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_BlueMVPs" );
pLocalizedTeamName = pBlueTeamName;
g_pVGuiLocalize->ConstructString_safe( wzTeamWin, g_pVGuiLocalize->Find( pWinTeamLabel ), 2, pLocalizedTeamName, g_pVGuiLocalize->Find( "#Winpanel_Team1" ) );
pTeamLabel = wzTeamWin;
break;
case TF_TEAM_RED:
pBGPanel->SetBorder( pScheme->GetBorder( bUseMoreOpaqueBorder ? "TFFatLineBorderRedBGMoreOpaque" : "TFFatLineBorderRedBG" ) );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_RedMVPs" );
pLocalizedTeamName = pRedTeamName;
break;
case TEAM_UNASSIGNED: // stalemate
pBGPanel->SetBorder( pScheme->GetBorder( "TFFatLineBorder" ) );
pTeamLabel = g_pVGuiLocalize->Find( "#Winpanel_Stalemate" );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_TopPlayers" );
break;
case TEAM_INVALID: // used for stopwatch mode when it's not the final victory yet
pBGPanel->SetBorder( pScheme->GetBorder( "TFFatLineBorder" ) );
pTopPlayersLabel = g_pVGuiLocalize->Find( "#Winpanel_TopPlayers" );
pTeamLabel = L"";
if ( pBlueTeam && pBlueTeamName && pRedTeamName )
{
if ( bRoundComplete )
{
pTeamLabel = g_pVGuiLocalize->Find( "#WinPanel_StopWatch_Watching_RoundFinal" );
}
else
{
bool bBlueAttackers = ( pBlueTeam->GetRole() == TEAM_ROLE_ATTACKERS );
g_pVGuiLocalize->ConstructString_safe( wzTeamWin,
g_pVGuiLocalize->Find( "#WinPanel_StopWatch_Round_Complete" ),
1,
bBlueAttackers ? pBlueTeamName : pRedTeamName );
pTeamLabel = wzTeamWin;
}
}
break;
default:
Assert( false );
break;
}
SetDialogVariable( "TopPlayersLabel", pTopPlayersLabel );
if ( TFGameRules() && TFGameRules()->IsInTournamentMode() && !TFGameRules()->IsInStopWatch() )
{
g_pVGuiLocalize->ConstructString_safe( wzTeamWin, g_pVGuiLocalize->Find( pWinTeamLabel ), 1, pLocalizedTeamName );
wchar_t wzTeamMPVs[256];
g_pVGuiLocalize->ConstructString_safe( wzTeamMPVs, g_pVGuiLocalize->Find( "#Winpanel_TournamentMVPs" ), 1, pLocalizedTeamName );
if ( iWinningTeam != TEAM_UNASSIGNED )
{
SetDialogVariable( "TopPlayersLabel", wzTeamMPVs );
}
}
else if ( ( iWinningTeam != TEAM_UNASSIGNED ) && ( iWinningTeam != TEAM_INVALID ) )
{
g_pVGuiLocalize->ConstructString_safe( wzTeamWin, g_pVGuiLocalize->Find( pWinTeamLabel ), 2, pLocalizedTeamName, g_pVGuiLocalize->Find( "#Winpanel_Team1" ) );
}
if ( ( iWinningTeam != TEAM_UNASSIGNED ) && ( iWinningTeam != TEAM_INVALID ) )
{
pTeamLabel = wzTeamWin;
}
SetDialogVariable( bRoundComplete ? "WinningTeamLabel" : "AdvancingTeamLabel", pTeamLabel );
wchar_t wzWinReason[256] = L"";
switch ( iWinReason )
{
case WINREASON_ALL_POINTS_CAPTURED:
{
if ( TFGameRules() && ( TFGameRules()->GetGameType() == TF_GAMETYPE_ESCORT ) && ( TFGameRules()->HasMultipleTrains() == true ) && ( iRoundsRemaining == 0 ) )
{
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_PayloadRace" ), 1, pLocalizedTeamName );
}
else
{
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_AllPointsCaptured" ), 1, pLocalizedTeamName );
}
}
break;
case WINREASON_FLAG_CAPTURE_LIMIT:
{
wchar_t wzFlagCaptureLimit[16];
_snwprintf( wzFlagCaptureLimit, ARRAYSIZE( wzFlagCaptureLimit), L"%i", iFlagCapLimit );
const wchar_t *wpszFormatString = NULL;
if ( iFlagCapLimit == 1 )
{
wpszFormatString = g_pVGuiLocalize->Find( "#Winreason_FlagCaptureLimit_One" );
}
if ( !wpszFormatString )
{
wpszFormatString = g_pVGuiLocalize->Find( "#Winreason_FlagCaptureLimit" );
}
g_pVGuiLocalize->ConstructString_safe( wzWinReason, wpszFormatString, 2,
pLocalizedTeamName, wzFlagCaptureLimit );
}
break;
case WINREASON_OPPONENTS_DEAD:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_OpponentsDead" ), 1, pLocalizedTeamName );
break;
case WINREASON_DEFEND_UNTIL_TIME_LIMIT:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_DefendedUntilTimeLimit" ), 1, pLocalizedTeamName );
break;
case WINREASON_STALEMATE:
if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() )
{
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_Stalemate" ), 0 );
}
break;
case WINREASON_TIMELIMIT:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_TimeLimit" ), 1, pLocalizedTeamName );
break;
case WINREASON_WINLIMIT:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_WinLimit" ), 1, pLocalizedTeamName );
break;
case WINREASON_WINDIFFLIMIT:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_WinDiffLimit" ), 1, pLocalizedTeamName );
break;
case WINREASON_RD_REACTOR_CAPTURED:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_ReactorCaptured" ), 1, pLocalizedTeamName );
break;
case WINREASON_RD_CORES_COLLECTED:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_CoresCollected" ), 1, pLocalizedTeamName );
break;
case WINREASON_RD_REACTOR_RETURNED:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_ReactorReturned" ), 1, pLocalizedTeamName );
break;
case WINREASON_PD_POINTS:
g_pVGuiLocalize->ConstructString_safe( wzWinReason, g_pVGuiLocalize->Find( "#Winreason_PlayerDestructionPoints" ), 1, pLocalizedTeamName );
break;
case WINREASON_SCORED:
{
wchar_t wzScoreLimit[16];
_snwprintf( wzScoreLimit, ARRAYSIZE( wzScoreLimit ), L"%i", iFlagCapLimit );
const wchar_t *wpszFormatString = NULL;
if ( iFlagCapLimit == 1 )
{
wpszFormatString = g_pVGuiLocalize->Find( "#Winreason_ScoreLimit_One" );
}
if ( !wpszFormatString )
{
wpszFormatString = g_pVGuiLocalize->Find( "#Winreason_ScoreLimit" );
}
g_pVGuiLocalize->ConstructString_safe( wzWinReason, wpszFormatString, 2,
pLocalizedTeamName, wzScoreLimit );
}
break;
case WINREASON_STOPWATCH_WATCHING_ROUNDS:
if ( pBlueTeam && pBlueTeamName && pRedTeamName )
{
bool bBlueAttackers = ( pBlueTeam->GetRole() == TEAM_ROLE_ATTACKERS );
g_pVGuiLocalize->ConstructString_safe( wzWinReason,
g_pVGuiLocalize->Find( "#Winreason_Stopwatch_Watching_Rounds" ),
2,
bBlueAttackers ? pBlueTeamName : pRedTeamName,
bBlueAttackers ? pRedTeamName : pBlueTeamName );
}
break;
case WINREASON_STOPWATCH_WATCHING_FINAL_ROUND:
if ( pBlueTeam && pBlueTeamName && pRedTeamName )
{
bool bBlueAttackers = ( pBlueTeam->GetRole() == TEAM_ROLE_ATTACKERS );
g_pVGuiLocalize->ConstructString_safe( wzWinReason,
g_pVGuiLocalize->Find( "#Winreason_Stopwatch_SwitchSides" ),
2,
bBlueAttackers ? pRedTeamName : pBlueTeamName,
bBlueAttackers ? pBlueTeamName : pRedTeamName );
}
break;
case WINREASON_STOPWATCH_PLAYING_ROUNDS:
if ( pBlueTeam && pBlueTeamName && pRedTeamName )
{
bool bBlueAttackers = ( pBlueTeam->GetRole() == TEAM_ROLE_ATTACKERS );
g_pVGuiLocalize->ConstructString_safe( wzWinReason,
g_pVGuiLocalize->Find( "#Winreason_Stopwatch_Playing_Rounds" ),
2,
bBlueAttackers ? pBlueTeamName : pRedTeamName,
bBlueAttackers ? pRedTeamName : pBlueTeamName );
}
break;
default:
// This happens at the end of the Soldier training mission, FYI
Assert( false );
break;
}
SetDialogVariable( "WinReasonLabel", wzWinReason );
if ( !bRoundComplete && ( WINREASON_STALEMATE != iWinReason ) && ( WINREASON_STOPWATCH_WATCHING_ROUNDS != iWinReason ) && ( WINREASON_STOPWATCH_WATCHING_FINAL_ROUND != iWinReason ) && ( WINREASON_STOPWATCH_PLAYING_ROUNDS != iWinReason ) )
{
// if this was a mini-round, show # of capture points remaining
wchar_t wzNumCapturesRemaining[16];
wchar_t wzCapturesRemainingMsg[256]=L"";
_snwprintf( wzNumCapturesRemaining, ARRAYSIZE( wzNumCapturesRemaining ), L"%i", iRoundsRemaining );
g_pVGuiLocalize->ConstructString_safe( wzCapturesRemainingMsg,
g_pVGuiLocalize->Find( 1 == iRoundsRemaining ? "#Winpanel_CapturePointRemaining" : "Winpanel_CapturePointsRemaining" ),
1, wzNumCapturesRemaining );
SetDialogVariable( "DetailsLabel", wzCapturesRemainingMsg );
}
else if ( ( WINREASON_ALL_POINTS_CAPTURED == iWinReason ) || ( WINREASON_FLAG_CAPTURE_LIMIT == 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 );
}
}
// 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 );
if ( bRoundComplete )
{
// 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 + 2.0f;
}
}
// only show team scores if round is complete
m_pTeamScorePanel->SetVisible( bRoundComplete );
}
if ( !g_TF_PR )
return;
// look for the top 3 players sent in the event
for ( int i = 1; i <= 3; i++ )
{
bool bShow = false;
char szPlayerIndexVal[64]="", szPlayerScoreVal[64]="";
// get player index and round points from the event
Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "player_%d", i );
Q_snprintf( szPlayerScoreVal, ARRAYSIZE( szPlayerScoreVal ), "player_%d_points", i );
int iPlayerIndex = event->GetInt( szPlayerIndexVal, 0 );
int iRoundScore = event->GetInt( szPlayerScoreVal, 0 );
// round score of 0 means no player to show for that position (not enough players, or didn't score any points that round)
if ( iRoundScore > 0 )
bShow = true;
CAvatarImagePanel *pPlayerAvatar = dynamic_cast<CAvatarImagePanel *>( FindChildByName( CFmtStr( "Player%dAvatar", i ) ) );
if ( pPlayerAvatar )
{
pPlayerAvatar->SetShouldScaleImage( true );
pPlayerAvatar->SetShouldDrawFriendIcon( false );
if ( bShow )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayerIndex );
pPlayerAvatar->SetPlayer( pPlayer );
}
pPlayerAvatar->SetVisible( bShow );
}
CTFBadgePanel *pBadgePanel = dynamic_cast<CTFBadgePanel *>( FindChildByName( CFmtStr( "Player%dBadge", i ) ) );
if ( pBadgePanel )
{
const IMatchGroupDescription *pMatchDesc = TFGameRules() ? GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() ) : NULL;
const IProgressionDesc *pProgressionDesc = pMatchDesc ? pMatchDesc->m_pProgressionDesc : NULL;
bool bVisible = ( pMatchDesc && pProgressionDesc );
if ( bVisible )
{
if ( !bGameOver && TFGameRules()->IsMatchTypeCompetitive() )
{
bVisible = false;
}
}
if ( bVisible )
{
const CSteamID steamID = GetSteamIDForPlayerIndex( iPlayerIndex );
if ( steamID.IsValid() )
{
pBadgePanel->SetupBadge( pProgressionDesc, steamID );
}
else
{
bVisible = false;
}
}
if ( pBadgePanel->IsVisible() != bVisible )
{
pBadgePanel->SetVisible( bVisible );
}
}
vgui::Label *pPlayerName = dynamic_cast<Label *>( FindChildByName( CFmtStr( "Player%dName", i ) ) );
vgui::Label *pPlayerClass = dynamic_cast<Label *>( FindChildByName( CFmtStr( "Player%dClass", i ) ) );
vgui::Label *pPlayerScore = dynamic_cast<Label *>( FindChildByName( CFmtStr( "Player%dScore", i ) ) );
if ( !pPlayerName || !pPlayerClass || !pPlayerScore )
return;
if ( bShow )
{
// set the player labels to team color
Color clr = g_PR->GetTeamColor( g_PR->GetTeam( iPlayerIndex ) );
pPlayerName->SetFgColor( clr );
pPlayerClass->SetFgColor( clr );
pPlayerScore->SetFgColor( clr );
// set label contents
pPlayerName->SetText( g_PR->GetPlayerName( iPlayerIndex ) );
pPlayerClass->SetText( g_aPlayerClassNames[g_TF_PR->GetPlayerClass( iPlayerIndex )] );
pPlayerScore->SetText( CFmtStr( "%d", iRoundScore ) );
// send an achievement event
IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_mvp" );
if ( pEvent )
{
pEvent->SetInt( "player", iPlayerIndex );
gameeventmanager->FireEventClientSide( pEvent );
}
}
// show or hide labels for this player position
pPlayerName->SetVisible( bShow );
pPlayerClass->SetVisible( bShow );
pPlayerScore->SetVisible( bShow );
}
// Top killstreak
const int nMaxKillStreaks = 1;
for ( int i = 1; i <= nMaxKillStreaks; ++i )
{
char szPlayerIndexVal[64]="", szPlayerScoreVal[64]="";
Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "killstreak_player_%d", i );
Q_snprintf( szPlayerScoreVal, ARRAYSIZE( szPlayerScoreVal ), "killstreak_player_%d_count", i );
int iPlayerIndex = event->GetInt( szPlayerIndexVal, 0 );
int iCount = event->GetInt( szPlayerScoreVal, 0 );
vgui::Label *pKillStreakPlayerName = dynamic_cast<Label *>( FindChildByName( CFmtStr( "KillStreakPlayer%dName", i ) ) );
vgui::Label *pKillStreakPlayerClass = dynamic_cast<Label *>( FindChildByName( CFmtStr( "KillStreakPlayer%dClass", i ) ) );
vgui::Label *pKillStreakPlayerScore = dynamic_cast<Label *>( FindChildByName( CFmtStr( "KillStreakPlayer%dScore", i ) ) );
if ( !pKillStreakPlayerName || !pKillStreakPlayerClass || !pKillStreakPlayerScore )
continue;
bool bShow = iCount > 0;
if ( bShow )
{
CAvatarImagePanel *pPlayerAvatar = dynamic_cast<CAvatarImagePanel *>( FindChildByName( CFmtStr( "KillStreakPlayer%dAvatar", i ) ) );
if ( pPlayerAvatar )
{
pPlayerAvatar->SetShouldScaleImage( true );
pPlayerAvatar->SetShouldDrawFriendIcon( false );
CBasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayerIndex );
pPlayerAvatar->SetPlayer( pPlayer );
pPlayerAvatar->SetVisible( true );
}
// set the player labels to team color
Color clr = g_PR->GetTeamColor( g_PR->GetTeam( iPlayerIndex ) );
pKillStreakPlayerName->SetFgColor( clr );
pKillStreakPlayerClass->SetFgColor( clr );
pKillStreakPlayerScore->SetFgColor( clr );
// set label contents
pKillStreakPlayerName->SetText( g_PR->GetPlayerName( iPlayerIndex ) );
pKillStreakPlayerClass->SetText( g_aPlayerClassNames[g_TF_PR->GetPlayerClass( iPlayerIndex )] );
pKillStreakPlayerScore->SetText( CFmtStr( "%d", iCount ) );
}
CTFBadgePanel *pBadgePanel = dynamic_cast<CTFBadgePanel *>( FindChildByName( CFmtStr( "KillStreakPlayer%dBadge", i ) ) );
if ( pBadgePanel )
{
const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
const IProgressionDesc *pProgressionDesc = pMatchDesc ? pMatchDesc->m_pProgressionDesc : NULL;
bool bVisible = ( bShow && pMatchDesc && pProgressionDesc );
if ( bVisible )
{
const CSteamID steamID = GetSteamIDForPlayerIndex( iPlayerIndex );
if ( steamID.IsValid() )
{
pBadgePanel->SetupBadge( pProgressionDesc, steamID );
}
else
{
bVisible = false;
}
}
if ( pBadgePanel->IsVisible() != bVisible )
{
pBadgePanel->SetVisible( bVisible );
}
}
// show or hide labels for this player position
pKillStreakPlayerName->SetVisible( bShow );
pKillStreakPlayerClass->SetVisible( bShow );
pKillStreakPlayerScore->SetVisible( bShow );
}
UpdateTeamInfo();
m_bShouldBeVisible = true;
MoveToFront();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWinPanel::UpdateTeamInfo()
{
bool bShowAvatars = g_TF_PR && g_TF_PR->HasPremadeParties();
if ( bShowAvatars )
{
m_pRedLeaderAvatarImage->SetPlayer( GetSteamIDForPlayerIndex( g_TF_PR->GetPartyLeaderRedTeamIndex() ), k_EAvatarSize64x64 );
m_pRedLeaderAvatarImage->SetShouldDrawFriendIcon( false );
m_pBlueLeaderAvatarImage->SetPlayer( GetSteamIDForPlayerIndex( g_TF_PR->GetPartyLeaderBlueTeamIndex() ), k_EAvatarSize64x64 );
m_pBlueLeaderAvatarImage->SetShouldDrawFriendIcon( false );
}
m_pRedLeaderAvatarImage->SetVisible( bShowAvatars );
m_pRedLeaderAvatarBG->SetVisible( bShowAvatars );
m_pRedTeamName->SetVisible( !bShowAvatars );
m_pBlueLeaderAvatarImage->SetVisible( bShowAvatars );
m_pBlueLeaderAvatarBG->SetVisible( bShowAvatars );
m_pBlueTeamName->SetVisible( !bShowAvatars );
}
//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CTFWinPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
}
//-----------------------------------------------------------------------------
// Purpose: returns whether panel should be drawn
//-----------------------------------------------------------------------------
bool CTFWinPanel::ShouldDraw()
{
if ( !m_bShouldBeVisible )
return false;
return CHudElement::ShouldDraw();
}
//-----------------------------------------------------------------------------
// Purpose: panel think method
//-----------------------------------------------------------------------------
void CTFWinPanel::OnThink()
{
// if we've scheduled ourselves to update the team scores, handle it now
if ( m_flTimeUpdateTeamScore > 0 && ( gpGlobals->curtime > m_flTimeUpdateTeamScore ) && m_pTeamScorePanel )
{
IGameEvent *event = gameeventmanager->CreateEvent( "winpanel_show_scores" );
if ( event )
{
gameeventmanager->FireEventClientSide( event );
}
// play a sound
CLocalPlayerFilter filter;
C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Hud.EndRoundScored" );
// update the team scores
if ( m_pTeamScorePanel )
{
m_pTeamScorePanel->SetDialogVariable( "blueteamscore", m_iBlueTeamScore );
m_pTeamScorePanel->SetDialogVariable( "redteamscore", m_iRedTeamScore );
}
m_flTimeUpdateTeamScore = 0;
}
}