csgo-2018-source/engine/host_state.cpp

//========= Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: Runs the state machine for the host & server
//
// $NoKeywords: $
//=============================================================================//


#include "host_state.h"
#include "eiface.h"
#include "quakedef.h"
#include "server.h"
#include "sv_main.h"
#include "host_cmd.h"
#include "host.h"
#include "screen.h"
#include "icliententity.h"
#include "icliententitylist.h"
#include "client.h"
#include "host_jmp.h"
#include "cdll_engine_int.h"
#include "tier0/vprof.h"
#include "tier0/icommandline.h"
#include "filesystem_engine.h"
#include "zone.h"
#include "iengine.h"
#include "snd_audio_source.h"
#include "sv_steamauth.h"
#ifndef DEDICATED
#include "vgui_baseui_interface.h"
#endif
#include "sv_plugin.h"
#include "cl_main.h"
#include "sv_steamauth.h"
#include "datacache/imdlcache.h"
#include "sys_dll.h"
#include "testscriptmgr.h"
#include "cvar.h"
#include "MapReslistGenerator.h"
#include "filesystem/IQueuedLoader.h"
#include "matchmaking/imatchframework.h"
#ifdef _PS3
#include "tls_ps3.h"
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

extern bool		g_bAbortServerSet;
#ifndef DEDICATED
extern ConVar	reload_materials;
#endif

typedef enum 
{
	HS_NEW_GAME = 0,
	HS_LOAD_GAME,
	HS_CHANGE_LEVEL_SP,
	HS_CHANGE_LEVEL_MP,
	HS_RUN,
	HS_GAME_SHUTDOWN,
	HS_SHUTDOWN,
	HS_RESTART,
} HOSTSTATES;

// a little class that manages the state machine for the host
class CHostState
{
public:
				CHostState();
	void		Init();
	void		FrameUpdate( float time );
	void		SetNextState( HOSTSTATES nextState );

	void		RunGameInit();

	void		SetState( HOSTSTATES newState, bool clearNext );
	void		GameShutdown();

	void		State_NewGame();
	void		State_LoadGame();
	void		State_ChangeLevelMP();
	void		State_ChangeLevelSP();
	void		State_Run( float time );
	void		State_GameShutdown();
	void		State_Shutdown();
	void		State_Restart();

	bool		IsGameShuttingDown();

	void		RememberLocation();
	void		OnClientConnected(); // Client fully connected
	void		OnClientDisconnected(); // Client disconnected

	HOSTSTATES	m_currentState;
	HOSTSTATES	m_nextState;
	Vector		m_vecLocation;
	QAngle		m_angLocation;
	char		m_levelName[256];
	char		m_mapGroupName[256];
	char		m_landmarkName[256];
	char		m_saveName[256];
	float		m_flShortFrameTime;		// run a few one-tick frames to avoid large timesteps while loading assets

	bool		m_activeGame;
	bool		m_bRememberLocation;
	bool		m_bBackgroundLevel;
	bool		m_bWaitingForConnection;
	bool		m_bLetToolsOverrideLoadGameEnts;	// During a load game, this tells Foundry to override ents that are selected in Hammer.
	bool		m_bSplitScreenConnect;
	bool		m_bGameHasShutDownAndFlushedMemory;	// This is false once we load a map into memory, and set to true once the map is unloaded and all memory flushed
	bool		m_bWorkshopMapDownloadPending;
};

static bool Host_ValidGame( void );
static CHostState	g_HostState;


//-----------------------------------------------------------------------------
// external API for manipulating the host state machine
//-----------------------------------------------------------------------------
void HostState_Init()
{
	g_HostState.Init();
}

void HostState_Frame( float time )
{
	g_HostState.FrameUpdate( time );
}

void HostState_RunGameInit()
{
	g_HostState.RunGameInit();
	g_ServerGlobalVariables.bMapLoadFailed = false;
}

