replaysystem.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//=======================================================================================//

#include "replaysystem.h"
#include "tier2/tier2.h"
#include "iserver.h"
#include "iclient.h"
#include "icliententitylist.h"
#include "igameevents.h"
#include "replay/ireplaymovierenderer.h"
#include "replay/ireplayscreenshotsystem.h"
#include "replay/replayutils.h"
#include "replay/replaylib.h"
#include "sv_sessionrecorder.h"
#include "sv_recordingsession.h"
#include "cl_screenshotmanager.h"
#include "netmessages.h"
#include "thinkmanager.h"
#include "managertest.h"
#include "vprof.h"
#include "sv_fileservercleanup.h"

#if !defined( _X360 )
#include "winlite.h"
#include "xbox/xboxstubs.h"
#endif

// TODO: Deal with linux build includes
#ifdef IS_WINDOWS_PC
#include <winsock.h>
#endif

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

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

#undef CreateEvent	// Can't call IGameEventManager2::CreateEvent() without this

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

#if !defined( DEDICATED )
IEngineClientReplay			*g_pEngineClient = NULL;
CClientReplayContext		*g_pClientReplayContextInternal = NULL;
IVDebugOverlay				*g_pDebugOverlay = NULL;
IDownloadSystem				*g_pDownloadSystem = NULL;
#endif

vgui::ILocalize				*g_pVGuiLocalize = NULL;
CServerReplayContext		*g_pServerReplayContext = NULL;
IClientReplay				*g_pClient = NULL;
IServerReplay				*g_pServer = NULL;
IEngineReplay				*g_pEngine = NULL;
IGameEventManager2			*g_pGameEventManager = NULL;
IEngineTrace				*g_pEngineTraceClient = NULL;
IReplayDemoPlayer			*g_pReplayDemoPlayer = NULL;
IClientEntityList			*entitylist = NULL;		// icliententitylist.h forces the use of this name by externing in the header

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

