BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/client/tf/tf_hud_tournament.cpp

1567 lines
46 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "hud.h"
#include "hudelement.h"
#include "c_tf_player.h"
#include "iclientmode.h"
#include "ienginevgui.h"
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include <vgui/IVGui.h>
#include <vgui_controls/Label.h>
#include <vgui_controls/EditablePanel.h>
#include "tf_imagepanel.h"
#include "tf_gamerules.h"
#include "c_tf_team.h"
#include "vgui/tf_controls.h"
#include <vgui_controls/TextEntry.h>
#include "vgui_controls/AnimationController.h"
#include "hud_basechat.h"
#include "clientmode_shared.h"
#include "c_playerresource.h"
#include "c_tf_playerresource.h"
#include "tf_hud_objectivestatus.h"
#include "c_team_objectiveresource.h"
#include "c_tf_team.h"
#include "tf_clientscoreboard.h"
#include "tf_playerpanel.h"
#include "tf_hud_tournament.h"
#include "c_tf_objective_resource.h"
#include "tf_time_panel.h"
#include "tf_hud_match_status.h"
#include "tf_gc_client.h"
#include "tf_lobby_server.h"
#include "inputsystem/iinputsystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
void AddSubKeyNamed( KeyValues *pKeys, const char *pszName );
using namespace vgui;
#define TOURNAMENT_PANEL_UPDATE_INTERVAL 0.25f
extern ConVar mp_timelimit;
extern ConVar mp_winlimit;
extern ConVar mp_maxrounds;
extern ConVar mp_tournament;
class CHudChat;
DECLARE_HUDELEMENT( CHudTournament );
static const wchar_t* GetSCGlyph( const char* action )
{
auto origin = g_pInputSystem->GetSteamControllerActionOrigin( action, GAME_ACTION_SET_FPSCONTROLS );
return g_pInputSystem->GetSteamControllerFontCharacterForActionOrigin( origin );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHudTournament::CHudTournament( const char *pElementName ) : CHudElement( pElementName ), BaseClass( NULL, "HudTournament" )
{
Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetHiddenBits( HIDEHUD_MISCSTATUS );
vgui::ivgui()->AddTickSignal( GetVPanel(), 50 );
for ( int i = 0; i < MAX_TEAMS; i++ )
{
m_bTeamReady[i] = false;
}
m_bReadyStatusMode = false;
m_bCompetitiveMode = false;
m_bReadyTextBlinking = false;
m_bCountDownVisible = false;
m_pPlayerPanelKVs = NULL;
m_bReapplyPlayerPanelKVs = false;
m_pScoreboard = NULL;
m_pCountdownBG = new vgui::ScalableImagePanel( this, "CountdownBG" );
m_pCountdownLabel = new CExLabel( this, "CountdownLabel", L"" );
m_pCountdownLabelShadow = new CExLabel( this, "CountdownLabelShadow", L"" );
m_pModeImage = new vgui::ImagePanel( this, "ModeImage" );
m_pHudTournamentBG = new vgui::ScalableImagePanel( this, "HudTournamentBG" );
m_pTournamentConditionLabel = new CExLabel( this, "TournamentConditionLabel", L"" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHudTournament::~CHudTournament()
{
if ( m_pPlayerPanelKVs )
{
m_pPlayerPanelKVs->deleteThis();
m_pPlayerPanelKVs = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::Init( void )
{
// listen for events
ListenForGameEvent( "tournament_stateupdate" );
ListenForGameEvent( "teams_changed" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "restart_timer_time" );
ListenForGameEvent( "competitive_victory" );
m_bShouldBeVisible = false;
SetVisible( false );
CHudElement::Init();
m_flNextUpdate = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::PlaySounds( int nTime )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
bool bCompetitiveMode = TFGameRules() && TFGameRules()->IsCompetitiveMode();
switch( nTime )
{
case 60:
{
if ( bCompetitiveMode )
{
pLocalPlayer->EmitSound( "Announcer.CompGame1Begins60Seconds" );
}
break;
}
case 30:
{
if ( bCompetitiveMode )
{
pLocalPlayer->EmitSound( "Announcer.CompGame1Begins30Seconds" );
}
break;
}
case 10:
{
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
if ( TFObjectiveResource()->GetMannVsMachineWaveCount() >= TFObjectiveResource()->GetMannVsMachineMaxWaveCount() )
{
pLocalPlayer->EmitSound( "Announcer.MVM_Final_Wave_Start" );
}
else if ( TFObjectiveResource()->GetMannVsMachineWaveCount() <= 1 )
{
if ( GTFGCClientSystem()->GetLobby() && IsMannUpGroup( GTFGCClientSystem()->GetLobby()->GetMatchGroup() ) )
{
pLocalPlayer->EmitSound( "Announcer.MVM_Manned_Up" );
}
else
{
pLocalPlayer->EmitSound( "Announcer.MVM_First_Wave_Start" );
}
}
else
{
pLocalPlayer->EmitSound( "Announcer.MVM_Wave_Start" );
}
}
else
{
pLocalPlayer->EmitSound( bCompetitiveMode ? "Announcer.CompGame1Begins10Seconds" : "Announcer.RoundBegins10Seconds" );
}
break;
}
case 9:
{
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
int nMaxWaves = TFObjectiveResource()->GetMannVsMachineMaxWaveCount();
int nCurWave = TFObjectiveResource()->GetMannVsMachineWaveCount();
bool bHasTank = false;
for ( int i = 0; i < MVM_CLASS_TYPES_PER_WAVE_MAX_NEW; ++i )
{
// int nClassCount = TFObjectiveResource()->GetMannVsMachineWaveClassCount( i );
const char *pchClassIconName = TFObjectiveResource()->GetMannVsMachineWaveClassName( i );
if( V_stristr( pchClassIconName, "tank" ))
{
bHasTank = true;
}
}
if( nCurWave == nMaxWaves )
{
pLocalPlayer->EmitSound( "music.mvm_start_last_wave" );
}
else if( bHasTank )
{
pLocalPlayer->EmitSound( "music.mvm_start_tank_wave" );
}
else if( nCurWave > ( nMaxWaves / 2 ) )
{
pLocalPlayer->EmitSound( "music.mvm_start_mid_wave" );
}
else
{
pLocalPlayer->EmitSound( "music.mvm_start_wave" );
}
}
break;
}
case 5:
{
pLocalPlayer->EmitSound( bCompetitiveMode ? "Announcer.CompGameBegins05Seconds" : "Announcer.RoundBegins5Seconds" );
break;
}
case 4:
{
pLocalPlayer->EmitSound( bCompetitiveMode ? "Announcer.CompGameBegins04Seconds" : "Announcer.RoundBegins4Seconds" );
break;
}
case 3:
{
pLocalPlayer->EmitSound( bCompetitiveMode ? "Announcer.CompGameBegins03Seconds" : "Announcer.RoundBegins3Seconds" );
break;
}
case 2:
{
pLocalPlayer->EmitSound( bCompetitiveMode ? "Announcer.CompGameBegins02Seconds" : "Announcer.RoundBegins2Seconds" );
break;
}
case 1:
{
pLocalPlayer->EmitSound( bCompetitiveMode ? "Announcer.CompGameBegins01Seconds" : "Announcer.RoundBegins1Seconds" );
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::PreparePanel( void )
{
if ( m_flNextUpdate > gpGlobals->curtime )
return;
if ( !TFGameRules() )
return;
bool bSteamController = ::input->IsSteamControllerActive();
bool bShowReadyHintIcon = false;
if ( TFGameRules()->IsInPreMatch() )
{
bool bCountdownVisible = false;
bool bAutoReady = false;
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
if ( pMatchDesc )
{
bAutoReady = pMatchDesc->m_params.m_bAutoReady;
}
if ( !bAutoReady && ( TFGameRules()->IsWaitingForTeams() || TFGameRules()->GetRoundRestartTime() < 0 ) )
{
if ( m_bReadyStatusMode )
{
const char *pszLabelText;
if ( TFGameRules() && TFGameRules()->PlayerReadyStatus_HaveMinPlayersToEnable() )
{
if ( bSteamController )
{
pszLabelText = "Tournament_Instructions_Ready_NoKeyHintText";
bShowReadyHintIcon = true;
}
else
{
pszLabelText = "Tournament_Instructions_Ready";
}
}
else
{
pszLabelText = "Tournament_Instructions_Waiting";
}
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( pszLabelText ) );
SetDialogVariable( "tournamentstatelabel", g_pVGuiLocalize->Find( "Tournament_WaitingForTeam" ) );
SetPlayerPanelsVisible( true );
m_pModeImage->SetVisible( m_bCompetitiveMode );
}
else
{
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( "Tournament_Instructions" ) );
SetDialogVariable( "tournamentstatelabel", g_pVGuiLocalize->Find( "Tournament_WaitingForTeams" ) );
SetPlayerPanelsVisible( false );
m_pModeImage->SetVisible( false );
}
}
else
{
float flTime = TFGameRules()->GetRoundRestartTime() - gpGlobals->curtime;
int nTime = (int)( ceil( flTime ) );
wchar szCountdown[64];
wchar_t wzVal[16];
const char *szCountDown = m_bReadyStatusMode ? "Tournament_CountDownTime" : "Tournament_Countdown";
const char *szCountDownSec = m_bReadyStatusMode ? "Tournament_CountDownTime" : "Tournament_Countdown_Sec";
swprintf( wzVal, ARRAYSIZE( wzVal ), L"%d", nTime );
wchar_t *pFormatString = g_pVGuiLocalize->Find( szCountDown );
if ( nTime == 1 )
{
pFormatString = g_pVGuiLocalize->Find( szCountDownSec );
}
if ( pFormatString )
{
g_pVGuiLocalize->ConstructString_safe( szCountdown, pFormatString, 1, wzVal );
SetDialogVariable( "tournamentstatelabel", szCountdown );
}
if ( bAutoReady )
{
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( "" ) );
m_pModeImage->SetVisible( false );
SetPlayerPanelsVisible( false );
}
else if ( nTime <= TOURNAMENT_NOCANCEL_TIME )
{
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( "" ) );
}
else
{
if ( m_bReadyStatusMode )
{
if ( bSteamController )
{
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( "Tournament_Instructions_Ready_NoKeyHintText" ) );
bShowReadyHintIcon = true;
}
else
{
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( "Tournament_Instructions_Ready" ) );
}
}
else
{
SetDialogVariable( "readylabel", g_pVGuiLocalize->Find( "" ) );
}
}
if ( m_bReadyStatusMode && nTime >= 0 )
{
bCountdownVisible = true;
}
}
// Show the Steam Controller hint icon if need be
auto pReadyHintIcon = dynamic_cast< CExLabel* >( FindChildByName( "TournamentReadyHintIcon" ) );
if ( pReadyHintIcon )
{
if ( bShowReadyHintIcon && !bAutoReady )
{
pReadyHintIcon->SetText( GetSCGlyph( "toggleready" ) );
pReadyHintIcon->SetVisible( true );
pReadyHintIcon->SetEnabled( true );
}
else
{
pReadyHintIcon->SetVisible( false );
pReadyHintIcon->SetEnabled( false );
}
}
if ( m_bCountDownVisible != bCountdownVisible )
{
m_bCountDownVisible = bCountdownVisible;
if ( m_bCountDownVisible )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(this, m_bCompetitiveMode ? "HudTournament_ShowTimerCompetitive" : "HudTournament_ShowTimerDefault", false);
}
else
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(this, "HudTournament_HideTimer", false);
}
}
}
#ifdef WIN32
#define STRING_FMT L"%s"
#else
#define STRING_FMT L"%S"
#endif
C_TFTeam *pBlueTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
SetDialogVariable( "bluenamelabel", pBlueTeam ? pBlueTeam->Get_Localized_Name() : L"BLU" );
C_TFTeam *pRedTeam = GetGlobalTFTeam( TF_TEAM_RED );
SetDialogVariable( "rednamelabel", pRedTeam ? pRedTeam->Get_Localized_Name() : L"RED" );
SetDialogVariable( "bluestate", TFGameRules()->IsTeamReady( TF_TEAM_BLUE ) ? g_pVGuiLocalize->Find( "Tournament_TeamReady" ) : g_pVGuiLocalize->Find( "Tournament_TeamNotReady" ) );
SetDialogVariable( "redstate", TFGameRules()->IsTeamReady( TF_TEAM_RED ) ? g_pVGuiLocalize->Find( "Tournament_TeamReady" ) : g_pVGuiLocalize->Find( "Tournament_TeamNotReady" ) );
if ( m_bTeamReady[TF_TEAM_BLUE] != TFGameRules()->IsTeamReady( TF_TEAM_BLUE ) || m_bTeamReady[TF_TEAM_RED] != TFGameRules()->IsTeamReady( TF_TEAM_RED ) )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
pLocalPlayer->EmitSound( "Hud.Hint" );
}
}
m_bTeamReady[TF_TEAM_BLUE] = TFGameRules()->IsTeamReady( TF_TEAM_BLUE );
m_bTeamReady[TF_TEAM_RED] = TFGameRules()->IsTeamReady( TF_TEAM_RED );
wchar_t szWindConditions[1024];
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), STRING_FMT, g_pVGuiLocalize->Find( "Tournament_WinConditions" ) );
if ( mp_timelimit.GetInt() > 0 || mp_winlimit.GetInt() > 0 || mp_maxrounds.GetInt() )
{
bool bPrev = false;
if ( mp_timelimit.GetInt() > 0 )
{
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), STRING_FMT L"%d " STRING_FMT, szWindConditions, mp_timelimit.GetInt(), mp_timelimit.GetInt() == 1 ? g_pVGuiLocalize->Find( "Tournament_WinConditionsMinute" ) : g_pVGuiLocalize->Find( "Tournament_WinConditionsMinutes" ) );
bPrev = true;
}
if ( mp_winlimit.GetInt() > 0 )
{
if ( bPrev )
{
#ifdef WIN32
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), L"%s, ", szWindConditions );
#else
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), L"%S, ", szWindConditions );
#endif
}
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), STRING_FMT L"%d " STRING_FMT, szWindConditions, mp_winlimit.GetInt(), mp_winlimit.GetInt() == 1 ? g_pVGuiLocalize->Find( "Tournament_WinConditionsWin" ) : g_pVGuiLocalize->Find( "Tournament_WinConditionsWins" ) );
bPrev = true;
}
if ( mp_maxrounds.GetInt() > 0 )
{
if ( bPrev )
{
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), STRING_FMT L", ", szWindConditions );
}
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), STRING_FMT L"%d " STRING_FMT, szWindConditions, mp_maxrounds.GetInt(), mp_maxrounds.GetInt() == 1 ? g_pVGuiLocalize->Find( "Tournament_WinConditionsRound" ) : g_pVGuiLocalize->Find( "Tournament_WinConditionsRounds" ) );
}
}
else
{
_snwprintf( szWindConditions, ARRAYSIZE( szWindConditions ), STRING_FMT STRING_FMT, szWindConditions, g_pVGuiLocalize->Find( "Tournament_WinConditionsNone" ) );
}
SetDialogVariable( "winconditions", szWindConditions );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::FireGameEvent( IGameEvent * event )
{
const char *pEventName = event->GetName();
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
if ( Q_strcmp( "tournament_stateupdate", pEventName ) == 0 )
{
if ( !g_TF_PR )
return;
if ( !pHUDChat )
return;
wchar_t wszLocalized[100];
bool bNameChange = event->GetBool( "namechange" );
int iTeamState = event->GetInt( "readystate", -1 );
int iIndex = event->GetInt("userid");
const char *pszName = g_TF_PR->GetPlayerName( iIndex );
wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( pszName, wszPlayerName, sizeof(wszPlayerName) );
if ( bNameChange )
{
wchar_t wszTeam[16];
g_pVGuiLocalize->ConvertANSIToUnicode( event->GetString( "newname" ), wszTeam, sizeof(wszTeam) );
g_pVGuiLocalize->ConstructString_safe( wszLocalized, g_pVGuiLocalize->Find( "#Tournament_TeamName_Change" ), 2, wszPlayerName, wszTeam );
}
else
{
g_pVGuiLocalize->ConstructString_safe( wszLocalized, g_pVGuiLocalize->Find( "#Tournament_ReadyState_Change" ), 2, wszPlayerName, iTeamState == 1 ? g_pVGuiLocalize->Find( "#Tournament_TeamReady" ) : g_pVGuiLocalize->Find( "#Tournament_TeamNotReady" ) );
}
char szLocalized[100];
g_pVGuiLocalize->ConvertUnicodeToANSI( wszLocalized, szLocalized, sizeof(szLocalized) );
pHUDChat->ChatPrintf( iIndex, CHAT_FILTER_NONE, "%s ", szLocalized );
}
else if ( Q_strcmp( "localplayer_respawn", pEventName ) == 0 )
{
if ( m_bReadyStatusMode )
{
if ( m_bReadyTextBlinking )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudReadyPulse" );
}
}
}
else if ( FStrEq( "restart_timer_time", pEventName ) )
{
PlaySounds( event->GetInt( "time" ) );
if ( TFGameRules()->GetRoundsPlayed() == 0 && m_bCompetitiveMode )
{
if ( event->GetInt( "time" ) == 10 )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudTournament_MoveTimerDown", false );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudTournament_MoveChatWindow", false );
}
}
}
else if ( FStrEq( "competitive_victory", pEventName ) )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudTournament_DoorsCloseEndRound", false );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CHudTournament::OnTick( void )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
if ( TFGameRules() )
{
if ( TFGameRules()->IsInTournamentMode() )
{
if ( TFGameRules()->IsInWaitingForPlayers() && TFGameRules()->State_Get() != GR_STATE_GAME_OVER )
{
m_bShouldBeVisible = true;
PreparePanel();
if ( !TFGameRules()->IsInArenaMode() )
{
if ( !pLocalPlayer->IsAlive() )
{
m_bShouldBeVisible = false;
}
}
}
else
{
m_bShouldBeVisible = false;
}
if ( TFGameRules()->UsePlayerReadyStatusMode() )
{
if ( !m_bReadyStatusMode )
{
m_bReadyStatusMode = true;
InvalidateLayout( false, true );
}
}
else if ( m_bReadyStatusMode )
{
m_bReadyStatusMode = false;
InvalidateLayout( false, true );
}
if ( TFGameRules()->IsCompetitiveMode() )
{
if ( !m_bCompetitiveMode )
{
m_bCompetitiveMode = true;
InvalidateLayout( false, true );
}
}
else if ( m_bCompetitiveMode )
{
m_bCompetitiveMode = false;
InvalidateLayout( false, true );
}
}
else
{
m_bShouldBeVisible = false;
}
if ( m_bReadyStatusMode )
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
if ( !pMatchDesc || !pMatchDesc->m_params.m_bAutoReady )
{
RecalculatePlayerPanels();
// Ready text animation
if ( !TFGameRules()->IsPlayerReady( GetLocalPlayerIndex() ) && !m_bReadyTextBlinking )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudReadyPulse" );
m_bReadyTextBlinking = true;
}
else if ( TFGameRules()->IsPlayerReady( GetLocalPlayerIndex() ) && m_bReadyTextBlinking )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudReadyPulseEnd" );
m_bReadyTextBlinking = false;
}
}
if ( !m_pScoreboard.Get() && gViewPortInterface )
{
m_pScoreboard = (CTFClientScoreBoardDialog *)( gViewPortInterface->FindPanelByName( PANEL_SCOREBOARD ) );
}
if ( m_pScoreboard.Get() && m_pScoreboard->IsVisible() )
{
m_bShouldBeVisible = false;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::LevelInit( void )
{
m_bShouldBeVisible = false;
SetVisible( false );
Init();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::SetVisible( bool state )
{
// we can only turn on tournament mode if we're in prematch
if ( state )
{
if ( m_bReadyStatusMode )
{
if ( m_bReadyTextBlinking )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudReadyPulse" );
}
}
if ( TeamplayRoundBasedRules() && !TeamplayRoundBasedRules()->IsInPreMatch() )
return;
}
BaseClass::SetVisible( state );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
m_bReapplyPlayerPanelKVs = true;
KeyValues *pConditions = NULL;
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
pConditions = new KeyValues( "conditions" );
AddSubKeyNamed( pConditions, "if_mvm" );
}
else if ( m_bCompetitiveMode )
{
pConditions = new KeyValues( "conditions" );
AddSubKeyNamed( pConditions, "if_competitive" );
}
else if ( m_bReadyStatusMode )
{
pConditions = new KeyValues( "conditions" );
AddSubKeyNamed( pConditions, "if_readymode" );
}
// load control settings...
LoadControlSettings( "resource/UI/HudTournament.res", NULL, NULL, pConditions );
if ( pConditions )
{
pConditions->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
KeyValues *pItemKV = inResourceData->FindKey( "playerpanels_kv" );
if ( pItemKV )
{
if ( m_pPlayerPanelKVs )
{
m_pPlayerPanelKVs->deleteThis();
}
m_pPlayerPanelKVs = new KeyValues("playerpanels_kv");
pItemKV->CopySubkeys( m_pPlayerPanelKVs );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::PerformLayout( void )
{
BaseClass::PerformLayout();
if ( m_bReapplyPlayerPanelKVs )
{
m_bReapplyPlayerPanelKVs = false;
if ( m_pPlayerPanelKVs )
{
for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
{
m_PlayerPanels[i]->ApplySettings( m_pPlayerPanelKVs );
m_PlayerPanels[i]->InvalidateLayout( false, true );
}
}
}
bool bShowTournamentConditions = !m_bCompetitiveMode && TFGameRules() && !TFGameRules()->IsMannVsMachineMode();
// Hide some elements when in competitive mode
if ( m_pTournamentConditionLabel )
{
m_pTournamentConditionLabel->SetVisible( bShowTournamentConditions );
}
Panel* pTournamentBG = FindChildByName( "HudTournamentBG" );
if ( pTournamentBG )
{
pTournamentBG->SetVisible( bShowTournamentConditions );
}
UpdatePlayerPanels();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::SetPlayerPanelsVisible( bool bVisible )
{
for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
{
if ( m_PlayerPanels[i] )
{
if ( m_PlayerPanels[i]->IsVisible() != bVisible )
{
m_PlayerPanels[i]->SetVisible( bVisible );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Create a new panel if necessary
//-----------------------------------------------------------------------------
CTFPlayerPanel *CHudTournament::GetOrAddPanel( int iPanelIndex )
{
if ( iPanelIndex < m_PlayerPanels.Count() )
{
return m_PlayerPanels[ iPanelIndex ];
}
Assert( iPanelIndex == m_PlayerPanels.Count() );
CTFPlayerPanel *pPanel = new CTFPlayerPanel( this, VarArgs("playerpanel%d", iPanelIndex) );
if ( m_pPlayerPanelKVs )
{
pPanel->ApplySettings( m_pPlayerPanelKVs );
pPanel->InvalidateLayout( false, true );
}
m_PlayerPanels.AddToTail( pPanel );
return pPanel;
}
//-----------------------------------------------------------------------------
// Purpose: Decide which players we will show
//-----------------------------------------------------------------------------
void CHudTournament::RecalculatePlayerPanels( void )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer || !g_TF_PR )
return;
int iLocalTeam = g_TF_PR->GetTeam( pPlayer->entindex() );
int iPanel = 0;
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
if ( !g_TF_PR->IsConnected( i ) )
continue;
int iTeam = g_TF_PR->GetTeam( i );
if ( iTeam == TEAM_UNASSIGNED && !m_bReadyStatusMode )
continue;
// Spectators see all players, team members only see their team.
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && iTeam != iLocalTeam && iLocalTeam != TEAM_SPECTATOR )
continue;
if ( iTeam != TF_TEAM_RED && iTeam != TF_TEAM_BLUE )
continue;
// Add an entry for him
CTFPlayerPanel *pPanel = GetOrAddPanel( iPanel );
pPanel->SetPlayerIndex( i );
++iPanel;
}
// Check if we have a lobby, then add in players that have a reservation in the lobby,
// but aren't in the game yet
// XXX(JohnS): Once eric's change to mirror the match info to playerresource is in, we should just trust that and
// not look at the lobby on our end. Eventually client lobbies shouldn't even have other members in
// them.
CTFGSLobby *pLobby = GTFGCClientSystem()->GetLobby();
if ( pLobby )
{
for ( int i = 0; i < pLobby->GetNumMembers(); ++i )
{
CSteamID steamID = pLobby->GetMember( i );
// Already have a panel for him?
bool bFound = false;
for ( int j = 0; j < iPanel; ++j )
{
if ( m_PlayerPanels[j]->GetSteamID() == steamID )
{
bFound = true;
break;
}
}
if ( !bFound )
{
CTFPlayerPanel *pPanel = GetOrAddPanel( iPanel );
pPanel->Setup( 0, steamID, pLobby->GetMemberDetails( i )->name().c_str(), pLobby->GetMemberDetails( steamID )->team() );
++iPanel;
}
}
}
// Clear out any extra panels
for ( int i = iPanel; i < m_PlayerPanels.Count(); i++ )
{
m_PlayerPanels[i]->SetPlayerIndex( 0 );
}
UpdatePlayerPanels();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournament::UpdatePlayerPanels( void )
{
if ( !g_TF_PR )
return;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
if ( !TFGameRules() )
return;
// Hide panels for players when they're no longer able to stop the countdown
if ( TFGameRules()->GetRoundRestartTime() >= 0.f && TFGameRules()->GetRoundRestartTime() - gpGlobals->curtime <= TOURNAMENT_NOCANCEL_TIME )
{
SetPlayerPanelsVisible( false );
m_pModeImage->SetVisible( false );
return;
}
bool bNeedsPlayerLayout = false;
for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
{
if ( m_PlayerPanels[i]->Update() )
{
bNeedsPlayerLayout = true;
}
}
if ( !bNeedsPlayerLayout || !TFGameRules() )
return;
// Try and always put the local player's team on team1, if he's in a team
int iTeam1 = TF_TEAM_BLUE;
int iTeam2 = TF_TEAM_RED;
int iLocalTeam = g_TF_PR->GetTeam( pPlayer->entindex() );
if ( ( iLocalTeam == TF_TEAM_RED || iLocalTeam == TF_TEAM_BLUE ) && !TFGameRules()->IsCompetitiveMode() ) // Blue always on left in comp
{
iTeam1 = iLocalTeam;
iTeam2 = ( iTeam1 == TF_TEAM_BLUE ) ? TF_TEAM_RED : TF_TEAM_BLUE;
}
int iTeam1Count = g_TF_PR->GetNumPlayersForTeam( iTeam1, false );
if ( GTFGCClientSystem()->GetLobby() )
{
// Everyone's on the same team in MvM, and any other lobby-based game is assumed to be two teams.
iTeam1Count = TFGameRules()->IsMannVsMachineMode() ?
GTFGCClientSystem()->GetLobby()->GetNumMembers() :
GTFGCClientSystem()->GetLobby()->GetNumMembers()>>1;
}
int iTeam1Processed = 0;
int iTeam2Processed = 0;
int iCenter = GetWide() * 0.5;
for ( int i = 0; i < m_PlayerPanels.Count(); i++ )
{
int iTeam = m_PlayerPanels[i]->GetTeam();
if ( !m_PlayerPanels[i]->GetPlayerIndex() && iTeam == TEAM_INVALID )
continue;
int iXPos = ( m_bCompetitiveMode ) ? -XRES( 30 ) : 0; // Hack to make space for the season image
int iYPos = ( m_iTeam1PlayerBaseY + m_iTeam1PlayerDeltaY );
int nOffset = ( m_bCompetitiveMode ) ? m_iTeamsPlayerDeltaXComp : m_iTeam2PlayerDeltaX;
if ( iTeam == iTeam1 )
{
// Two teams. First team left of center.
if ( m_bReadyStatusMode && !TFGameRules()->IsMannVsMachineMode() )
{
int iTeam1LeftCorner = iCenter - ( iTeam1Count * nOffset );
iXPos += ( iTeam1LeftCorner + ( iTeam1Processed * nOffset ) );
}
// One team. Centered.
else
{
int iTeam1LeftCorner = ( iCenter - ( iTeam1Count * nOffset ) * 0.5 );
iXPos += ( iTeam1LeftCorner + ( iTeam1Processed * nOffset ) );
}
m_PlayerPanels[i]->SetSpecIndex( 6 - iTeam1Processed );
++iTeam1Processed;
}
else if ( iTeam == iTeam2 )
{
// Two teams. Second team right of center.
iXPos = ( iCenter + ( iTeam2Processed * nOffset ) );
iXPos += ( m_bCompetitiveMode ) ? XRES( 30 ) : 0; // Hack to make space for the season image
m_PlayerPanels[i]->SetSpecIndex( 7 + iTeam2Processed );
++iTeam2Processed;
}
m_PlayerPanels[i]->SetPos( iXPos, iYPos );
}
}
DECLARE_HUDELEMENT( CHudTournamentSetup );
bool TournamentHudElementKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
{
CHudTournamentSetup *pTournamentPanel = ( CHudTournamentSetup * )GET_HUDELEMENT( CHudTournamentSetup );
if ( pTournamentPanel && down == 1 )
{
return pTournamentPanel->ToggleState( keynum );
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHudTournamentSetup::CHudTournamentSetup( const char *pElementName ) : CHudElement( pElementName ), BaseClass( NULL, "HudTournamentSetup" )
{
Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetHiddenBits( HIDEHUD_MISCSTATUS );
vgui::ivgui()->AddTickSignal( GetVPanel(), 100 );
m_pNameEntry = new TextEntry(this, "TournamentNameEdit" );
m_pEntryBG = new CTFImagePanel(this, "HudTournamentNameBG" );
m_pReadyButton = new CExButton(this, "TournamentReadyButton", "" );
m_pNotReadyButton = new CExButton(this, "TournamentNotReadyButton", "" );
m_pTeamNameLabel = NULL;
m_flNextThink = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::Init( void )
{
SetVisible( false );
CHudElement::Init();
DisableInput();
m_pNameEntry->SetText( g_pVGuiLocalize->Find( "Tournament_TeamNameNotSet" ) );
m_flNextThink = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::OnCommand( const char *command )
{
if ( !Q_strcmp( command, "teamready" ) )
{
char szText[64];
m_pNameEntry->GetText( szText, sizeof( szText ) );
char szTeamName[64];
Q_snprintf ( szTeamName, sizeof( szTeamName ), "tournament_teamname %s", szText );
engine->ClientCmd_Unrestricted( szTeamName );
engine->ClientCmd_Unrestricted( "tournament_readystate 1" );
DisableInput();
}
else if ( !Q_strcmp( command, "teamnotready" ) )
{
engine->ClientCmd_Unrestricted( "tournament_readystate 0" );
DisableInput();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHudTournamentSetup::ToggleState( ButtonCode_t code )
{
if ( !IsVisible() )
return false;
if ( !g_TF_PR )
return false;
if ( code == KEY_F4 || code == STEAMCONTROLLER_F4 )
{
if ( TFGameRules() && TFGameRules()->UsePlayerReadyStatusMode() )
{
int nReady = ( TFGameRules()->IsPlayerReady( GetLocalPlayerIndex() ) ) ? 0 : 1;
char szCommand[64];
Q_snprintf( szCommand, sizeof( szCommand ), "tournament_player_readystate %d", nReady );
engine->ClientCmd_Unrestricted( szCommand );
}
else
{
if ( IsMouseInputEnabled() )
{
DisableInput();
return true;
}
else
{
EnableInput();
return true;
}
}
}
if ( IsMouseInputEnabled() )
{
if ( code == KEY_ESCAPE || code == KEY_ENTER )
{
if ( code == KEY_ENTER )
{
char szText[64];
m_pNameEntry->GetText( szText, sizeof( szText ) );
char szTeamName[64];
Q_snprintf ( szTeamName, sizeof( szTeamName ), "tournament_teamname %s", szText );
engine->ClientCmd_Unrestricted( szTeamName );
m_flNextThink = gpGlobals->curtime + TOURNAMENT_PANEL_UPDATE_INTERVAL;
}
DisableInput();
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::FireGameEvent( IGameEvent * event )
{
const char *pEventName = event->GetName();
if ( Q_strcmp( "tournament_stateupdate", pEventName ) == 0 )
{
if ( TFGameRules()->IsInTournamentMode() && TFGameRules()->IsInWaitingForPlayers() )
{
m_flNextThink = gpGlobals->curtime;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CHudTournamentSetup::OnTick( void )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
if ( !g_TF_PR )
return;
int iLocalTeam = g_TF_PR->GetTeam( pLocalPlayer->entindex() );
if ( iLocalTeam <= LAST_SHARED_TEAM || TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
{
SetVisible( false );
return;
}
if ( TFGameRules() )
{
if ( TFGameRules()->UsePlayerReadyStatusMode() )
{
if ( TFGameRules()->IsInTournamentMode() && TFGameRules()->IsInWaitingForPlayers() )
{
if ( !IsVisible() )
{
SetVisible( true );
}
SetPos( 0, YRES( -100 ) ); // make sure the panel is WAY off the screen for MvM mode
}
else
{
if ( IsVisible() )
{
SetVisible( false );
}
}
}
else if ( TFGameRules()->IsInTournamentMode() && TFGameRules()->IsInWaitingForPlayers() )
{
if ( !IsVisible() )
{
SetVisible( true );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudTournamentSetupPanelClose" );
}
}
else
{
if ( IsVisible() )
{
SetVisible( false );
}
}
}
if ( m_flNextThink <= gpGlobals->curtime )
{
if ( !IsMouseInputEnabled() )
{
m_pNameEntry->SetText( ( iLocalTeam == TF_TEAM_BLUE ) ? mp_tournament_blueteamname.GetString() : mp_tournament_redteamname.GetString() );
}
SetDialogVariable( "tournamentstatelabel", TFGameRules()->IsTeamReady( iLocalTeam ) ? g_pVGuiLocalize->Find( "Tournament_TeamSetupReady" ) : g_pVGuiLocalize->Find( "Tournament_TeamSetupNotReady" ) );
m_flNextThink = gpGlobals->curtime + TOURNAMENT_PANEL_UPDATE_INTERVAL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::EnableInput( void )
{
SetVisible( true );
vgui::SETUP_PANEL( this );
SetKeyBoardInputEnabled( true );
SetMouseInputEnabled( true );
m_pNameEntry->SetVisible( true );
vgui::surface()->CalculateMouseVisible();
m_pNameEntry->RequestFocus();
m_pNameEntry->SetPaintBorderEnabled( true );
m_pNameEntry->SetMouseInputEnabled( true );
m_pNameEntry->SetKeyBoardInputEnabled( true );
MakePopup();
m_pEntryBG->SetVisible( true );
m_pReadyButton->SetVisible( true );
m_pReadyButton->SetMouseInputEnabled( true );
m_pNotReadyButton->SetVisible( true );
m_pNotReadyButton->SetMouseInputEnabled( true );
m_pTeamNameLabel->SetVisible( true );
engine->ClientCmd_Unrestricted( "gameui_preventescapetoshow\n" );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudTournamentSetupPanelOpen" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::DisableInput( void )
{
SetKeyBoardInputEnabled( false );
SetMouseInputEnabled( false );
m_pNameEntry->SetMouseInputEnabled( false );
m_pNameEntry->SetKeyBoardInputEnabled( false );
engine->ClientCmd_Unrestricted( "gameui_allowescapetoshow\n" );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudTournamentSetupPanelClose" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::LevelInit( void )
{
SetVisible( false );
Init();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHudTournamentSetup::ShouldDraw( void )
{
return ( IsVisible() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudTournamentSetup::ApplySchemeSettings( IScheme *pScheme )
{
// load control settings...
LoadControlSettings( "resource/UI/HudTournamentSetup.res" );
BaseClass::ApplySchemeSettings( pScheme );
m_pNameEntry->SetFont( pScheme->GetFont( "HudFontSmallest", IsProportional() ) );
m_pTeamNameLabel = dynamic_cast<Label *>( FindChildByName( "TournamentTeamNameLabel" ) );
}
DECLARE_HUDELEMENT( CHudStopWatch );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHudStopWatch::CHudStopWatch( const char *pElementName ) : CHudElement( pElementName ), BaseClass( NULL, "HudStopWatch" )
{
Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetHiddenBits( HIDEHUD_MISCSTATUS );
m_bShouldBeVisible = false;
vgui::ivgui()->AddTickSignal( GetVPanel(), 100 );
m_pTimePanel = new CTFHudTimeStatus( this, "ObjectiveStatusTimePanel" );
m_pStopWatchLabel = new CExLabel( this, "StopWatchLabel", "" );
m_pStopWatchScore = new CExLabel( this, "StopWatchScoreToBeat", "" );
m_pStopWatchPointsLabel = new CExLabel( this, "StopWatchPointsLabel", "" );
m_pStopWatchImage = new ImagePanel( this, "StopWatchImageCaptureTime" );
m_pStopWatchDescriptionLabel = new CExLabel( this, "StopWatchDescriptionLabel", "" );
ListenForGameEvent( "competitive_state_changed" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHudStopWatch::ShouldDraw( void )
{
bool bRetVal = m_bShouldBeVisible;
if ( bRetVal )
{
// give the HUD a chance to turn us off when we should be hidden
bRetVal = CHudElement::ShouldDraw();
}
return bRetVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudStopWatch::LevelInit( void )
{
m_bShouldBeVisible = true;
if ( m_pTimePanel )
{
m_pTimePanel->SetVisible( true );
m_pTimePanel->Reset();
}
m_pStopWatchLabel->SetVisible( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudStopWatch::ApplySchemeSettings( IScheme *pScheme )
{
KeyValues *pConditions = NULL;
if ( ShouldUseMatchHUD() )
{
pConditions = new KeyValues( "conditions" );
AddSubKeyNamed( pConditions, "if_comp" );
}
// load control settings...
LoadControlSettings( "resource/UI/HudStopWatch.res", NULL, NULL, pConditions );
BaseClass::ApplySchemeSettings( pScheme );
m_pStopWatchDescriptionBG = FindChildByName( "HudStopWatchDescriptionBG" );
if ( pConditions )
{
pConditions->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudStopWatch::OnTick( void )
{
BaseClass::OnTick();
if ( !TFGameRules() )
return;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
bool bInFreezeCam = ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM );
bool bProperMatch = TFGameRules()->IsInTournamentMode() || TFGameRules()->IsCompetitiveMode();
if ( !bProperMatch || TFGameRules()->IsInPreMatch() || !TFGameRules()->IsInStopWatch() || bInFreezeCam || TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
{
m_bShouldBeVisible = false;
return;
}
else
{
m_bShouldBeVisible = true;
}
if ( m_pTimePanel && ObjectiveResource() )
{
int iActiveTimer = ObjectiveResource()->GetStopWatchTimer();
m_pTimePanel->SetTimerIndex( iActiveTimer );
C_TFTeam *pAttacker = NULL;
C_TFTeam *pDefender = NULL;
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
{
C_TFTeam *pTeam = GetGlobalTFTeam( i );
if ( pTeam )
{
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
{
pDefender = pTeam;
}
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
{
pAttacker = pTeam;
}
}
}
if ( !pAttacker || !pDefender )
return;
if ( TFGameRules()->GetStopWatchState() == STOPWATCH_CAPTURE_TIME_NOT_SET )
{
m_pTimePanel->SetVisible( false );
m_pStopWatchLabel->SetVisible( true );
m_pStopWatchScore->SetVisible( false );
m_pStopWatchPointsLabel->SetVisible( false );
m_pStopWatchDescriptionBG->SetVisible( false );
m_pStopWatchDescriptionLabel->SetVisible( false );
m_pStopWatchImage->SetImage( "../hud/ico_time_none" );
SetDialogVariable( "stopwatchlabel", g_pVGuiLocalize->Find( "Tournament_StopWatchNoCap" ) );
}
else if ( TFGameRules()->GetStopWatchState() == STOPWATCH_RUNNING )
{
m_pTimePanel->SetVisible( true );
m_pStopWatchLabel->SetVisible( false );
m_pStopWatchScore->SetVisible( true );
m_pStopWatchPointsLabel->SetVisible( true );
m_pStopWatchImage->SetImage( "../hud/ico_time_10" );
CTeamRoundTimer *pTimer = dynamic_cast< CTeamRoundTimer* >( ClientEntityList().GetEnt( iActiveTimer ) );
int iPoints = 0;
if ( pTimer )
{
if ( pTimer->IsWatchingTimeStamps() )
{
iPoints = pAttacker->Get_Score();
}
else
{
iPoints = pDefender->Get_Score() - pAttacker->Get_Score();
}
}
wchar_t wzScoreVal[128];
static wchar_t wzScore[128];
wchar_t *pszPoints = NULL;
_snwprintf( wzScoreVal, ARRAYSIZE( wzScoreVal ), L"%i", iPoints );
if ( 1 == iPoints )
{
pszPoints = g_pVGuiLocalize->Find( "#Tournament_StopWatch_Point" );
}
else
{
pszPoints = g_pVGuiLocalize->Find( "#Tournament_StopWatch_Points" );
}
SetDialogVariable( "pointslabel", pszPoints );
SetDialogVariable( "scoretobeat", wzScoreVal );
wchar_t wzHelp[128];
if ( pPlayer->GetTeam() == pAttacker )
{
g_pVGuiLocalize->ConstructString_safe( wzHelp, g_pVGuiLocalize->Find( "Tournament_StopWatch_TimeVictory" ), 1, pDefender->Get_Localized_Name() );
}
else
{
g_pVGuiLocalize->ConstructString_safe( wzHelp, g_pVGuiLocalize->Find( "Tournament_StopWatch_TimeVictoryDefender" ), 1, pDefender->Get_Localized_Name() );
}
SetDialogVariable( "descriptionlabel", wzHelp );
if ( pTimer && !pTimer->IsWatchingTimeStamps() )
{
m_pStopWatchDescriptionBG->SetVisible( true );
m_pStopWatchDescriptionLabel->SetVisible( true );
}
else
{
m_pStopWatchDescriptionBG->SetVisible( false );
m_pStopWatchDescriptionLabel->SetVisible( false );
}
}
else if ( TFGameRules()->GetStopWatchState() == STOPWATCH_OVERTIME )
{
m_pTimePanel->SetVisible( false );
m_pStopWatchLabel->SetVisible( true );
m_pStopWatchScore->SetVisible( false );
m_pStopWatchPointsLabel->SetVisible( false );
m_pStopWatchDescriptionBG->SetVisible( false );
m_pStopWatchDescriptionLabel->SetVisible( false );
SetDialogVariable( "descriptionlabel", g_pVGuiLocalize->Find( "#Tournament_StopWatch_CapVictory" ) );
m_pStopWatchImage->SetImage( "../hud/ico_time_60" );
wchar_t wzScoreVal[128];
int iPoints = (pDefender->Get_Score() - pAttacker->Get_Score()) + 1;
wchar_t wzVal[16];
swprintf( wzVal, ARRAYSIZE( wzVal ), L"%x", iPoints );
if ( pPlayer->GetTeam() == pAttacker )
{
g_pVGuiLocalize->ConstructString_safe( wzScoreVal, g_pVGuiLocalize->Find( "Tournament_StopWatchPointCaptureAttacker" ), 2, wzVal, iPoints == 1 ? g_pVGuiLocalize->Find( "#Tournament_StopWatch_Point" ) : g_pVGuiLocalize->Find( "#Tournament_StopWatch_Points" ) );
}
else if ( pPlayer->GetTeam() == pDefender )
{
g_pVGuiLocalize->ConstructString_safe( wzScoreVal, g_pVGuiLocalize->Find( "Tournament_StopWatchPointCaptureDefender" ), 2, wzVal, iPoints == 1 ? g_pVGuiLocalize->Find( "#Tournament_StopWatch_Point" ) : g_pVGuiLocalize->Find( "#Tournament_StopWatch_Points" ) );
}
else
{
g_pVGuiLocalize->ConstructString_safe( wzScoreVal, g_pVGuiLocalize->Find( "Tournament_StopWatchPointCaptureSpectator" ), 2, wzVal, iPoints == 1 ? g_pVGuiLocalize->Find( "#Tournament_StopWatch_Point" ) : g_pVGuiLocalize->Find( "#Tournament_StopWatch_Points" ) );
}
SetDialogVariable( "stopwatchlabel", wzScoreVal );
}
}
}
void CHudStopWatch::FireGameEvent( IGameEvent * event )
{
if ( FStrEq( event->GetName(), "competitive_state_changed" ) )
{
InvalidateLayout( false, true );
return;
}
CHudElement::FireGameEvent( event );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CON_COMMAND( player_ready_toggle, "Toggle player ready state" )
{
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pPlayer )
{
CHudTournamentSetup *pTournamentPanel = dynamic_cast< CHudTournamentSetup* >( GET_HUDELEMENT( CHudTournamentSetup ) );
if ( pTournamentPanel )
{
pTournamentPanel->ToggleState( KEY_F4 );
}
}
}
Reference in New Issue View Git Blame Copy Permalink