//-----------------------------------------------------------------------------
// start a new game as soon as possible
//-----------------------------------------------------------------------------
void HostState_NewGame( char const *pMapName, bool remember_location, bool background, bool bSplitScreenConnect )
{
	char szMapName[_MAX_PATH];
	Q_StripExtension( pMapName, szMapName, sizeof(szMapName) );
	Q_strncpy( g_HostState.m_levelName, szMapName, sizeof( g_HostState.m_levelName ) );
	Q_FixSlashes( g_HostState.m_levelName, '/' ); // Store with forward slashes internally to be consistent. 

	g_HostState.m_landmarkName[0] = 0;
	g_HostState.m_bRememberLocation = remember_location;
	g_HostState.m_bWaitingForConnection = true;
	g_HostState.m_bBackgroundLevel = background;
	g_HostState.m_bSplitScreenConnect = bSplitScreenConnect;
	if ( remember_location )
	{
		g_HostState.RememberLocation();
	}
	g_HostState.SetNextState( HS_NEW_GAME );
}

//-----------------------------------------------------------------------------
// load a new game as soon as possible
//-----------------------------------------------------------------------------
void HostState_LoadGame( char const *pSaveFileName, bool remember_location, bool bLetToolsOverrideLoadGameEnts )
{
#ifndef DEDICATED
	// Make sure the freaking save file exists....
	if ( !saverestore->SaveFileExists( pSaveFileName ) )
	{
			Warning("Save file %s can't be found!\n", pSaveFileName );
			SCR_EndLoadingPlaque();
			return;
	}

	Q_strncpy( g_HostState.m_saveName, pSaveFileName, sizeof( g_HostState.m_saveName )  );

	// Tell the game .dll we are loading another game
	serverGameDLL->PreSaveGameLoaded( pSaveFileName, sv.IsActive() );

	g_HostState.m_bRememberLocation = remember_location;
	g_HostState.m_bBackgroundLevel = false;
	g_HostState.m_bWaitingForConnection = true;
	g_HostState.m_bSplitScreenConnect = false;
	g_HostState.m_bLetToolsOverrideLoadGameEnts = bLetToolsOverrideLoadGameEnts;
	if ( remember_location )
	{
		g_HostState.RememberLocation();
	}

	g_HostState.SetNextState( HS_LOAD_GAME );
#endif
}

// change level (single player style - smooth transition)
void HostState_ChangeLevelSP( char const *pNewLevel, char const *pLandmarkName )
{
	Q_strncpy( g_HostState.m_levelName, pNewLevel, sizeof( g_HostState.m_levelName ) );
	Q_FixSlashes( g_HostState.m_levelName, '/' ); // Store with forward slashes internally to be consistent. 
	Q_strncpy( g_HostState.m_landmarkName, pLandmarkName, sizeof( g_HostState.m_landmarkName ) );
	g_HostState.SetNextState( HS_CHANGE_LEVEL_SP );
}

// change level (multiplayer style - respawn all connected clients)
void HostState_ChangeLevelMP( char const *pNewLevel, char const *pLandmarkName )
{
	Steam3Server().NotifyOfLevelChange();

	Q_strncpy( g_HostState.m_levelName, pNewLevel, sizeof( g_HostState.m_levelName ) );
	Q_FixSlashes( g_HostState.m_levelName, '/' ); // Store with forward slashes internally to be consistent. 
	Q_strncpy( g_HostState.m_landmarkName, pLandmarkName, sizeof( g_HostState.m_landmarkName ) );

	PublishedFileId_t id = serverGameDLL->GetUGCMapFileID( pNewLevel );
	if ( sv.IsDedicated() && id != 0 )
	{
		// If we're hosting a workshop map, don't change level until we've made sure we're hosting the latest version.
		serverGameDLL->UpdateUGCMap( id );
		g_HostState.m_bWorkshopMapDownloadPending = true;
	}	
	else
	{
		g_HostState.SetNextState( HS_CHANGE_LEVEL_MP );
	}
}

// set the mapgroup name
void HostState_SetMapGroupName( char const *pMapGroupName )
{
	if ( pMapGroupName )
	{
		V_strncpy( g_HostState.m_mapGroupName, pMapGroupName, sizeof ( g_HostState.m_mapGroupName ) );
		sv.SetMapGroupName( pMapGroupName );
	}
}

// shutdown the game as soon as possible
void HostState_GameShutdown()
{
	Steam3Server().NotifyOfLevelChange();

	// This will get called during shutdown, ignore it.
	if ( g_HostState.m_currentState != HS_SHUTDOWN &&
		 g_HostState.m_currentState != HS_RESTART &&
		 g_HostState.m_currentState != HS_GAME_SHUTDOWN
		 )
	{
		g_HostState.SetNextState( HS_GAME_SHUTDOWN );
	}
}

