expvintl/source-engine-2018-hl2_src
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3bf9df6b27
source-engine-2018-hl2_src/serverbrowser/DialogGameInfo.cpp

803 lines
24 KiB
C++
Raw Normal View History

1
2020-04-23 00:56:21 +08:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "pch_serverbrowser.h"
using namespace vgui;
static const long RETRY_TIME = 10000; // refresh server every 10 seconds
static const long CHALLENGE_ENTRIES = 1024;
extern "C"
{
DLL_EXPORT bool JoiningSecureServerCall()
{
return true;
}
}
//-----------------------------------------------------------------------------
// Purpose: Comparison function used in query redblack tree
//-----------------------------------------------------------------------------
bool QueryLessFunc( const struct challenge_s &item1, const struct challenge_s &item2 )
{
// compare port then ip
if ( item1.addr.GetPort() < item2.addr.GetPort() )
return true;
else if ( item1.addr.GetPort() > item2.addr.GetPort() )
return false;
int ip1 = item1.addr.GetIPNetworkByteOrder();
int ip2 = item2.addr.GetIPNetworkByteOrder();
return ip1 < ip2;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CDialogGameInfo::CDialogGameInfo( vgui::Panel *parent, int serverIP, int queryPort, unsigned short connectionPort, const char *pszConnectCode ) :
Frame(parent, "DialogGameInfo"),
m_CallbackPersonaStateChange( this, &CDialogGameInfo::OnPersonaStateChange ),
m_sConnectCode( pszConnectCode )
{
SetBounds(0, 0, 512, 512);
SetMinimumSize(416, 340);
SetDeleteSelfOnClose(true);
m_bConnecting = false;
m_bServerFull = false;
m_bShowAutoRetryToggle = false;
m_bServerNotResponding = false;
m_bShowingExtendedOptions = false;
m_SteamIDFriend = 0;
m_hPingQuery = HSERVERQUERY_INVALID;
m_hPlayersQuery = HSERVERQUERY_INVALID;
m_bPlayerListUpdatePending = false;
m_szPassword[0] = 0;
m_pConnectButton = new Button(this, "Connect", "#ServerBrowser_JoinGame");
m_pCloseButton = new Button(this, "Close", "#ServerBrowser_Close");
m_pRefreshButton = new Button(this, "Refresh", "#ServerBrowser_Refresh");
m_pInfoLabel = new Label(this, "InfoLabel", "");
m_pAutoRetry = new ToggleButton(this, "AutoRetry", "#ServerBrowser_AutoRetry");
m_pAutoRetry->AddActionSignalTarget(this);
m_pAutoRetryAlert = new RadioButton(this, "AutoRetryAlert", "#ServerBrowser_AlertMeWhenSlotOpens");
m_pAutoRetryJoin = new RadioButton(this, "AutoRetryJoin", "#ServerBrowser_JoinWhenSlotOpens");
m_pPlayerList = new ListPanel(this, "PlayerList");
m_pPlayerList->AddColumnHeader(0, "PlayerName", "#ServerBrowser_PlayerName", 156);
m_pPlayerList->AddColumnHeader(1, "Score", "#ServerBrowser_Score", 64);
m_pPlayerList->AddColumnHeader(2, "Time", "#ServerBrowser_Time", 64);
m_pPlayerList->SetSortFunc(2, &PlayerTimeColumnSortFunc);
// set the defaults for sorting
// hack, need to make this more explicit functions in ListPanel
PostMessage(m_pPlayerList, new KeyValues("SetSortColumn", "column", 2));
PostMessage(m_pPlayerList, new KeyValues("SetSortColumn", "column", 1));
PostMessage(m_pPlayerList, new KeyValues("SetSortColumn", "column", 1));
m_pAutoRetryAlert->SetSelected(true);
m_pConnectButton->SetCommand(new KeyValues("Connect"));
m_pCloseButton->SetCommand(new KeyValues("Close"));
m_pRefreshButton->SetCommand(new KeyValues("Refresh"));
m_iRequestRetry = 0;
// create a new server to watch
memset(&m_Server, 0, sizeof(m_Server) );
m_Server.m_NetAdr.Init( serverIP, queryPort, connectionPort );
// refresh immediately
RequestInfo();
// let us be ticked every frame
ivgui()->AddTickSignal(this->GetVPanel());
LoadControlSettings("Servers/DialogGameInfo.res");
RegisterControlSettingsFile( "Servers/DialogGameInfo_SinglePlayer.res" );
RegisterControlSettingsFile( "Servers/DialogGameInfo_AutoRetry.res" );
MoveToCenterOfScreen();
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CDialogGameInfo::~CDialogGameInfo()
{
if ( !steamapicontext->SteamMatchmakingServers() )
return;
if ( m_hPingQuery != HSERVERQUERY_INVALID )
steamapicontext->SteamMatchmakingServers()->CancelServerQuery( m_hPingQuery );
if ( m_hPlayersQuery != HSERVERQUERY_INVALID )
steamapicontext->SteamMatchmakingServers()->CancelServerQuery( m_hPlayersQuery );
}
//-----------------------------------------------------------------------------
// Purpose: send a player query to a server
//-----------------------------------------------------------------------------
void CDialogGameInfo::SendPlayerQuery( uint32 unIP, uint16 usQueryPort )
{
if ( !steamapicontext->SteamMatchmakingServers() )
return;
if ( m_hPlayersQuery != HSERVERQUERY_INVALID )
steamapicontext->SteamMatchmakingServers()->CancelServerQuery( m_hPlayersQuery );
m_hPlayersQuery = steamapicontext->SteamMatchmakingServers()->PlayerDetails( unIP, usQueryPort, this );
m_bPlayerListUpdatePending = true;
}
//-----------------------------------------------------------------------------
// Purpose: Activates the dialog
//-----------------------------------------------------------------------------
void CDialogGameInfo::Run(const char *titleName)
{
if ( titleName )
{
SetTitle( "#ServerBrowser_GameInfoWithNameTitle", true );
}
else
{
SetTitle( "#ServerBrowser_GameInfoWithNameTitle", true );
}
SetDialogVariable( "game", titleName );
// get the info from the user
RequestInfo();
Activate();
}
//-----------------------------------------------------------------------------
// Purpose: Changes which server to watch
//-----------------------------------------------------------------------------
void CDialogGameInfo::ChangeGame( int serverIP, int queryPort, unsigned short connectionPort )
{
memset( &m_Server, 0x0, sizeof(m_Server) );
m_Server.m_NetAdr.Init( serverIP, queryPort, connectionPort );
// remember the dialogs position so we can keep it the same
int x, y;
GetPos( x, y );
// see if we need to change dialog state
if ( !m_Server.m_NetAdr.GetIP() || !m_Server.m_NetAdr.GetQueryPort() )
{
// not in a server, load the simple settings dialog
SetMinimumSize(0, 0);
SetSizeable( false );
LoadControlSettings( "Servers/DialogGameInfo_SinglePlayer.res" );
}
else
{
// moving from a single-player game -> multiplayer, reset dialog
SetMinimumSize(416, 340);
SetSizeable( true );
LoadControlSettings( "Servers/DialogGameInfo.res" );
}
SetPos( x, y );
// Start refresh immediately
m_iRequestRetry = 0;
RequestInfo();
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: updates the dialog if it's watching a friend who changes servers
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnPersonaStateChange( PersonaStateChange_t *pPersonaStateChange )
{
#if 0 // TBD delete this func
if ( m_SteamIDFriend && m_SteamIDFriend == pPersonaStateChange->m_ulSteamID )
{
// friend may have changed servers
uint64 nGameID;
uint32 unGameIP;
uint16 usGamePort;
uint16 usQueryPort;
if ( SteamFriends()->GetFriendGamePlayed( m_SteamIDFriend, &nGameID, &unGameIP, &usGamePort, &usQueryPort ) )
{
if ( pPersonaStateChange->m_nChangeFlags & k_EPersonaChangeGamePlayed )
{
ChangeGame( unGameIP, usQueryPort, usGamePort );
}
}
else
{
// bugbug johnc: change to not be in a game anymore
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Associates a user with this dialog
//-----------------------------------------------------------------------------
void CDialogGameInfo::SetFriend( uint64 ulSteamIDFriend )
{
// set the title to include the friends name
SetTitle( "#ServerBrowser_GameInfoWithNameTitle", true );
SetDialogVariable( "game", steamapicontext->SteamFriends()->GetFriendPersonaName( ulSteamIDFriend ) );
SetDialogVariable( "friend", steamapicontext->SteamFriends()->GetFriendPersonaName( ulSteamIDFriend ) );
// store the friend we're associated with
m_SteamIDFriend = ulSteamIDFriend;
FriendGameInfo_t friendGameInfo;
if ( steamapicontext->SteamFriends()->GetFriendGamePlayed( ulSteamIDFriend, &friendGameInfo ) )
{
uint16 usConnPort = friendGameInfo.m_usGamePort;
if ( friendGameInfo.m_usQueryPort < QUERY_PORT_ERROR )
usConnPort = friendGameInfo.m_usQueryPort;
ChangeGame( friendGameInfo.m_unGameIP, usConnPort, friendGameInfo.m_usGamePort );
}
}
//-----------------------------------------------------------------------------
// Purpose: data access
//-----------------------------------------------------------------------------
uint64 CDialogGameInfo::GetAssociatedFriend()
{
return m_SteamIDFriend;
}
//-----------------------------------------------------------------------------
// Purpose: lays out the data
//-----------------------------------------------------------------------------
void CDialogGameInfo::PerformLayout()
{
BaseClass::PerformLayout();
SetControlString( "ServerText", m_Server.GetName() );
SetControlString( "GameText", m_Server.m_szGameDescription );
SetControlString( "MapText", m_Server.m_szMap );
SetControlString( "GameTags", m_Server.m_szGameTags );
if ( !m_Server.m_bHadSuccessfulResponse )
{
SetControlString("SecureText", "");
}
else if ( m_Server.m_bSecure )
{
SetControlString("SecureText", "#ServerBrowser_Secure");
}
else
{
SetControlString("SecureText", "#ServerBrowser_NotSecure");
}
char buf[128];
if ( m_Server.m_nMaxPlayers > 0)
{
Q_snprintf(buf, sizeof(buf), "%d / %d", m_Server.m_nPlayers, m_Server.m_nMaxPlayers);
}
else
{
buf[0] = 0;
}
SetControlString("PlayersText", buf);
if ( m_Server.m_NetAdr.GetIP() && m_Server.m_NetAdr.GetQueryPort() )
{
SetControlString("ServerIPText", m_Server.m_NetAdr.GetConnectionAddressString() );
m_pConnectButton->SetEnabled(true);
if ( m_pAutoRetry->IsSelected() )
{
m_pAutoRetryAlert->SetVisible(true);
m_pAutoRetryJoin->SetVisible(true);
}
else
{
m_pAutoRetryAlert->SetVisible(false);
m_pAutoRetryJoin->SetVisible(false);
}
}
else
{
SetControlString("ServerIPText", "");
m_pConnectButton->SetEnabled(false);
}
if ( m_Server.m_bHadSuccessfulResponse )
{
Q_snprintf(buf, sizeof(buf), "%d", m_Server.m_nPing );
SetControlString("PingText", buf);
}
else
{
SetControlString("PingText", "");
}
// set the info text
if ( m_pAutoRetry->IsSelected() )
{
if ( m_Server.m_nPlayers < m_Server.m_nMaxPlayers )
{
m_pInfoLabel->SetText("#ServerBrowser_PressJoinToConnect");
}
else if (m_pAutoRetryJoin->IsSelected())
{
m_pInfoLabel->SetText("#ServerBrowser_JoinWhenSlotIsFree");
}
else
{
m_pInfoLabel->SetText("#ServerBrowser_AlertWhenSlotIsFree");
}
}
else if (m_bServerFull)
{
m_pInfoLabel->SetText("#ServerBrowser_CouldNotConnectServerFull");
}
else if (m_bServerNotResponding)
{
m_pInfoLabel->SetText("#ServerBrowser_ServerNotResponding");
}
else
{
// clear the status
m_pInfoLabel->SetText("");
}
if ( m_Server.m_bHadSuccessfulResponse && !(m_Server.m_nPlayers + m_Server.m_nBotPlayers) )
{
m_pPlayerList->SetEmptyListText("#ServerBrowser_ServerHasNoPlayers");
}
else
{
m_pPlayerList->SetEmptyListText("#ServerBrowser_ServerNotResponding");
}
// auto-retry layout
m_pAutoRetry->SetVisible(m_bShowAutoRetryToggle);
Repaint();
}
void CDialogGameInfo::OnKeyCodePressed( vgui::KeyCode code )
{
if ( code == KEY_XBUTTON_B || code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A || code == STEAMCONTROLLER_B )
{
m_pCloseButton->DoClick();
}
else
{
BaseClass::OnKeyCodePressed(code);
}
}
//-----------------------------------------------------------------------------
// Purpose: Forces the game info dialog to try and connect
//-----------------------------------------------------------------------------
void CDialogGameInfo::Connect()
{
OnConnect();
}
//-----------------------------------------------------------------------------
// Purpose: Connects the user to this game
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnConnect()
{
// flag that we are attempting connection
m_bConnecting = true;
// reset state
m_bServerFull = false;
m_bServerNotResponding = false;
InvalidateLayout();
// need to refresh server before attempting to connect, to make sure there is enough room on the server
m_iRequestRetry = 0;
RequestInfo();
}
//-----------------------------------------------------------------------------
// Purpose: Cancel auto-retry if we connect to the game by other means
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnConnectToGame( int ip, int port )
{
// if we just connected to the server we were looking at, close the dialog
// important so that we don't auto-retry a server that we are already on
if ( m_Server.m_NetAdr.GetIP() == (uint32)ip && m_Server.m_NetAdr.GetConnectionPort() == (uint16)port )
{
// close this dialog
Close();
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles Refresh button press, starts a re-ping of the server
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnRefresh()
{
m_iRequestRetry = 0;
// re-ask the server for the game info
RequestInfo();
}
//-----------------------------------------------------------------------------
// Purpose: Forces the whole dialog to redraw when the auto-retry button is toggled
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnButtonToggled(Panel *panel)
{
if (panel == m_pAutoRetry)
{
ShowAutoRetryOptions(m_pAutoRetry->IsSelected());
}
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether the extended auto-retry options are visible or not
//-----------------------------------------------------------------------------
void CDialogGameInfo::ShowAutoRetryOptions(bool state)
{
// we need to extend the dialog
int growSize = 60;
if (!state)
{
growSize = -growSize;
}
// alter the dialog size accordingly
int x, y, wide, tall;
GetBounds( x, y, wide, tall );
// load a new layout file depending on the state
SetMinimumSize(416, 340);
if ( state )
LoadControlSettings( "Servers/DialogGameInfo_AutoRetry.res" );
else
LoadControlSettings( "Servers/DialogGameInfo.res" );
// restore size and position as
// load control settings will override them
SetBounds( x, y, wide, tall + growSize );
// restore other properties of the dialog
PerformLayout();
m_pAutoRetryAlert->SetSelected( true );
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: Requests the right info from the server
//-----------------------------------------------------------------------------
void CDialogGameInfo::RequestInfo()
{
if ( !steamapicontext->SteamMatchmakingServers() )
return;
if ( m_iRequestRetry == 0 )
{
// reset the time at which we auto-refresh
m_iRequestRetry = system()->GetTimeMillis() + RETRY_TIME;
if ( m_hPingQuery != HSERVERQUERY_INVALID )
steamapicontext->SteamMatchmakingServers()->CancelServerQuery( m_hPingQuery );
m_hPingQuery = steamapicontext->SteamMatchmakingServers()->PingServer( m_Server.m_NetAdr.GetIP(), m_Server.m_NetAdr.GetQueryPort(), this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Called every frame, handles resending network messages
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnTick()
{
// check to see if we should perform an auto-refresh
if ( m_iRequestRetry && m_iRequestRetry < system()->GetTimeMillis() )
{
m_iRequestRetry = 0;
RequestInfo();
}
}
//-----------------------------------------------------------------------------
// Purpose: called when the server has successfully responded
//-----------------------------------------------------------------------------
void CDialogGameInfo::ServerResponded( gameserveritem_t &server )
{
if( m_Server.m_NetAdr.GetQueryPort() &&
m_Server.m_NetAdr.GetQueryPort() != server.m_NetAdr.GetQueryPort() )
{
return; // this is not the guy we talked about
}
uint16 connectionPort = m_Server.m_NetAdr.GetConnectionPort();
// FIXME(johns): This is a workaround for a steam bug, where it inproperly reads signed bytes out of the
// message. Once the upstream fix makes it into our SteamSDK, this block can be removed.
server.m_nPlayers = (uint8)(int8)server.m_nPlayers;
server.m_nBotPlayers = (uint8)(int8)server.m_nBotPlayers;
server.m_nMaxPlayers = (uint8)(int8)server.m_nMaxPlayers;
m_hPingQuery = HSERVERQUERY_INVALID;
m_Server = server;
// Preserve our connection port, since we may be querying the sourceTV port but getting a response for the real
// server. This is a limitation of the steam Matchmaking API where it doesn't properly send us a sourcetv response
// but instead the main server's response (unless we're connecting to a proxy, THEN we get the sourcetv response!)
m_Server.m_NetAdr.SetConnectionPort( connectionPort );
if ( m_bConnecting )
{
ConnectToServer();
}
else if ( m_pAutoRetry->IsSelected() && server.m_nPlayers < server.m_nMaxPlayers )
{
// there is a slot free, we can join
// make the sound
surface()->PlaySound("Servers/game_ready.wav");
// flash this window
FlashWindow();
// if it's set, connect right away
if (m_pAutoRetryJoin->IsSelected())
{
ConnectToServer();
}
}
else
{
SendPlayerQuery( server.m_NetAdr.GetIP(), server.m_NetAdr.GetQueryPort() );
}
m_bServerNotResponding = false;
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: called when a server response has timed out
//-----------------------------------------------------------------------------
void CDialogGameInfo::ServerFailedToRespond()
{
// the server didn't respond, mark that in the UI
// only mark if we haven't ever received a response
if ( !m_Server.m_bHadSuccessfulResponse )
{
m_bServerNotResponding = true;
}
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: Constructs a command to send a running game to connect to a server,
// based on the server type
//
// TODO it would be nice to push this logic into the IRunGameEngine interface; that
// way we could ask the engine itself to construct arguments in ways that fit.
// Might be worth the effort as we start to add more engines.
//-----------------------------------------------------------------------------
void CDialogGameInfo::ApplyConnectCommand( const gameserveritem_t &server )
{
char command[ 256 ];
// set the server password, if any
if ( m_szPassword[0] )
{
Q_snprintf( command, Q_ARRAYSIZE( command ), "password \"%s\"\n", m_szPassword );
g_pRunGameEngine->AddTextCommand( command );
}
// send engine command to change servers
Q_snprintf( command, Q_ARRAYSIZE( command ), "connect %s %s\n", server.m_NetAdr.GetConnectionAddressString(), m_sConnectCode.String() );
g_pRunGameEngine->AddTextCommand( command );
}
//-----------------------------------------------------------------------------
// Purpose: Constructs game options to use when running a game to connect to a server
//-----------------------------------------------------------------------------
void CDialogGameInfo::ConstructConnectArgs( char *pchOptions, int cchOptions, const gameserveritem_t &server )
{
Q_snprintf( pchOptions, cchOptions, " +connect %s", server.m_NetAdr.GetConnectionAddressString() );
if ( m_szPassword[0] )
{
Q_strcat( pchOptions, " +password \"", cchOptions );
Q_strcat( pchOptions, m_szPassword, cchOptions );
Q_strcat( pchOptions, "\"", cchOptions );
}
}
//-----------------------------------------------------------------------------
// Purpose: Connects to the server
//-----------------------------------------------------------------------------
void CDialogGameInfo::ConnectToServer()
{
m_bConnecting = false;
// check VAC status
if ( m_Server.m_bSecure && ServerBrowser().IsVACBannedFromGame( m_Server.m_nAppID ) )
{
// refuse the user
CVACBannedConnRefusedDialog *pDlg = new CVACBannedConnRefusedDialog( GetVParent(), "VACBannedConnRefusedDialog" );
pDlg->Activate();
Close();
return;
}
// check to see if we need a password
if ( m_Server.m_bPassword && !m_szPassword[0] )
{
CDialogServerPassword *box = new CDialogServerPassword(this);
box->AddActionSignalTarget(this);
box->Activate( m_Server.GetName(), 0 );
return;
}
// check the player count
if ( m_Server.m_nPlayers >= m_Server.m_nMaxPlayers )
{
// mark why we cannot connect
m_bServerFull = true;
// give them access to auto-retry options
m_bShowAutoRetryToggle = true;
InvalidateLayout();
return;
}
// tell the engine to connect
const char *gameDir = m_Server.m_szGameDir;
if (g_pRunGameEngine->IsRunning())
{
ApplyConnectCommand( m_Server );
}
else
{
char connectArgs[256];
ConstructConnectArgs( connectArgs, Q_ARRAYSIZE( connectArgs ), m_Server );
if ( ( m_Server.m_bSecure && JoiningSecureServerCall() )|| !m_Server.m_bSecure )
{
switch ( g_pRunGameEngine->RunEngine( m_Server.m_nAppID, gameDir, connectArgs ) )
{
case IRunGameEngine::k_ERunResultModNotInstalled:
{
MessageBox *dlg = new MessageBox( "#ServerBrowser_GameInfoTitle", "#ServerBrowser_ModNotInstalled" );
dlg->DoModal();
SetVisible(false);
return;
}
break;
case IRunGameEngine::k_ERunResultAppNotFound:
{
MessageBox *dlg = new MessageBox( "#ServerBrowser_GameInfoTitle", "#ServerBrowser_AppNotFound" );
dlg->DoModal();
SetVisible(false);
return;
}
break;
case IRunGameEngine::k_ERunResultNotInitialized:
{
MessageBox *dlg = new MessageBox( "#ServerBrowser_GameInfoTitle", "#ServerBrowser_NotInitialized" );
dlg->DoModal();
SetVisible(false);
return;
}
break;
case IRunGameEngine::k_ERunResultOkay:
default:
break;
};
}
}
// close this dialog
PostMessage(this, new KeyValues("Close"));
}
//-----------------------------------------------------------------------------
// Purpose: called when the current refresh list is complete
//-----------------------------------------------------------------------------
void CDialogGameInfo::RefreshComplete( EMatchMakingServerResponse response )
{
}
//-----------------------------------------------------------------------------
// Purpose: handles response from the get password dialog
//-----------------------------------------------------------------------------
void CDialogGameInfo::OnJoinServerWithPassword(const char *password)
{
// copy out the password
Q_strncpy(m_szPassword, password, sizeof(m_szPassword));
// retry connecting to the server again
OnConnect();
}
//-----------------------------------------------------------------------------
// Purpose: player list received
//-----------------------------------------------------------------------------
void CDialogGameInfo::ClearPlayerList()
{
m_pPlayerList->DeleteAllItems();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: on individual player added
//-----------------------------------------------------------------------------
void CDialogGameInfo::AddPlayerToList(const char *playerName, int score, float timePlayedSeconds)
{
if ( m_bPlayerListUpdatePending )
{
m_bPlayerListUpdatePending = false;
m_pPlayerList->RemoveAll();
}
KeyValues *player = new KeyValues("player");
player->SetString("PlayerName", playerName);
player->SetInt("Score", score);
player->SetInt("TimeSec", (int)timePlayedSeconds);
// construct a time string
int seconds = (int)timePlayedSeconds;
int minutes = seconds / 60;
int hours = minutes / 60;
seconds %= 60;
minutes %= 60;
char buf[64];
buf[0] = 0;
if (hours)
{
Q_snprintf(buf, sizeof(buf), "%dh %dm %ds", hours, minutes, seconds);
}
else if (minutes)
{
Q_snprintf(buf, sizeof(buf), "%dm %ds", minutes, seconds);
}
else
{
Q_snprintf(buf, sizeof(buf), "%ds", seconds);
}
player->SetString("Time", buf);
m_pPlayerList->AddItem(player, 0, false, true);
player->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose: Sorting function for time column
//-----------------------------------------------------------------------------
int CDialogGameInfo::PlayerTimeColumnSortFunc(ListPanel *pPanel, const ListPanelItem &p1, const ListPanelItem &p2)
{
int p1time = p1.kv->GetInt("TimeSec");
int p2time = p2.kv->GetInt("TimeSec");
if (p1time > p2time)
return -1;
if (p1time < p2time)
return 1;
return 0;
}
Reference in New Issue Copy Permalink