#define REPLAY_INIT( exp_ ) \
	if ( !( exp_ ) ) \
	{ \
		Warning( "CReplaySystem::Connect() failed on: \"%s\"!\n", #exp_ ); \
		return false; \
	}

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

class CReplaySystem : public CTier2AppSystem< IReplaySystem >
{
	typedef CTier2AppSystem< IReplaySystem > BaseClass;

public:
	virtual bool Connect( CreateInterfaceFn fnFactory )
	{
		REPLAY_INIT( fnFactory );
		REPLAY_INIT( BaseClass::Connect( fnFactory ) );

		ConVar_Register( FCVAR_CLIENTDLL );

		REPLAY_INIT( g_pFullFileSystem );

		g_pEngine = (IEngineReplay *)fnFactory( ENGINE_REPLAY_INTERFACE_VERSION, NULL );
		REPLAY_INIT( g_pEngine );

		REPLAY_INIT( g_pEngine->IsSupportedModAndPlatform() );
		
#if !defined( DEDICATED )
		g_pEngineClient = (IEngineClientReplay *)fnFactory( ENGINE_REPLAY_CLIENT_INTERFACE_VERSION, NULL );
		REPLAY_INIT( g_pEngineClient );

		g_pEngineTraceClient = (IEngineTrace *)fnFactory( INTERFACEVERSION_ENGINETRACE_CLIENT, NULL );
		REPLAY_INIT( g_pEngineTraceClient );

		g_pReplayDemoPlayer = (IReplayDemoPlayer *)fnFactory( INTERFACEVERSION_REPLAYDEMOPLAYER, NULL );
		REPLAY_INIT( g_pReplayDemoPlayer );

		g_pVGuiLocalize = (vgui::ILocalize *)fnFactory( VGUI_LOCALIZE_INTERFACE_VERSION, NULL );
		REPLAY_INIT( g_pVGuiLocalize );

		g_pDebugOverlay = ( IVDebugOverlay * )fnFactory( VDEBUG_OVERLAY_INTERFACE_VERSION, NULL );
		REPLAY_INIT( g_pDebugOverlay );
#endif

		g_pGameEventManager = (IGameEventManager2 *)fnFactory( INTERFACEVERSION_GAMEEVENTSMANAGER2, NULL );
		REPLAY_INIT( g_pGameEventManager );

#if !defined( DEDICATED )
		g_pDownloadSystem = (IDownloadSystem *)fnFactory( INTERFACEVERSION_DOWNLOADSYSTEM, NULL );
		REPLAY_INIT( g_pDownloadSystem );

		// Create client context now if not running a dedicated server
		if ( !g_pEngine->IsDedicated() )
		{
			g_pClientReplayContextInternal = new CClientReplayContext();
		}

		// ...and create server replay context if we are
		else
#endif
		{
			g_pServerReplayContext = new CServerReplayContext();
		}

#if defined( DEDICATED )
		REPLAY_INIT( ReplayLib_Init( g_pEngine->GetGameDir(), NULL ) )	// Init without the client replay context
#else
		REPLAY_INIT( ReplayLib_Init( g_pEngine->GetGameDir(), g_pClientReplayContextInternal ) );
#endif

		Test();

		return true;
	}

	virtual void Disconnect()
	{
		BaseClass::Disconnect(); 
	}

	virtual InitReturnVal_t Init()
	{
		InitReturnVal_t nRetVal = BaseClass::Init();
		if ( nRetVal != INIT_OK )
			return nRetVal;

		return INIT_OK;
	}

	virtual void Shutdown()
	{
		BaseClass::Shutdown();

#if !defined( DEDICATED )
		delete g_pClientReplayContextInternal;
		g_pClientReplayContextInternal = NULL;
#endif

		delete g_pServerReplayContext;
		g_pServerReplayContext = NULL;
	}

	virtual void Think()
	{
		VPROF_BUDGET( "CReplaySystem::Think", VPROF_BUDGETGROUP_REPLAY );

		g_pThinkManager->Think();
	}

	virtual bool IsReplayEnabled()
	{
		extern ConVar replay_enable;
		return replay_enable.GetInt() != 0;
	}

	virtual bool IsRecording()
	{
		// NOTE: demoplayer->IsPlayingBack() needs to be checked here, as "replay_enable" and
		// "replay_recording" will inevitably get stored with signon data in any playing demo.
		// If the !demoplayer->IsPlayingBack() line is omitted below, Replay_IsRecording()
		// becomes useless during demo playback and will always return true.
		extern ConVar replay_recording;
#if !defined( DEDICATED )
		return IsReplayEnabled() &&
			   replay_recording.GetInt() &&
			   !g_pEngineClient->IsDemoPlayingBack();
#else
		return IsReplayEnabled() &&
			   replay_recording.GetInt();
#endif
	}

	//----------------------------------------------------------------------------------------
	// Client-specific implementation:
	//----------------------------------------------------------------------------------------
	
	virtual bool CL_Init( CreateInterfaceFn fnClientFactory )
	{
#if !defined( DEDICATED )
		g_pClient = (IClientReplay *)fnClientFactory( CLIENT_REPLAY_INTERFACE_VERSION, NULL );
		if ( !g_pClient )
			return false;

		entitylist = (IClientEntityList *)fnClientFactory( VCLIENTENTITYLIST_INTERFACE_VERSION, NULL );
		if ( !entitylist )
			return false;

		if ( !g_pClientReplayContextInternal->Init( fnClientFactory ) )
			return false;

		return true;
#else
		return false;
#endif
	}

	virtual void CL_Shutdown()
	{
#if !defined( DEDICATED )
		if ( g_pClientReplayContextInternal && g_pClientReplayContextInternal->IsInitialized() )
		{
			g_pClientReplayContextInternal->Shutdown();
		}
#endif
	}

	virtual void CL_Render()
	{
#if !defined( DEDICATED )
		// If the replay system wants to take a screenshot, do it now
		if ( g_pClientReplayContextInternal->m_pScreenshotManager->ShouldCaptureScreenshot() )
		{
			g_pClientReplayContextInternal->m_pScreenshotManager->DoCaptureScreenshot();
			return;
		}

		// Currently rendering?  NOTE: GetMovieRenderer() only returns a valid ptr during rendering
		IReplayMovieRenderer *pReplayMovieRenderer = g_pClientReplayContextInternal->GetMovieRenderer();
		if ( !pReplayMovieRenderer )
			return;

		pReplayMovieRenderer->RenderVideo();
#endif
	}

	virtual IClientReplayContext *CL_GetContext()
	{
#if !defined( DEDICATED )
		return g_pClientReplayContextInternal;
#else
		return NULL;
#endif
	}

	//----------------------------------------------------------------------------------------
	// Server-specific implementation:
	//----------------------------------------------------------------------------------------
	
	virtual bool SV_Init( CreateInterfaceFn fnServerFactory )
	{
		if ( !g_pEngine->IsDedicated() || !g_pServerReplayContext )
			return false;

		g_pServer = (IServerReplay *)fnServerFactory( SERVER_REPLAY_INTERFACE_VERSION, NULL );
		if ( !g_pServer )
			return false;

		Assert( !ReplayServer() );

		return g_pServerReplayContext->Init( fnServerFactory );
	}

	virtual void SV_Shutdown()
	{
		if ( g_pServerReplayContext && g_pServerReplayContext->IsInitialized() )
		{
			g_pServerReplayContext->Shutdown();
		}
	}

	virtual IServerReplayContext *SV_GetContext()
	{
		return g_pServerReplayContext;
	}

	virtual bool SV_ShouldBeginRecording( bool bIsInWaitingForPlayers )
	{
		extern ConVar replay_enable;

		return !bIsInWaitingForPlayers &&
#if !defined( DEDICATED )
			   !g_pEngineClient->IsPlayingReplayDemo() &&
#endif
			   replay_enable.GetBool();
	}

	virtual void SV_NotifyReplayRequested()
	{
		if ( !g_pEngine->IsSupportedModAndPlatform() )
			return;

		CServerRecordingSession *pSession = SV_GetRecordingSessionInProgress();
		if ( !pSession )
			return;

		// A replay was requested - notify the session so we don't throw it away at the end of the round
		pSession->NotifyReplayRequested();
	}

	virtual void SV_SendReplayEvent( const char *pEventName, int nClientSlot )
	{
		// Attempt to create the event
		IGameEvent *pEvent = g_pGameEventManager->CreateEvent( pEventName, true );
		if ( !pEvent )
			return;

		SV_SendReplayEvent( pEvent, nClientSlot );
	}

	virtual void SV_SendReplayEvent( IGameEvent *pEvent, int nClientSlot/*=-1*/ )
	{
		IServer *pGameServer = g_pEngine->GetGameServer();

		if ( !pEvent )
			return;

		// Write event info to SVC_GameEvent msg
		char buffer_data[MAX_EVENT_BYTES];
		SVC_GameEvent msg;
		msg.SetReliable( false );
		msg.m_DataOut.StartWriting( buffer_data, sizeof( buffer_data ) );
		if ( !g_pGameEventManager->SerializeEvent( pEvent, &msg.m_DataOut ) )
		{
			DevMsg( "Replay_SendReplayEvent(): failed to serialize event '%s'.\n", pEvent->GetName() );
			goto free_event;
		}

		// Send to all clients?
		if ( nClientSlot == -1 )
		{
			for ( int i = 0; i < pGameServer->GetClientCount(); ++i )
			{
				IClient *pClient = pGameServer->GetClient( i );
				if ( pClient )
				{
					// Send the message
					pClient->SendNetMsg( msg );
				}
			}
		}
		else	// Send to just the one client?
		{
			IClient *pClient = pGameServer->GetClient( nClientSlot );
			if ( pClient )
			{
				// Send the message
				pClient->SendNetMsg( msg );
			}
		}

	free_event:
		g_pGameEventManager->FreeEvent( pEvent );
	}

	virtual void SV_EndRecordingSession( bool bForceSynchronousPublish/*=false*/ )
	{
		if ( !g_pEngine->IsSupportedModAndPlatform() )
			return;

		if ( !ReplayServer() )
			return;

		SV_GetSessionRecorder()->StopRecording( false );

		if ( bForceSynchronousPublish )
		{
			// Publish all files
			SV_GetSessionRecorder()->PublishAllSynchronous();

			// This should unlock all sessions
			SV_GetSessionRecorder()->UpdateSessionLocks();

			// Let the session manager do any cleanup - this will remove files associated with a ditched
			// session.  For example, if the server was shut down in the middle of a round where no one
			// saved a replay, the files will be published synchronously above and then cleaned up
			// synchronously here.
			SV_GetRecordingSessionManager()->DoSessionCleanup();

			// Since the recording session manager will kick off a cleanup job, we need to wait for it
			// here since we're shutting down.
			SV_GetFileserverCleaner()->BlockForCompletion();
		}
	}

	void Test()
	{
#if !defined( DEDICATED ) && _DEBUG
		// This gets called after interfaces are hooked up, and before any of the 
		// internal replay systems get init'd.
		CTestManager::Test();
#endif
	}
};

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

static CReplaySystem s_Replay;
IReplaySystem *g_pReplay = &s_Replay;

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

EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CReplaySystem, IReplaySystem, REPLAY_INTERFACE_VERSION,
								   s_Replay );

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