// shutdown the engine/program as soon as possible
void HostState_Shutdown()
{
	g_HostState.SetNextState( HS_SHUTDOWN );
}

//-----------------------------------------------------------------------------
// Purpose: Restart the engine
//-----------------------------------------------------------------------------
void HostState_Restart()
{
	g_HostState.SetNextState( HS_RESTART );
}

bool HostState_IsGameShuttingDown()
{
	return g_HostState.IsGameShuttingDown();
}

void HostState_OnClientConnected()
{
	g_HostState.OnClientConnected();
}

void HostState_OnClientDisconnected()
{
	g_HostState.OnClientDisconnected();
}

void HostState_SetSpawnPoint(Vector &position, QAngle &angle)
{
	g_HostState.m_angLocation = angle;
	g_HostState.m_vecLocation = position;
	g_HostState.m_bRememberLocation = true;
}

bool HostState_IsTransitioningToLoad()
{
	if ( g_HostState.m_nextState == HS_NEW_GAME ||
		g_HostState.m_nextState == HS_LOAD_GAME ||
		g_HostState.m_nextState == HS_CHANGE_LEVEL_SP ||
		g_HostState.m_nextState == HS_CHANGE_LEVEL_MP )
	{
		return true;
	}

	return false;
}

bool HostState_GameHasShutDownAndFlushedMemory()
{
	// False if map-related assets are still in memory
	// True once all such have been flushed from memory
	return g_HostState.m_bGameHasShutDownAndFlushedMemory;
}

void HostState_Pre_LoadMapIntoMemory()
{
	// About to load a map into memory
	g_HostState.m_bGameHasShutDownAndFlushedMemory = false;
}

void HostState_Post_FlushMapFromMemory()
{
	// Map-related assets have been flushed from memory
	g_HostState.m_bGameHasShutDownAndFlushedMemory = true;
}

const char *HostState_GetNewLevel()
{
	return g_HostState.m_levelName;
}

//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Class implementation
//-----------------------------------------------------------------------------

CHostState::CHostState()
{
	m_bGameHasShutDownAndFlushedMemory = true;
	SetState( HS_RUN, true );
}



void CHostState::Init()
{
	// This can occur if user pressed close button during opening cinematic
	if ( m_nextState != HS_SHUTDOWN )
	{
		if ( IsPS3QuitRequested() && m_nextState == HS_GAME_SHUTDOWN )
		{
			// do nothing; the state is set to game shutdown, leave it there. Otherwise engine goes into infinite "RUN" frame loop
		}
		else
		{
			SetState( HS_RUN, true );
		}
	}
	m_bLetToolsOverrideLoadGameEnts = false;
	m_activeGame = false;
	m_levelName[0] = 0;
	m_mapGroupName[0] = 0;
	m_saveName[0] = 0;
	m_landmarkName[0] = 0;
	m_bRememberLocation = 0;
	m_bBackgroundLevel = false;
	m_bSplitScreenConnect = false;
	m_vecLocation.Init();
	m_angLocation.Init();
	m_bWaitingForConnection = false;
	m_flShortFrameTime = 1.0;
	m_bGameHasShutDownAndFlushedMemory = true;
	m_bWorkshopMapDownloadPending = false;
}

void CHostState::SetState( HOSTSTATES newState, bool clearNext )
{
	m_currentState = newState;
	if ( clearNext )
	{
		m_nextState = newState;
	}
}

void CHostState::SetNextState( HOSTSTATES next )
{
	Assert( m_currentState == HS_RUN );
	m_nextState = next;
}

void CHostState::RunGameInit()
{
	materials->OnDebugEvent( "CHostState::RunGameInit" );
	Assert( !m_activeGame );

	if ( serverGameDLL )
	{
		serverGameDLL->GameInit();
	}
	m_activeGame = true;
}

