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.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 29985681a1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '29985681a1'
${ noResults }
source-engine/gameui/GameUI_Interface.cpp

1285 lines
38 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements all the functions exported by the GameUI dll
//
// $NoKeywords: $
//===========================================================================//
#ifdef WIN32
#if !defined( _X360 )
#include <windows.h>
#endif
#include <io.h>
#include <direct.h>
#elif defined( POSIX )
#include <sys/time.h>
#else
#error
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <tier0/dbg.h>
#ifdef SendMessage
#undef SendMessage
#endif
#include "filesystem.h"
#include "GameUI_Interface.h"
#include "Sys_Utils.h"
#include "string.h"
#include "tier0/icommandline.h"
// interface to engine
#include "EngineInterface.h"
#include "replay/ienginereplay.h"
#include "replay/ireplaysystem.h"
#include "VGuiSystemModuleLoader.h"
#include "bitmap/tgaloader.h"
#include "GameConsole.h"
#include "LoadingDialog.h"
#include "CDKeyEntryDialog.h"
#include "ModInfo.h"
#include "game/client/IGameClientExports.h"
#include "materialsystem/imaterialsystem.h"
#include "engine/imatchmaking.h"
#include "ixboxsystem.h"
#include "iachievementmgr.h"
#include "IGameUIFuncs.h"
#include <ienginevgui.h>
#include "steam/steam_api.h"
#include "BonusMapsDatabase.h"
#include "BonusMapsDialog.h"
#include "sourcevr/isourcevirtualreality.h"
// vgui2 interface
// note that GameUI project uses ..\vgui2\include, not ..\utils\vgui\include
#include "BasePanel.h"
#include <vgui/Cursor.h>
#include <KeyValues.h>
#include <vgui/ILocalize.h>
#include <vgui/IPanel.h>
#include <vgui/IScheme.h>
#include <vgui/IVGui.h>
#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui_controls/Menu.h>
#include <vgui_controls/PHandle.h>
#include "tier3/tier3.h"
#include "tier0/vcrmode.h"
#include "matsys_controls/matsyscontrols.h"
#include "steam/steam_api.h"
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif
#include "tier0/dbg.h"
#include "engine/IEngineSound.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
IGameUIFuncs *gameuifuncs = NULL;
IEngineVGui *enginevguifuncs = NULL;
IMatchmaking *matchmaking = NULL;
IXboxSystem *xboxsystem = NULL; // 360 only
vgui::ISurface *enginesurfacefuncs = NULL;
IVEngineClient *engine = NULL;
IEngineSound *enginesound = NULL;
IAchievementMgr *achievementmgr = NULL;
IEngineClientReplay *g_pEngineClientReplay = NULL;
ISourceVirtualReality *g_pSourceVR = NULL;
static CSteamAPIContext g_SteamAPIContext;
CSteamAPIContext *steamapicontext = &g_SteamAPIContext;
static CBasePanel *staticPanel = NULL;
class CGameUI;
CGameUI *g_pGameUI = NULL;
class CLoadingDialog;
vgui::DHANDLE<CLoadingDialog> g_hLoadingDialog;
vgui::VPANEL g_hLoadingBackgroundDialog = NULL;
static CGameUI g_GameUI;
static WHANDLE g_hMutex = NULL;
static WHANDLE g_hWaitMutex = NULL;
static IGameClientExports *g_pGameClientExports = NULL;
IGameClientExports *GameClientExports()
{
return g_pGameClientExports;
}
//-----------------------------------------------------------------------------
// Purpose: singleton accessor
//-----------------------------------------------------------------------------
CGameUI &GameUI()
{
return g_GameUI;
}
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CGameUI, IGameUI, GAMEUI_INTERFACE_VERSION, g_GameUI);
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGameUI::CGameUI()
{
g_pGameUI = this;
m_bTryingToLoadFriends = false;
m_iFriendsLoadPauseFrames = 0;
m_iGameIP = 0;
m_iGameConnectionPort = 0;
m_iGameQueryPort = 0;
m_bActivatedUI = false;
m_szPreviousStatusText[0] = 0;
m_bIsConsoleUI = false;
m_bHasSavedThisMenuSession = false;
m_bOpenProgressOnStart = false;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGameUI::~CGameUI()
{
g_pGameUI = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Initialization
//-----------------------------------------------------------------------------
void CGameUI::Initialize( CreateInterfaceFn factory )
{
ConnectTier1Libraries( &factory, 1 );
ConnectTier2Libraries( &factory, 1 );
ConVar_Register( FCVAR_CLIENTDLL );
ConnectTier3Libraries( &factory, 1 );
enginesound = (IEngineSound *)factory(IENGINESOUND_CLIENT_INTERFACE_VERSION, NULL);
engine = (IVEngineClient *)factory( VENGINE_CLIENT_INTERFACE_VERSION, NULL );
steamapicontext->Init();
ConVarRef var( "gameui_xbox" );
m_bIsConsoleUI = var.IsValid() && var.GetBool();
vgui::VGui_InitInterfacesList( "GameUI", &factory, 1 );
vgui::VGui_InitMatSysInterfacesList( "GameUI", &factory, 1 );
// load localization file
g_pVGuiLocalize->AddFile( "Resource/gameui_%language%.txt", "GAME", true );
// load mod info
ModInfo().LoadCurrentGameInfo();
// load localization file for kb_act.lst
g_pVGuiLocalize->AddFile( "Resource/valve_%language%.txt", "GAME", true );
enginevguifuncs = (IEngineVGui *)factory( VENGINE_VGUI_VERSION, NULL );
enginesurfacefuncs = (vgui::ISurface *)factory(VGUI_SURFACE_INTERFACE_VERSION, NULL);
gameuifuncs = (IGameUIFuncs *)factory( VENGINE_GAMEUIFUNCS_VERSION, NULL );
matchmaking = (IMatchmaking *)factory( VENGINE_MATCHMAKING_VERSION, NULL );
xboxsystem = (IXboxSystem *)factory( XBOXSYSTEM_INTERFACE_VERSION, NULL );
g_pEngineClientReplay = (IEngineClientReplay *)factory( ENGINE_REPLAY_CLIENT_INTERFACE_VERSION, NULL );
if ( ModInfo().SupportsVR() && CommandLine()->CheckParm( "-vr" ) )
{
g_pSourceVR = (ISourceVirtualReality *)factory( SOURCE_VIRTUAL_REALITY_INTERFACE_VERSION, NULL );
}
// NOTE: g_pEngineReplay intentionally not checked here
if ( !enginesurfacefuncs || !gameuifuncs || !enginevguifuncs || !xboxsystem || (IsX360() && !matchmaking) )
{
Error( "CGameUI::Initialize() failed to get necessary interfaces\n" );
}
vgui::VPANEL rootpanel = enginevguifuncs->GetPanel( PANEL_GAMEUIDLL );
// setup base panel
staticPanel = new CBasePanel();
staticPanel->SetBounds(0, 0, 400, 300 );
staticPanel->SetPaintBorderEnabled( false );
staticPanel->SetPaintBackgroundEnabled( true );
staticPanel->SetPaintEnabled( false );
staticPanel->SetVisible( true );
staticPanel->SetMouseInputEnabled( false );
staticPanel->SetKeyBoardInputEnabled( false );
staticPanel->SetParent(rootpanel);
}
void CGameUI::PostInit()
{
if ( IsX360() )
{
enginesound->PrecacheSound( "UI/buttonrollover.wav", true, true );
enginesound->PrecacheSound( "UI/buttonclick.wav", true, true );
enginesound->PrecacheSound( "UI/buttonclickrelease.wav", true, true );
enginesound->PrecacheSound( "player/suit_denydevice.wav", true, true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the specified panel as the background panel for the loading
// dialog. If NULL, default background is used. If you set a panel,
// it should be full-screen with an opaque background, and must be a VGUI popup.
//-----------------------------------------------------------------------------
void CGameUI::SetLoadingBackgroundDialog( vgui::VPANEL panel )
{
g_hLoadingBackgroundDialog = panel;
}
void CGameUI::BonusMapUnlock( const char *pchFileName, const char *pchMapName )
{
if ( !pchFileName || pchFileName[ 0 ] == '\0' ||
!pchMapName || pchMapName[ 0 ] == '\0' )
{
if ( !g_pBonusMapsDialog )
return;
g_pBonusMapsDialog->SetSelectedBooleanStatus( "lock", false );
return;
}
if ( BonusMapsDatabase()->SetBooleanStatus( "lock", pchFileName, pchMapName, false ) )
{
BonusMapsDatabase()->RefreshMapData();
if ( !g_pBonusMapsDialog )
{
// It unlocked without the bonus maps menu open, so flash the menu item
CBasePanel *pBasePanel = BasePanel();
if ( pBasePanel )
{
if ( GameUI().IsConsoleUI() )
{
if ( Q_stricmp( pchFileName, "scripts/advanced_chambers" ) == 0 )
{
pBasePanel->SetMenuItemBlinkingState( "OpenNewGameDialog", true );
}
}
else
{
pBasePanel->SetMenuItemBlinkingState( "OpenBonusMapsDialog", true );
}
}
BonusMapsDatabase()->SetBlink( true );
}
else
g_pBonusMapsDialog->RefreshData(); // Update the open dialog
}
}
void CGameUI::BonusMapComplete( const char *pchFileName, const char *pchMapName )
{
if ( !pchFileName || pchFileName[ 0 ] == '\0' ||
!pchMapName || pchMapName[ 0 ] == '\0' )
{
if ( !g_pBonusMapsDialog )
return;
g_pBonusMapsDialog->SetSelectedBooleanStatus( "complete", true );
BonusMapsDatabase()->RefreshMapData();
g_pBonusMapsDialog->RefreshData();
return;
}
if ( BonusMapsDatabase()->SetBooleanStatus( "complete", pchFileName, pchMapName, true ) )
{
BonusMapsDatabase()->RefreshMapData();
// Update the open dialog
if ( g_pBonusMapsDialog )
g_pBonusMapsDialog->RefreshData();
}
}
void CGameUI::BonusMapChallengeUpdate( const char *pchFileName, const char *pchMapName, const char *pchChallengeName, int iBest )
{
if ( !pchFileName || pchFileName[ 0 ] == '\0' ||
!pchMapName || pchMapName[ 0 ] == '\0' ||
!pchChallengeName || pchChallengeName[ 0 ] == '\0' )
{
return;
}
else
{
if ( BonusMapsDatabase()->UpdateChallengeBest( pchFileName, pchMapName, pchChallengeName, iBest ) )
{
// The challenge best changed, so write it to the file
BonusMapsDatabase()->WriteSaveData();
BonusMapsDatabase()->RefreshMapData();
// Update the open dialog
if ( g_pBonusMapsDialog )
g_pBonusMapsDialog->RefreshData();
}
}
}
void CGameUI::BonusMapChallengeNames( char *pchFileName, char *pchMapName, char *pchChallengeName )
{
if ( !pchFileName || !pchMapName || !pchChallengeName )
return;
BonusMapsDatabase()->GetCurrentChallengeNames( pchFileName, pchMapName, pchChallengeName );
}
void CGameUI::BonusMapChallengeObjectives( int &iBronze, int &iSilver, int &iGold )
{
BonusMapsDatabase()->GetCurrentChallengeObjectives( iBronze, iSilver, iGold );
}
void CGameUI::BonusMapDatabaseSave( void )
{
BonusMapsDatabase()->WriteSaveData();
}
int CGameUI::BonusMapNumAdvancedCompleted( void )
{
return BonusMapsDatabase()->NumAdvancedComplete();
}
void CGameUI::BonusMapNumMedals( int piNumMedals[ 3 ] )
{
BonusMapsDatabase()->NumMedals( piNumMedals );
}
//-----------------------------------------------------------------------------
// Purpose: connects to client interfaces
//-----------------------------------------------------------------------------
void CGameUI::Connect( CreateInterfaceFn gameFactory )
{
g_pGameClientExports = (IGameClientExports *)gameFactory(GAMECLIENTEXPORTS_INTERFACE_VERSION, NULL);
achievementmgr = engine->GetAchievementMgr();
if (!g_pGameClientExports)
{
Error("CGameUI::Initialize() failed to get necessary interfaces\n");
}
m_GameFactory = gameFactory;
}
//-----------------------------------------------------------------------------
// Purpose: Callback function; sends platform Shutdown message to specified window
//-----------------------------------------------------------------------------
int __stdcall SendShutdownMsgFunc(WHANDLE hwnd, int lparam)
{
Sys_PostMessage(hwnd, Sys_RegisterWindowMessage("ShutdownValvePlatform"), 0, 1);
return 1;
}
//-----------------------------------------------------------------------------
// Purpose: Searches for GameStartup*.mp3 files in the sound/ui folder and plays one
//-----------------------------------------------------------------------------
void CGameUI::PlayGameStartupSound()
{
if ( IsX360() )
return;
if ( CommandLine()->FindParm( "-nostartupsound" ) )
return;
FileFindHandle_t fh;
CUtlVector<char *> fileNames;
char path[ 512 ];
bool bHolidayFound = false;
// only want to run the holiday check for TF2
const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );
if ( ( Q_stricmp( pGameName, "tf" ) == 0 ) || ( Q_stricmp( pGameName, "tf_beta" ) == 0 ) )
{
// check for a holiday sound file
const char *pszHoliday = NULL;
if ( GameClientExports() )
{
pszHoliday = GameClientExports()->GetHolidayString();
if ( pszHoliday && pszHoliday[0] )
{
Q_snprintf( path, sizeof( path ), "sound/ui/holiday/gamestartup_%s*.mp3", pszHoliday );
Q_FixSlashes( path );
char const *fn = g_pFullFileSystem->FindFirstEx( path, "MOD", &fh );
{
if ( fn )
{
bHolidayFound = true;
}
}
}
}
}
// only want to do this if we haven't found a holiday file
if ( !bHolidayFound )
{
Q_snprintf( path, sizeof( path ), "sound/ui/gamestartup*.mp3" );
Q_FixSlashes( path );
}
char const *fn = g_pFullFileSystem->FindFirstEx( path, "MOD", &fh );
if ( fn )
{
do
{
char ext[ 10 ];
Q_ExtractFileExtension( fn, ext, sizeof( ext ) );
if ( !Q_stricmp( ext, "mp3" ) )
{
char temp[ 512 ];
if ( bHolidayFound )
{
Q_snprintf( temp, sizeof( temp ), "ui/holiday/%s", fn );
}
else
{
Q_snprintf( temp, sizeof( temp ), "ui/%s", fn );
}
char *found = new char[ strlen( temp ) + 1 ];
Q_strncpy( found, temp, strlen( temp ) + 1 );
Q_FixSlashes( found );
fileNames.AddToTail( found );
}
fn = g_pFullFileSystem->FindNext( fh );
} while ( fn );
g_pFullFileSystem->FindClose( fh );
}
// did we find any?
if ( fileNames.Count() > 0 )
{
#ifdef WIN32
SYSTEMTIME SystemTime;
GetSystemTime( &SystemTime );
int index = SystemTime.wMilliseconds % fileNames.Count();
#else
struct timeval tm;
gettimeofday( &tm, NULL );
int index = tm.tv_usec/1000 % fileNames.Count();
#endif
if ( fileNames.IsValidIndex( index ) && fileNames[index] )
{
// Play the Saxxy music if we're in saxxy mode.
#if defined( SAXXYMAINMENU_ENABLED )
bool bIsTF = false;
const char *pGameDir = engine->GetGameDirectory();
if ( pGameDir )
{
// Is the game TF?
const int nStrLen = V_strlen( pGameDir );
bIsTF = nStrLen
&& nStrLen >= 2 &&
pGameDir[nStrLen-2] == 't' &&
pGameDir[nStrLen-1] == 'f';
}
// escape chars "*#" make it stream, and be affected by snd_musicvolume
const char *pSoundFile = bIsTF ? "ui/holiday/gamestartup_saxxy.mp3" : fileNames[index];
#else
const char *pSoundFile = fileNames[index];
#endif
char found[ 512 ];
Q_snprintf( found, sizeof( found ), "play *#%s", pSoundFile );
engine->ClientCmd_Unrestricted( found );
}
fileNames.PurgeAndDeleteElements();
}
}
//-----------------------------------------------------------------------------
// Purpose: Called to setup the game UI
//-----------------------------------------------------------------------------
void CGameUI::Start()
{
// determine Steam location for configuration
if ( !FindPlatformDirectory( m_szPlatformDir, sizeof( m_szPlatformDir ) ) )
return;
if ( IsPC() )
{
// setup config file directory
char szConfigDir[512];
Q_strncpy( szConfigDir, m_szPlatformDir, sizeof( szConfigDir ) );
Q_strncat( szConfigDir, "config", sizeof( szConfigDir ), COPY_ALL_CHARACTERS );
Msg( "Steam config directory: %s\n", szConfigDir );
g_pFullFileSystem->AddSearchPath(szConfigDir, "CONFIG");
g_pFullFileSystem->CreateDirHierarchy("", "CONFIG");
// user dialog configuration
vgui::system()->SetUserConfigFile("InGameDialogConfig.vdf", "CONFIG");
g_pFullFileSystem->AddSearchPath( "platform", "PLATFORM" );
}
// localization
g_pVGuiLocalize->AddFile( "Resource/platform_%language%.txt");
g_pVGuiLocalize->AddFile( "Resource/vgui_%language%.txt");
Sys_SetLastError( SYS_NO_ERROR );
if ( IsPC() )
{
if ( !IsPosix() )
{
// Alfred says this is really, really old code that does some wacky crap that only
// happened in the first version of HL and it's the only game that does this and
// it was a steam testing type thing and we don't need to do it on Posix, etc.
g_hMutex = Sys_CreateMutex( "ValvePlatformUIMutex" );
g_hWaitMutex = Sys_CreateMutex( "ValvePlatformWaitMutex" );
if ( g_hMutex == 0 || g_hWaitMutex == 0 || Sys_GetLastError() == SYS_ERROR_INVALID_HANDLE )
{
// error, can't get handle to mutex
if (g_hMutex)
{
Sys_ReleaseMutex(g_hMutex);
}
if (g_hWaitMutex)
{
Sys_ReleaseMutex(g_hWaitMutex);
}
g_hMutex = NULL;
g_hWaitMutex = NULL;
Error("Steam Error: Could not access Steam, bad mutex\n");
return;
}
unsigned int waitResult = Sys_WaitForSingleObject(g_hMutex, 0);
if (!(waitResult == SYS_WAIT_OBJECT_0 || waitResult == SYS_WAIT_ABANDONED))
{
// mutex locked, need to deactivate Steam (so we have the Friends/ServerBrowser data files)
// get the wait mutex, so that Steam.exe knows that we're trying to acquire ValveTrackerMutex
waitResult = Sys_WaitForSingleObject(g_hWaitMutex, 0);
#ifdef WIN32
if (waitResult == SYS_WAIT_OBJECT_0 || waitResult == SYS_WAIT_ABANDONED)
{
Sys_EnumWindows(SendShutdownMsgFunc, 1);
}
#endif
}
}
// Delay playing the startup music until the first frame
m_bPlayGameStartupSound = true;
// now we are set up to check every frame to see if we can friends/server browser
m_bTryingToLoadFriends = true;
m_iFriendsLoadPauseFrames = 1;
}
}
//-----------------------------------------------------------------------------
// Purpose: Validates the user has a cdkey in the registry
//-----------------------------------------------------------------------------
void CGameUI::ValidateCDKey()
{
// this check is disabled, since we have no plans for an offline version of hl2
#if 0
//!! hack, write out a regkey for now so developers don't have to type it in
//!! undo this before release
vgui::system()->SetRegistryString("HKEY_CURRENT_USER\\Software\\Valve\\Source\\Settings\\EncryptedCDKey", "QOgi:JXrJj<Eb8abkESf4Pg;OfofJwDzRsyH>AdjtyPnV[FB");
// see what's in the registry
if (!CCDKeyEntryDialog::IsValidWeakCDKeyInRegistry())
{
m_hCDKeyEntryDialog = new CCDKeyEntryDialog(NULL, false);
m_hCDKeyEntryDialog->Activate();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Finds which directory the platform resides in
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGameUI::FindPlatformDirectory(char *platformDir, int bufferSize)
{
platformDir[0] = '\0';
if ( platformDir[0] == '\0' )
{
// we're not under steam, so setup using path relative to game
if ( IsPC() )
{
#ifdef WIN32
if ( ::GetModuleFileName( ( HINSTANCE )GetModuleHandle( NULL ), platformDir, bufferSize ) )
{
char *lastslash = strrchr(platformDir, '\\'); // this should be just before the filename
if ( lastslash )
{
*lastslash = 0;
Q_strncat(platformDir, "\\platform\\", bufferSize, COPY_ALL_CHARACTERS );
return true;
}
}
#else
if ( getcwd( platformDir, bufferSize ) )
{
V_AppendSlash( platformDir, bufferSize );
Q_strncat(platformDir, "platform", bufferSize, COPY_ALL_CHARACTERS );
V_AppendSlash( platformDir, bufferSize );
return true;
}
#endif
}
else
{
// xbox fetches the platform path from exisiting platform search path
// path to executeable is not correct for xbox remote configuration
if ( g_pFullFileSystem->GetSearchPath( "PLATFORM", false, platformDir, bufferSize ) )
{
char *pSeperator = strchr( platformDir, ';' );
if ( pSeperator )
*pSeperator = '\0';
return true;
}
}
Error( "Unable to determine platform directory\n" );
return false;
}
return (platformDir[0] != 0);
}
//-----------------------------------------------------------------------------
// Purpose: Called to Shutdown the game UI system
//-----------------------------------------------------------------------------
void CGameUI::Shutdown()
{
// notify all the modules of Shutdown
g_VModuleLoader.ShutdownPlatformModules();
// unload the modules them from memory
g_VModuleLoader.UnloadPlatformModules();
ModInfo().FreeModInfo();
// release platform mutex
// close the mutex
if (g_hMutex)
{
Sys_ReleaseMutex(g_hMutex);
}
if (g_hWaitMutex)
{
Sys_ReleaseMutex(g_hWaitMutex);
}
BonusMapsDatabase()->WriteSaveData();
steamapicontext->Clear();
ConVar_Unregister();
DisconnectTier3Libraries();
DisconnectTier2Libraries();
DisconnectTier1Libraries();
}
//-----------------------------------------------------------------------------
// Purpose: just wraps an engine call to activate the gameUI
//-----------------------------------------------------------------------------
void CGameUI::ActivateGameUI()
{
engine->ExecuteClientCmd("gameui_activate");
}
//-----------------------------------------------------------------------------
// Purpose: just wraps an engine call to hide the gameUI
//-----------------------------------------------------------------------------
void CGameUI::HideGameUI()
{
engine->ExecuteClientCmd("gameui_hide");
}
//-----------------------------------------------------------------------------
// Purpose: Toggle allowing the engine to hide the game UI with the escape key
//-----------------------------------------------------------------------------
void CGameUI::PreventEngineHideGameUI()
{
engine->ExecuteClientCmd("gameui_preventescape");
}
//-----------------------------------------------------------------------------
// Purpose: Toggle allowing the engine to hide the game UI with the escape key
//-----------------------------------------------------------------------------
void CGameUI::AllowEngineHideGameUI()
{
engine->ExecuteClientCmd("gameui_allowescape");
}
//-----------------------------------------------------------------------------
// Purpose: Activate the game UI
//-----------------------------------------------------------------------------
void CGameUI::OnGameUIActivated()
{
m_bActivatedUI = true;
// hide/show the main panel to Activate all game ui
staticPanel->SetVisible( true );
// pause the server in single player
if ( engine->GetMaxClients() <= 1 )
{
engine->ClientCmd_Unrestricted( "setpause" );
}
SetSavedThisMenuSession( false );
// notify taskbar
BasePanel()->OnGameUIActivated();
if ( GameClientExports() )
{
const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );
// only want to run this for TF2
if ( ( Q_stricmp( pGameName, "tf" ) == 0 ) || ( Q_stricmp( pGameName, "tf_beta" ) == 0 ) )
{
GameClientExports()->OnGameUIActivated();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Hides the game ui, in whatever state it's in
//-----------------------------------------------------------------------------
void CGameUI::OnGameUIHidden()
{
if ( GameClientExports() )
{
const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );
// only want to run this for TF2
if ( ( Q_stricmp( pGameName, "tf" ) == 0 ) || ( Q_stricmp( pGameName, "tf_beta" ) == 0 ) )
{
GameClientExports()->OnGameUIHidden();
}
}
// unpause the game when leaving the UI
if ( engine->GetMaxClients() <= 1 )
{
engine->ClientCmd_Unrestricted("unpause");
}
BasePanel()->OnGameUIHidden();
}
//-----------------------------------------------------------------------------
// Purpose: paints all the vgui elements
//-----------------------------------------------------------------------------
void CGameUI::RunFrame()
{
if ( IsX360() && m_bOpenProgressOnStart )
{
StartProgressBar();
m_bOpenProgressOnStart = false;
}
// resize the background panel to the screen size
int wide, tall;
vgui::surface()->GetScreenSize(wide, tall);
staticPanel->SetSize(wide,tall);
// Run frames
g_VModuleLoader.RunFrame();
BasePanel()->RunFrame();
// Play the start-up music the first time we run frame
if ( IsPC() && m_bPlayGameStartupSound )
{
PlayGameStartupSound();
m_bPlayGameStartupSound = false;
}
if ( IsPC() && ( ( IsPosix() && m_bTryingToLoadFriends ) ||
( m_bTryingToLoadFriends && m_iFriendsLoadPauseFrames-- < 1 && g_hMutex && g_hWaitMutex ) ) )
{
// try and load Steam platform files
unsigned int waitResult = Sys_WaitForSingleObject(g_hMutex, 0);
if ( IsPosix() || ( waitResult == SYS_WAIT_OBJECT_0 || waitResult == SYS_WAIT_ABANDONED ))
{
// we got the mutex, so load Friends/Serverbrowser
// clear the loading flag
m_bTryingToLoadFriends = false;
g_VModuleLoader.LoadPlatformModules(&m_GameFactory, 1, false);
// release the wait mutex
if ( !IsPosix() )
Sys_ReleaseMutex(g_hWaitMutex);
// notify the game of our game name
const char *fullGamePath = engine->GetGameDirectory();
const char *pathSep = strrchr( fullGamePath, '/' );
if ( !pathSep )
{
pathSep = strrchr( fullGamePath, '\\' );
}
if ( pathSep )
{
KeyValues *pKV = new KeyValues("ActiveGameName" );
pKV->SetString( "name", pathSep + 1 );
pKV->SetInt( "appid", engine->GetAppID() );
KeyValues *modinfo = new KeyValues("ModInfo");
if ( modinfo->LoadFromFile( g_pFullFileSystem, "gameinfo.txt" ) )
{
pKV->SetString( "game", modinfo->GetString( "game", "" ) );
}
modinfo->deleteThis();
g_VModuleLoader.PostMessageToAllModules( pKV );
}
// notify the ui of a game connect if we're already in a game
if (m_iGameIP)
{
SendConnectedToGameMessage();
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when the game connects to a server
//-----------------------------------------------------------------------------
void CGameUI::OLD_OnConnectToServer(const char *game, int IP, int port)
{
// Nobody should use this anymore because the query port and the connection port can be different.
// Use OnConnectToServer2 instead.
Assert( false );
OnConnectToServer2( game, IP, port, port );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the game connects to a server
//-----------------------------------------------------------------------------
void CGameUI::OnConnectToServer2(const char *game, int IP, int connectionPort, int queryPort)
{
m_iGameIP = IP;
m_iGameConnectionPort = connectionPort;
m_iGameQueryPort = queryPort;
SendConnectedToGameMessage();
}
void CGameUI::SendConnectedToGameMessage()
{
KeyValues *kv = new KeyValues( "ConnectedToGame" );
kv->SetInt( "ip", m_iGameIP );
kv->SetInt( "connectionport", m_iGameConnectionPort );
kv->SetInt( "queryport", m_iGameQueryPort );
g_VModuleLoader.PostMessageToAllModules( kv );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the game disconnects from a server
//-----------------------------------------------------------------------------
void CGameUI::OnDisconnectFromServer( uint8 eSteamLoginFailure )
{
m_iGameIP = 0;
m_iGameConnectionPort = 0;
m_iGameQueryPort = 0;
g_VModuleLoader.PostMessageToAllModules(new KeyValues("DisconnectedFromGame"));
if ( eSteamLoginFailure == STEAMLOGINFAILURE_NOSTEAMLOGIN )
{
if ( g_hLoadingDialog )
{
g_hLoadingDialog->DisplayNoSteamConnectionError();
}
}
else if ( eSteamLoginFailure == STEAMLOGINFAILURE_VACBANNED )
{
if ( g_hLoadingDialog )
{
g_hLoadingDialog->DisplayVACBannedError();
}
}
else if ( eSteamLoginFailure == STEAMLOGINFAILURE_LOGGED_IN_ELSEWHERE )
{
if ( g_hLoadingDialog )
{
g_hLoadingDialog->DisplayLoggedInElsewhereError();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: activates the loading dialog on level load start
//-----------------------------------------------------------------------------
void CGameUI::OnLevelLoadingStarted( bool bShowProgressDialog )
{
g_VModuleLoader.PostMessageToAllModules( new KeyValues( "LoadingStarted" ) );
// notify
BasePanel()->OnLevelLoadingStarted();
if ( bShowProgressDialog )
{
StartProgressBar();
}
// Don't play the start game sound if this happens before we get to the first frame
m_bPlayGameStartupSound = false;
}
//-----------------------------------------------------------------------------
// Purpose: closes any level load dialog
//-----------------------------------------------------------------------------
void CGameUI::OnLevelLoadingFinished(bool bError, const char *failureReason, const char *extendedReason)
{
StopProgressBar( bError, failureReason, extendedReason );
// notify all the modules
g_VModuleLoader.PostMessageToAllModules( new KeyValues( "LoadingFinished" ) );
// hide the UI
HideGameUI();
// notify
BasePanel()->OnLevelLoadingFinished();
}
//-----------------------------------------------------------------------------
// Purpose: Updates progress bar
// Output : Returns true if screen should be redrawn
//-----------------------------------------------------------------------------
bool CGameUI::UpdateProgressBar(float progress, const char *statusText)
{
// if either the progress bar or the status text changes, redraw the screen
bool bRedraw = false;
if ( ContinueProgressBar( progress ) )
{
bRedraw = true;
}
if ( SetProgressBarStatusText( statusText ) )
{
bRedraw = true;
}
return bRedraw;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameUI::StartProgressBar()
{
if ( !g_hLoadingDialog.Get() )
{
g_hLoadingDialog = new CLoadingDialog(staticPanel);
}
// open a loading dialog
m_szPreviousStatusText[0] = 0;
g_hLoadingDialog->SetProgressPoint(0.0f);
g_hLoadingDialog->Open();
}
//-----------------------------------------------------------------------------
// Purpose: returns true if the screen should be updated
//-----------------------------------------------------------------------------
bool CGameUI::ContinueProgressBar( float progressFraction )
{
if (!g_hLoadingDialog.Get())
return false;
g_hLoadingDialog->Activate();
return g_hLoadingDialog->SetProgressPoint(progressFraction);
}
//-----------------------------------------------------------------------------
// Purpose: stops progress bar, displays error if necessary
//-----------------------------------------------------------------------------
void CGameUI::StopProgressBar(bool bError, const char *failureReason, const char *extendedReason)
{
if (!g_hLoadingDialog.Get() && bError)
{
g_hLoadingDialog = new CLoadingDialog(staticPanel);
}
if (!g_hLoadingDialog.Get())
return;
if ( !IsX360() && bError )
{
// turn the dialog to error display mode
g_hLoadingDialog->DisplayGenericError(failureReason, extendedReason);
}
else
{
// close loading dialog
g_hLoadingDialog->Close();
g_hLoadingDialog = NULL;
}
// should update the background to be in a transition here
}
//-----------------------------------------------------------------------------
// Purpose: sets loading info text
//-----------------------------------------------------------------------------
bool CGameUI::SetProgressBarStatusText(const char *statusText)
{
if (!g_hLoadingDialog.Get())
return false;
if (!statusText)
return false;
if (!stricmp(statusText, m_szPreviousStatusText))
return false;
g_hLoadingDialog->SetStatusText(statusText);
Q_strncpy(m_szPreviousStatusText, statusText, sizeof(m_szPreviousStatusText));
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameUI::SetSecondaryProgressBar(float progress /* range [0..1] */)
{
if (!g_hLoadingDialog.Get())
return;
g_hLoadingDialog->SetSecondaryProgress(progress);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameUI::SetSecondaryProgressBarText(const char *statusText)
{
if (!g_hLoadingDialog.Get())
return;
g_hLoadingDialog->SetSecondaryProgressText(statusText);
}
//-----------------------------------------------------------------------------
// Purpose: Returns prev settings
//-----------------------------------------------------------------------------
bool CGameUI::SetShowProgressText( bool show )
{
if (!g_hLoadingDialog.Get())
return false;
return g_hLoadingDialog->SetShowProgressText( show );
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we're currently playing the game
//-----------------------------------------------------------------------------
bool CGameUI::IsInLevel()
{
const char *levelName = engine->GetLevelName();
if (levelName && levelName[0] && !engine->IsLevelMainMenuBackground())
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we're at the main menu and a background level is loaded
//-----------------------------------------------------------------------------
bool CGameUI::IsInBackgroundLevel()
{
const char *levelName = engine->GetLevelName();
if (levelName && levelName[0] && engine->IsLevelMainMenuBackground())
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we're in a multiplayer game
//-----------------------------------------------------------------------------
bool CGameUI::IsInMultiplayer()
{
return (IsInLevel() && engine->GetMaxClients() > 1);
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we're playing back a replay
//-----------------------------------------------------------------------------
bool CGameUI::IsInReplay()
{
return g_pEngineClientReplay && g_pEngineClientReplay->IsPlayingReplayDemo();
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we're console ui
//-----------------------------------------------------------------------------
bool CGameUI::IsConsoleUI()
{
return m_bIsConsoleUI;
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we've saved without closing the menu
//-----------------------------------------------------------------------------
bool CGameUI::HasSavedThisMenuSession()
{
return m_bHasSavedThisMenuSession;
}
void CGameUI::SetSavedThisMenuSession( bool bState )
{
m_bHasSavedThisMenuSession = bState;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameUI::ShowNewGameDialog( int chapter )
{
char val[32];
Q_snprintf( val, sizeof(val), "%d", chapter);
staticPanel->OnOpenNewGameDialog(val);
}
//-----------------------------------------------------------------------------
// Purpose: Makes the loading background dialog visible, if one has been set
//-----------------------------------------------------------------------------
void CGameUI::ShowLoadingBackgroundDialog()
{
if ( g_hLoadingBackgroundDialog )
{
vgui::ipanel()->SetParent( g_hLoadingBackgroundDialog, staticPanel->GetVPanel() );
vgui::ipanel()->PerformApplySchemeSettings( g_hLoadingBackgroundDialog );
vgui::ipanel()->SetVisible( g_hLoadingBackgroundDialog, true );
vgui::ipanel()->MoveToFront( g_hLoadingBackgroundDialog );
vgui::ipanel()->SendMessage( g_hLoadingBackgroundDialog, new KeyValues( "activate" ), staticPanel->GetVPanel() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Hides the loading background dialog, if one has been set
//-----------------------------------------------------------------------------
void CGameUI::HideLoadingBackgroundDialog()
{
if ( g_hLoadingBackgroundDialog )
{
vgui::ipanel()->SetParent( g_hLoadingBackgroundDialog, NULL );
vgui::ipanel()->SetVisible( g_hLoadingBackgroundDialog, false );
vgui::ipanel()->MoveToBack( g_hLoadingBackgroundDialog );
vgui::ipanel()->SendMessage( g_hLoadingBackgroundDialog, new KeyValues( "deactivate" ), staticPanel->GetVPanel() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether a loading background dialog has been set
//-----------------------------------------------------------------------------
bool CGameUI::HasLoadingBackgroundDialog()
{
return ( 0 != g_hLoadingBackgroundDialog );
}
//-----------------------------------------------------------------------------
// Purpose: Xbox 360 calls from engine to GameUI
//-----------------------------------------------------------------------------
void CGameUI::SessionNotification( const int notification, const int param )
{
BasePanel()->SessionNotification( notification, param );
}
void CGameUI::SystemNotification( const int notification )
{
BasePanel()->SystemNotification( notification );
}
void CGameUI::ShowMessageDialog( const uint nType, vgui::Panel *pOwner )
{
BasePanel()->ShowMessageDialog( nType, pOwner );
}
void CGameUI::CloseMessageDialog( const uint nType )
{
BasePanel()->CloseMessageDialog( nType );
}
void CGameUI::UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int nTeam, byte cVoiceState, int nPlayersNeeded, bool bHost )
{
BasePanel()->UpdatePlayerInfo( nPlayerId, pName, nTeam, cVoiceState, nPlayersNeeded, bHost );
}
void CGameUI::SessionSearchResult( int searchIdx, void *pHostData, XSESSION_SEARCHRESULT *pResult, int ping )
{
BasePanel()->SessionSearchResult( searchIdx, pHostData, pResult, ping );
}
void CGameUI::OnCreditsFinished( void )
{
BasePanel()->OnCreditsFinished();
}
bool CGameUI::ValidateStorageDevice( int *pStorageDeviceValidated )
{
return BasePanel()->ValidateStorageDevice( pStorageDeviceValidated );
}
void CGameUI::SetProgressOnStart()
{
m_bOpenProgressOnStart = true;
}
void CGameUI::OnConfirmQuit( void )
{
BasePanel()->OnOpenQuitConfirmationDialog();
}
bool CGameUI::IsMainMenuVisible( void )
{
CBasePanel *pBasePanel = BasePanel();
if ( pBasePanel )
return (pBasePanel->IsVisible() && pBasePanel->GetMenuAlpha() > 0 );
return false;
}
// Client DLL is providing us with a panel that it wants to replace the main menu with
void CGameUI::SetMainMenuOverride( vgui::VPANEL panel )
{
CBasePanel *pBasePanel = BasePanel();
if ( pBasePanel )
{
pBasePanel->SetMainMenuOverride( panel );
}
}
// Client DLL is telling us that a main menu command was issued, probably from its custom main menu panel
void CGameUI::SendMainMenuCommand( const char *pszCommand )
{
CBasePanel *pBasePanel = BasePanel();
if ( pBasePanel )
{
pBasePanel->RunMenuCommand( pszCommand );
}
}