void Replay_MsgBox( const char *pText )
{
	g_pClient->DisplayReplayMessage( pText, false, true, NULL );
}

void Replay_MsgBox( const wchar_t *pText )
{
	g_pClient->DisplayReplayMessage( pText, false, true, NULL );
}

const char *Replay_GetDownloadURLPath()
{
	static char s_szDownloadURLPath[MAX_OSPATH];
	extern ConVar replay_fileserver_path;	// NOTE: replicated

	V_strcpy_safe( s_szDownloadURLPath, replay_fileserver_path.GetString() );
	V_StripTrailingSlash( s_szDownloadURLPath );
	V_FixSlashes( s_szDownloadURLPath, '/' );

	// Get rid of starting slash
	if ( s_szDownloadURLPath[0] == '/' )
		return &s_szDownloadURLPath[1];

	return s_szDownloadURLPath;
}

const char *Replay_GetDownloadURL()
{
#if 0
	// Get the local host name
	char szHostname[MAX_OSPATH];
	if ( gethostname( szHostname, sizeof( szHostname ) ) == -1 )
	{
		Error( "Failed to send to Replay to client - couldn't get local IP.\n" );
		return "";
	}
#endif

	// Construct the URL based on replicated cvars
	static char s_szFileURL[ MAX_OSPATH ];
	extern ConVar replay_fileserver_protocol;
	extern ConVar replay_fileserver_host;
	extern ConVar replay_fileserver_port;
	V_snprintf(
		s_szFileURL, sizeof( s_szFileURL ),
		"%s://%s:%i/%s/",
		replay_fileserver_protocol.GetString(),
		replay_fileserver_host.GetString(),
		replay_fileserver_port.GetInt(),
		Replay_GetDownloadURLPath()
	);

	// Cleanup
	V_FixDoubleSlashes( s_szFileURL + V_strlen("http://") );

	return s_szFileURL;
}