void CHostState::GameShutdown()
{
	if ( m_activeGame )
	{
		materials->OnDebugEvent( "HostState::GameShutdown(active)");
		serverGameDLL->GameShutdown();
 		//if (! sv.IsLevelMainMenuBackground() )    can't do this here - it will overwrite variables that are part of the game setup (these vars are set _before_ the previous game is ended). hibernate is
		//    ResetGameConVarsToDefaults();         how we deal with this on the dedicated server.
		m_activeGame = false;
	}
	else
	{
		materials->OnDebugEvent( "HostState::GameShutdown" );
	}
}


// These State_ functions execute that state's code right away
// The external API queues up state changes to happen when the state machine is processed.
void CHostState::State_NewGame()
{
	bool bSplitScreenConnect = m_bSplitScreenConnect;
	m_bSplitScreenConnect = false;
	materials->OnDebugEvent( "CHostState::State_NewGame" );

	if ( Host_ValidGame() )
	{
		// Demand load game .dll if running with -nogamedll flag, etc.
		if ( !serverGameClients )
		{
			SV_InitGameDLL();
		}

		if ( !serverGameClients )
		{
			Warning( "Can't start game, no valid server.dll loaded\n" );
		}
		else
		{
			if ( modelloader->Map_IsValid( m_levelName ) )
			{
				if ( Host_NewGame( m_levelName, m_mapGroupName, false, m_bBackgroundLevel, bSplitScreenConnect ) )
				{
					// succesfully started the new game
					SetState( HS_RUN, true );
					return;
				}
			}
		}
	}

	SCR_EndLoadingPlaque();

	// new game failed
	GameShutdown();
	// run the server at the console
	SetState( HS_RUN, true );

	sv.ClearReservationStatus();
}

void CHostState::State_LoadGame()
{
	materials->OnDebugEvent( "CHostState::State_LoadGame" );

#ifndef DEDICATED
	HostState_RunGameInit();
	
	if ( saverestore->LoadGame( m_saveName, m_bLetToolsOverrideLoadGameEnts ) )
	{
		// succesfully started the new game
        GetTestScriptMgr()->CheckPoint( "load_game" );
		SetState( HS_RUN, true );
		return;
	}
#endif

	SCR_EndLoadingPlaque();

	// load game failed
	GameShutdown();
	// run the server at the console
	SetState( HS_RUN, true );

	if ( g_pMatchFramework->GetMatchSession() )
	{
		g_pMatchFramework->CloseSession();
		return;
	}

#if 0
	if ( IsX360() )
	{
		// On the 360 we need to return to the background map
		g_ServerGlobalVariables.bMapLoadFailed = true;
		Cbuf_Clear( Cbuf_GetCurrentPlayer() );
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), "startupmenu force" );
		Cbuf_Execute();
	}
#endif
}


void CHostState::State_ChangeLevelMP()
{
	materials->OnDebugEvent( "CHostState::State_ChangeLevelMP" );
	if ( Host_ValidGame() )
	{
		Steam3Server().NotifyOfLevelChange();

		g_pServerPluginHandler->LevelShutdown();
#if !defined(DEDICATED)
		audiosourcecache->LevelShutdown();
#endif
		if ( modelloader->Map_IsValid( m_levelName ) )
		{
#ifndef DEDICATED
			// start progress bar immediately for multiplayer level transitions
			EngineVGui()->EnabledProgressBarForNextLoad();
#endif
			Host_Changelevel( false, m_levelName, m_mapGroupName, m_landmarkName );
			SetState( HS_RUN, true );
			return;
		}
	}
	// fail
	ConMsg( "Unable to change level!\n" );
	SetState( HS_RUN, true );
}


void CHostState::State_ChangeLevelSP()
{
	materials->OnDebugEvent( "CHostState::State_ChangeLevelSP" );
	if ( Host_ValidGame() )
	{
		if ( modelloader->Map_IsValid( m_levelName ) )
		{
			Host_Changelevel( true, m_levelName, m_mapGroupName, m_landmarkName );
			SetState( HS_RUN, true );
			return;
		}
	}
	// fail
	ConMsg( "Unable to change level!\n" );
	SetState( HS_RUN, true );
}

static bool IsClientActive()
{
	if ( !sv.IsActive() )
	{
#ifdef DEDICATED
    return false;
#else
        return GetBaseLocalClient().IsActive();
#endif
	}

    for ( int i = 0; i < sv.GetClientCount(); i++ )
    {
		CGameClient *pClient = sv.Client( i );
		if ( pClient->IsActive() )
		{
			return true;
		}
    }
    return false;
}

static bool IsClientConnected()
{
    if ( !sv.IsActive() )
	{
#ifndef DEDICATED
        return GetBaseLocalClient().IsConnected();
#else
		return false;
#endif
	}

    for ( int i = 0; i < sv.GetClientCount(); i++ )
    {
		CGameClient *pClient = sv.Client( i );
		if ( pClient->IsConnected() )
			return true;
    }
    return false;
}

static bool s_bFirstRunFrame = true;


void CHostState::State_Run( float frameTime )
{
	//materials->OnDebugEvent( "CHostState::State_Run" );
	if ( m_flShortFrameTime > 0 )
	{
		if ( IsClientActive() )
		{
			m_flShortFrameTime = (m_flShortFrameTime > frameTime) ? (m_flShortFrameTime-frameTime) : 0;
		}
		// Only clamp time if client is in process of connecting or is already connected.
		if ( IsClientConnected() )
		{
			frameTime = MIN( frameTime, host_state.interval_per_tick );
		}
	}
	int nTimerWait = 15;
	if ( s_bFirstRunFrame )									// the first frame can take a while especially during fork startup
	{
		s_bFirstRunFrame = false;
		nTimerWait *= 2;
	}
	if ( sv.IsDedicated() )
		BeginWatchdogTimer( nTimerWait );
	Host_RunFrame( frameTime );								// 5 seconds allowed unless map load
	if ( sv.IsDedicated() )
		EndWatchdogTimer();

	// Continue loading process once we've tried to update the new map
	if ( sv.IsDedicated() && g_HostState.m_bWorkshopMapDownloadPending && !serverGameDLL->HasPendingMapDownloads() )
	{
		g_HostState.SetNextState( HS_CHANGE_LEVEL_MP );
		g_HostState.m_bWorkshopMapDownloadPending = false;
	}

	switch( m_nextState )
	{
	case HS_RUN:
		break;

	case HS_LOAD_GAME:
	case HS_NEW_GAME:
#if !defined( DEDICATED )
		SCR_BeginLoadingPlaque( m_levelName );
#endif
		// FALL THROUGH INTENTIONALLY TO SHUTDOWN

	case HS_SHUTDOWN:
	case HS_RESTART:
		// NOTE: The game must be shutdown before a new game can start, 
		// before a game can load, and before the system can be shutdown.
		// This is done here instead of pathfinding through a state transition graph.
		// That would be equivalent as the only way to get from HS_RUN to HS_LOAD_GAME is through HS_GAME_SHUTDOWN.
	case HS_GAME_SHUTDOWN:
		SetState( HS_GAME_SHUTDOWN, false );
		break;

	case HS_CHANGE_LEVEL_MP:
	case HS_CHANGE_LEVEL_SP:
		SetState( m_nextState, true );
		break;

	default:
		SetState( HS_RUN, true );
		break;
	}
}

void CHostState::State_GameShutdown()
{
	materials->OnDebugEvent( "CHostState::State_GameShutdown" );
	if ( serverGameDLL )
	{
		Steam3Server().NotifyOfLevelChange();
		g_pServerPluginHandler->LevelShutdown();
#if !defined(DEDICATED)
		audiosourcecache->LevelShutdown();
#endif
	}

	GameShutdown();
#ifndef DEDICATED
	saverestore->ClearSaveDir();
#endif
	Host_ShutdownServer();

	MapReslistGenerator().OnLevelShutdown();

	if ( IsGameConsole() )
	{
		if ( m_nextState == HS_GAME_SHUTDOWN )
		{
			// game consoles needs some memory to do main menu (movie, installer, etc)
			// this is an attempt to purge map related data
			g_pQueuedLoader->PurgeAll();			
			g_pDataCache->Flush();
			wavedatacache->Flush();
			g_pMDLCache->ReleaseAnimBlockAllocator();
			materials->OnLevelShutdown();
			materials->UncacheUnusedMaterials(); 
			// Record the fact that this memory flush completed
			HostState_Post_FlushMapFromMemory();

			// the above leaves resources in a bad state for Queued Loader
			// this ensures there a full purge necessary before any map gets loaded
			SV_FlushMemoryOnNextServer();

			// When ejecting BD right after starting loading a savegame, the game sometimes never calls State_shutdown, never sets engine state to DLL_CLOSE and goes into infinite loop
			// calling shutdown here to prevent that.
			if( IsPS3QuitRequested() )
			{
				State_Shutdown();
			}
		}
	}

	if( IsPS3QuitRequested() && m_nextState == HS_GAME_SHUTDOWN )
	{
		SetState( HS_GAME_SHUTDOWN, true );
	}
	else
	{
		switch( m_nextState )
		{
		case HS_LOAD_GAME:
		case HS_NEW_GAME:
		case HS_SHUTDOWN:
		case HS_RESTART:
			SetState( m_nextState, true );
			break;
		default:
			SetState( HS_RUN, true );
			break;
		}
	}
}