//----------------------------------------------------------------------------------------
// Purpose: (client/server) Crack a URL into a base and a path
// NOTE: the URL *must contain a port* !
//
//   Example: http://some.base.url:8080/a/path/here.txt cracks into:
//     pBaseURL = "http://some.base.url:8080"
//     pURLPath = "/a/path/here.txt"
//----------------------------------------------------------------------------------------
void Replay_CrackURL( const char *pURL, char *pBaseURLOut, char *pURLPathOut )
{
	const char *pColon;
	const char *pURLPath;

	// Must at least have "http://"
	if ( V_strlen(pURL) < 6 )
		goto fail;

	// Skip protocol ':' (eg http://)
	pColon = V_strstr( pURL, ":" );
	if ( !pColon )
		goto fail;

	// Find next colon
	pColon = V_strstr( pColon + 1, ":" );
	if ( !pColon )
		goto fail;

	// Copies "http[s]://<address>:<port>
	pURLPath = V_strstr( pColon, "/" );
	V_strncpy( pBaseURLOut, pURL, pURLPath - pURL + 1 );
	V_strcpy( pURLPathOut, pURLPath );

	return;

fail:
	AssertMsg( 0, "Replay_CrackURL() was passed an invalid URL and has failed.  This should never happen." );
}

#ifndef DEDICATED
void Replay_HudMsg( const char *pText, const char *pSound, bool bUrgent )
{
	g_pClient->DisplayReplayMessage( pText, bUrgent, false, pSound );
}
#endif

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