// Tell the launcher we're done.
void CHostState::State_Shutdown()
{
#if !defined(DEDICATED)
	CL_EndMovie();
#endif

	eng->SetNextState( IEngine::DLL_CLOSE );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHostState::State_Restart( void )
{
	// Just like a regular shutdown
	State_Shutdown();

	// But signal launcher/front end to restart engine
	eng->SetNextState( IEngine::DLL_RESTART );
}


//-----------------------------------------------------------------------------
// this is the state machine's main processing loop
//-----------------------------------------------------------------------------
char const *g_szHostStateDelayedMessage = NULL;
void CHostState::FrameUpdate( float time )
{
#if _DEBUG
	int loopCount = 0;
#endif

	if ( setjmp (host_abortserver) )
	{
		Init();
		return;
	}

	g_bAbortServerSet = true;

	while ( true )
	{
		if ( g_szHostStateDelayedMessage )
		{
			struct tm newtime;
			char tString[ 128 ] = {};
			Plat_GetLocalTime( &newtime );
			Plat_GetTimeString( &newtime, tString, sizeof( tString ) );

			Warning( "Host state %d at %s -- %s\n", m_currentState, tString, g_szHostStateDelayedMessage );

			g_szHostStateDelayedMessage = NULL;
		}

		int oldState = m_currentState;

		// execute the current state (and transition to the next state if not in HS_RUN)
		switch( m_currentState )
		{
		case HS_NEW_GAME:
			g_pMDLCache->BeginMapLoad();
			State_NewGame();
			break;
		case HS_LOAD_GAME:
			g_pMDLCache->BeginMapLoad();
			State_LoadGame();
			break;
		case HS_CHANGE_LEVEL_MP:
			g_pMDLCache->BeginMapLoad();
			m_flShortFrameTime = 0.5f;
			State_ChangeLevelMP();
			break;
		case HS_CHANGE_LEVEL_SP:
			g_pMDLCache->BeginMapLoad();
			m_flShortFrameTime = 1.5f; // 1.5s of slower frames
			State_ChangeLevelSP();
			break;
		case HS_RUN:
			State_Run( time );
			break;
		case HS_GAME_SHUTDOWN:
			State_GameShutdown();
			break;
		case HS_SHUTDOWN:
			State_Shutdown();
			break;
		case HS_RESTART:
			g_pMDLCache->BeginMapLoad();
			State_Restart();
			break;
		}

		// only do a single pass at HS_RUN per frame.  All other states loop until they reach HS_RUN 
		if ( oldState == HS_RUN )
			break;

		// shutting down
		if ( oldState == HS_SHUTDOWN ||
			 oldState == HS_RESTART )
			break;

		// we may be required to quit when in GAME_SHUTDOWN state on PS3, which state doesn't change to SHUTDOWN at this point
		// so in case we have user request to quit (or a disk ejected), to avoid infinite loop, we need to break out of this loop now.
		if( IsPS3QuitRequested() && oldState == HS_GAME_SHUTDOWN )
			break;


		// Only HS_RUN is allowed to persist across loops!!!
		// Also, detect circular state graphs (more than 8 cycling changes is probably a loop)
		// NOTE: In the current graph, there are at most 2.
#if _DEBUG
		if ( (m_currentState == oldState) || (++loopCount > 8) )
		{
			Host_Error( "state crash!\n" );
		}
#endif
	}
}


bool CHostState::IsGameShuttingDown( void )
{
	return ( ( m_currentState == HS_GAME_SHUTDOWN ) || ( m_nextState == HS_GAME_SHUTDOWN ) );
}

void CHostState::RememberLocation()
{
#ifndef DEDICATED
	Assert( m_bRememberLocation );

	m_vecLocation = MainViewOrigin();
	VectorAngles( MainViewForward(), m_angLocation );

	IClientEntity *localPlayer = entitylist ? entitylist->GetClientEntity( GetLocalClient().m_nPlayerSlot + 1 ) : NULL;
	if ( localPlayer )
	{
		m_vecLocation = localPlayer->GetAbsOrigin();
	}

	m_vecLocation.z -= 64.0f; // subtract out a bit of Z to position the player lower
#endif
}

void CHostState::OnClientConnected()
{
	materials->OnDebugEvent( "CHostState::OnClientConnected" );

	if ( !m_bWaitingForConnection )
		return;
	m_bWaitingForConnection = false;

	if ( m_bRememberLocation )
	{
		m_bRememberLocation = false;
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), va( "setpos_exact %f %f %f\n", m_vecLocation.x, m_vecLocation.y, m_vecLocation.z ) ); 
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), va( "setang_exact %f %f %f\n", m_angLocation.x, m_angLocation.y, m_angLocation.z ) );
	}

#if !defined( DEDICATED )
	if ( reload_materials.GetBool() )
	{
		// building cubemaps requires the materials to reload after map
		reload_materials.SetValue( 0 );
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), "mat_reloadallmaterials\n" );
	}

	// Spew global texture memory usage if asked to
	if( CommandLine()->CheckParm( "-dumpvidmemstats" ) )
	{
		FileHandle_t fp;
		fp = g_pFileSystem->Open( "vidmemstats.txt", "a" );

		g_pFileSystem->FPrintf( fp, "%s:\n", g_HostState.m_levelName );
	
#ifdef VPROF_ENABLED
		CVProfile *pProf = &g_VProfCurrentProfile;

		int prefixLen = V_strlen( "TexGroup_Global_" );
		float total = 0.0f;
		for ( int i=0; i < pProf->GetNumCounters(); i++ )
		{
			if ( pProf->GetCounterGroup( i ) == COUNTER_GROUP_TEXTURE_GLOBAL )
			{
				// The counters are in bytes and the panel is all in kilobytes.
				float value = pProf->GetCounterValue( i ) * ( 1.0f /  ( 1024.0f * 1024.0f ) );
				total += value;
				const char *pName = pProf->GetCounterName( i );
				if ( StringHasPrefix( pName, "TexGroup_Global_" ) )
				{
					pName += prefixLen;
				}
				g_pFileSystem->FPrintf( fp, "%s: %0.3fMB\n", pName, value );
			}
		}
		g_pFileSystem->FPrintf( fp, "vidmem total: %0.3fMB\n", total );
#endif

#if 0
		g_pFileSystem->FPrintf( fp, "hunk total: %0.3fMB\n", Cache_TotalUsed() * ( 1.0f / ( 1024.0f * 1024.0f ) ) );
		g_pFileSystem->FPrintf( fp, "hunk sound: %0.3fMB\n", Cache_TotalUsed_Sound() * ( 1.0f / ( 1024.0f * 1024.0f ) ) );
		g_pFileSystem->FPrintf( fp, "hunk models: %0.3fMB\n", Cache_TotalUsed_Models() * ( 1.0f / ( 1024.0f * 1024.0f ) ) );
#endif
		g_pFileSystem->FPrintf( fp, "---------------------------------\n" );
		g_pFileSystem->Close( fp );
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), "quit\n" );
	}
#endif
#ifndef DEDICATED
	if ( !sv.IsDedicated() )
	{
		ClientDLL_GameInit();
	}
#endif
}

void CHostState::OnClientDisconnected() 
{
	materials->OnDebugEvent( "CHostState::OnClientDisconnected" );
#ifndef DEDICATED
	if ( !sv.IsDedicated() )
	{
		ClientDLL_GameShutdown();
	}
#endif
}

// Determine if this is a valid game
static bool Host_ValidGame( void )
{
	return true;
}