source-engine/replay/cl_replaycontext.cpp

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

#include "cl_replaycontext.h"
#include "replaysystem.h"
#include "replay/iclientreplay.h"
#include "replay/ireplaymovierenderer.h"
#include "replay/shared_defs.h"
#include "cl_replaymanager.h"
#include "replay_dbg.h"
#include "baserecordingsessionmanager.h"
#include "baserecordingsessionblockmanager.h"
#include "cl_replaymoviemanager.h"
#include "cl_screenshotmanager.h"
#include "cl_performancemanager.h"
#include "cl_sessionblockdownloader.h"
#include "cl_downloader.h"
#include "cl_recordingsession.h"
#include "cl_recordingsessionblock.h"
#include "cl_renderqueue.h"
#include "replay_reconstructor.h"
#include "globalvars_base.h"

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

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

CClientReplayContext::CClientReplayContext()
:	m_pReplayManager( NULL ),
	m_pScreenshotManager( NULL ),
	m_pMovieRenderer( NULL ),
	m_pMovieManager( NULL ),
	m_pPerformanceManager( NULL ),
	m_pPerformanceController( NULL ),
	m_pTestDownloader( NULL ),
	m_pRenderQueue( NULL ),
	m_bClientSideReplayDisabled( false )
{
}

CClientReplayContext::~CClientReplayContext()
{
	delete m_pSessionBlockDownloader;
	delete m_pReplayManager;
	delete m_pScreenshotManager;
	delete m_pMovieManager;
	delete m_pPerformanceManager;
	delete m_pShared;
	delete m_pTestDownloader;
}

bool CClientReplayContext::Init( CreateInterfaceFn fnFactory )
{
	m_pShared = new CSharedReplayContext( this );
	m_pShared->m_strSubDir = SUBDIR_CLIENT;
	m_pShared->m_pRecordingSessionManager = new CClientRecordingSessionManager( this );
	m_pShared->m_pRecordingSessionBlockManager = new CClientRecordingSessionBlockManager( this );
	m_pShared->m_pErrorSystem = new CErrorSystem( this );

	if ( !m_pShared->Init( fnFactory ) )
		return false;

	m_pPerformanceManager = new CReplayPerformanceManager();
	m_pPerformanceManager->Init();

	m_pReplayManager = new CReplayManager();
	m_pReplayManager->Init( fnFactory );

	m_pScreenshotManager = new CScreenshotManager();
	m_pScreenshotManager->Init();

	m_pMovieManager = new CReplayMovieManager();
	m_pMovieManager->Init();

	m_pRenderQueue = new CRenderQueue();
	if ( !m_pRenderQueue )
		return false;

	m_pSessionBlockDownloader = new CSessionBlockDownloader();
	if ( !m_pSessionBlockDownloader )
		return false;

	m_pPerformanceController = new CPerformanceController();

	// Cleanup any unneeded block data from disk - cleanup is done on the fly, but this will clean up
	// blocks from the olden days, when block data was not cleaned up properly.
	CleanupUnneededBlocks();

	return true;
}

void CClientReplayContext::Shutdown()
{
	// NOTE: Must come first, as any existing downloads are aborted and may cause status
	// changes in replays, etc, which will need to be saved in CReplayManager::Shutdown(), etc.
	m_pSessionBlockDownloader->Shutdown();

	m_pShared->Shutdown();
	m_pReplayManager->Shutdown();
	m_pMovieManager->Shutdown();
}

void CClientReplayContext::DebugThink()
{
	if ( !replay_debug.GetBool() )
		return;

	int iLine = 15;

	// Recording session in progress
	CClientRecordingSession *pRecordingSession = CL_GetRecordingSessionInProgress();
	if ( pRecordingSession )
	{
		g_pEngineClient->Con_NPrintf( iLine++, "SESSION IN PROGRESS:" );
		g_pEngineClient->Con_NPrintf( iLine++, "  BLOCKS: %i", pRecordingSession->GetNumBlocks() );
		g_pEngineClient->Con_NPrintf( iLine++, "  NAME: %s", pRecordingSession->m_strName.Get() );
		g_pEngineClient->Con_NPrintf( iLine++, "  URL: %s", pRecordingSession->m_strBaseDownloadURL.Get() );
		g_pEngineClient->Con_NPrintf( iLine++, "  LAST CONSECUTIVE BLOCK DOWNLOADED: %i", pRecordingSession->GetGreatestConsecutiveBlockDownloaded() );
		g_pEngineClient->Con_NPrintf( iLine++, "  LAST BLOCK TO DOWNLOAD: %i", pRecordingSession->GetLastBlockToDownload() );
	}
	else
	{
		g_pEngineClient->Con_NPrintf( iLine++, "NO SESSION IN PROGRESS" );
	}

	iLine++;

	// Server state
	CClientRecordingSessionManager::ServerRecordingState_t *pServerState = &CL_GetRecordingSessionManager()->m_ServerRecordingState;
	g_pEngineClient->Con_NPrintf( iLine++, "SERVER STATE:" );
	g_pEngineClient->Con_NPrintf( iLine++, "  NAME: %s\n", pServerState->m_strSessionName.Get() );
	g_pEngineClient->Con_NPrintf( iLine++, "  DUMP INTERVAL: %i\n", pServerState->m_nDumpInterval );
	g_pEngineClient->Con_NPrintf( iLine++, "  CURRENT BLOCK: %i\n", pServerState->m_nCurrentBlock );
}

void CClientReplayContext::Think()
{
	DebugThink();

	if ( m_pTestDownloader )
	{
		m_pTestDownloader->Think();
		if ( m_pTestDownloader->IsDone() )
		{
			delete m_pTestDownloader;
			m_pTestDownloader = NULL;
		}
	}

	if ( !g_pReplay->IsReplayEnabled() )
		return;

	m_pShared->Think();
}

CReplay *CClientReplayContext::GetReplay( ReplayHandle_t hReplay )
{
	return m_pReplayManager->GetReplay( hReplay );
}

IReplayManager *CClientReplayContext::GetReplayManager()
{
	return m_pReplayManager;
}

IReplayScreenshotManager *CClientReplayContext::GetScreenshotManager()
{
	return m_pScreenshotManager;
}

IReplayPerformanceManager *CClientReplayContext::GetPerformanceManager()
{
	return m_pPerformanceManager;
}

IReplayPerformanceController *CClientReplayContext::GetPerformanceController()
{
	return m_pPerformanceController;
}

IReplayRenderQueue *CClientReplayContext::GetRenderQueue()
{
	return m_pRenderQueue;
}

void CClientReplayContext::SetMovieRenderer( IReplayMovieRenderer *pMovieRenderer )
{
	m_pMovieRenderer = pMovieRenderer;
}

IReplayMovieRenderer *CClientReplayContext::GetMovieRenderer()
{
	return m_pMovieRenderer;
}

IReplayMovieManager *CClientReplayContext::GetMovieManager()
{
	return m_pMovieManager;
}

void CClientReplayContext::TestDownloader( const char *pURL )
{
	// Don't overwrite existing test
	if ( m_pTestDownloader )
		return;

	// Download the file
	m_pTestDownloader = new CHttpDownloader();
	m_pTestDownloader->BeginDownload( pURL, NULL );
}

void CClientReplayContext::OnSignonStateFull()
{
	// Notify the demo player that we've reached full signon state
	if ( g_pEngineClient->IsPlayingReplayDemo() )
	{
		g_pReplayDemoPlayer->OnSignonStateFull();
	}

	// Play a performance?  This will play a performance from the beginning, if we're loading
	// one (ie the 'watch' button in the details panel of the replay browser), or will continue
	// playback if the user rewound while watching or editing a performance.
	CL_GetPerformanceController()->OnSignonStateFull();

	// If we're rendering, display the viewport
	if ( CL_GetMovieManager()->IsRendering() )
	{
		extern IClientReplay *g_pClient;
		g_pClient->OnRenderStart();

		// Prepare audio system for recording.
		g_pEngineClient->InitSoundRecord();

		// Init renderer
		IReplayMovie *pMovie = CL_GetMovieManager()->GetPendingMovie();
		if ( !m_pMovieRenderer->SetupRenderer( CL_GetMovieManager()->GetRenderMovieSettings(), pMovie ) )
		{
			Warning( "Render failed!\n" );
			CL_GetMovieManager()->CancelRender();
		}
	}

	// If we're not rendering and are playing back a replay, initialize the performance editor -
	// won't actually show until the user presses space, if they do at all.
	else if ( g_pEngineClient->IsPlayingReplayDemo() )
	{
		const CReplay *pReplay = g_pReplayDemoPlayer->GetCurrentReplay();
		if ( pReplay )
		{
			g_pClient->InitPerformanceEditor( pReplay->GetHandle() );
		}
		else
		{
			AssertMsg( 0, "Replay should exist here!" );
			Warning( "No current replay in demo player!\n" );
		}
	}
}

void CClientReplayContext::OnClientSideDisconnect()
{
	if ( !g_pEngine->IsSupportedModAndPlatform() )
		return;

	// Reset replay_recording or we'll continue to think we're recording
	extern ConVar replay_recording;
	replay_recording.SetValue( 0 );

	if ( !g_pEngineClient->IsPlayingReplayDemo() )
	{
		// Saves dangling replay, if there is one, clears out everything
		// NOTE: We need to let the replay manager deal before we end the session, otherwise the
		// state of the session will be cleared.
		m_pReplayManager->OnClientSideDisconnect();

		// Mark the session as no longer recording.
		CClientRecordingSession *pSession = CL_GetRecordingSessionInProgress();
		if ( pSession )
		{
			pSession->OnStopRecording();
		}

		// Sets recording flag to false in session in progress, clears session in progress,
		// and clears server state
		CL_GetRecordingSessionManager()->OnSessionEnd();
	}
}

void CClientReplayContext::PlayReplay( ReplayHandle_t hReplay, int iPerformance, bool bPlaySound )
{
	CReplay *pReplay = m_pReplayManager->GetReplay( hReplay );
	if ( !pReplay )
		return;

	if ( !ReconstructReplayIfNecessary( pReplay ) )
	{
		Replay_MsgBox( iPerformance < 0 ? "#Replay_Err_User_FailedToPlayReplay" : "#Replay_Err_User_FailedToPlayTake" );
		return;
	}

	// Play a sound?
	if ( bPlaySound )
	{
		g_pClient->PlaySound( iPerformance >= 0 ? "replay\\playperformance.wav" : "replay\\playoriginalreplay.wav" );
	}

	// Play the replay!
	g_pReplayDemoPlayer->PlayReplay( hReplay, iPerformance );
}

bool CClientReplayContext::ReconstructReplayIfNecessary( CReplay *pReplay )
{
	// If reconstruction hasn't happened yet, try to reconstruct
	extern ConVar replay_forcereconstruct;
	if ( !pReplay->HasReconstructedReplay() || replay_forcereconstruct.GetBool() )
	{
		if ( !Replay_Reconstruct( pReplay ) )
		{
			CL_GetErrorSystem()->AddErrorFromTokenName( "#Replay_Err_Reconstruction_Fail" );
			return false;
		}
	}

	return true;
}

void CClientReplayContext::OnPlayerSpawn()
{
	DBG( "OnPlayerSpawn()\n" );
	m_pReplayManager->AttemptToSetupNewReplay();
}

void CClientReplayContext::OnPlayerClassChanged()
{
	DBG( "OnPlayerClassChanged()\n" );
	m_pReplayManager->CompletePendingReplay();
}

void CClientReplayContext::GetPlaybackTimes( float &flOutTime, float &flOutLength, const CReplay *pReplay, const CReplayPerformance *pPerformance )
{
	flOutTime = 0.0f;
	flOutLength = 0.0f;
	
	// Get server start record tick
	const int nServerRecordStartTick = CL_GetRecordingSessionManager()->GetServerStartTickForSession( pReplay->m_hSession );

	// Don't let it be -1.  Take performance in tick into account.
	int nStartTick = MAX( 0, pReplay->m_nSpawnTick );
	if ( pPerformance && pPerformance->m_nTickIn >= 0 )
	{
		nStartTick = pPerformance->m_nTickIn;
	}

	// Calculate length
	const int nReplayEndTick = pReplay->m_nSpawnTick + g_pEngine->TimeToTicks( pReplay->m_flLength );
	const int nEndTick = ( pPerformance && pPerformance->m_nTickOut > 0 ) ? pPerformance->m_nTickOut : nReplayEndTick;
	flOutLength = pPerformance ? g_pEngine->TicksToTime( nEndTick - nStartTick ) : pReplay->m_flLength;

	// Calculate current time
	const int nCurTick = MAX( g_pEngineClient->GetClientGlobalVars()->tickcount - nStartTick - nServerRecordStartTick, 0 );
	flOutTime = MIN( g_pEngine->TicksToTime( nCurTick ), flOutLength );
}

uint64 CClientReplayContext::GetServerSessionId( ReplayHandle_t hReplay )
{
	CReplay *pReplay = GetReplay( hReplay );
	if ( !pReplay )
		return 0;

	CClientRecordingSession *pSession = CL_CastSession( CL_GetRecordingSessionManager()->FindSession( pReplay->m_hSession ) );
	if ( !pSession )
		return 0;

	return pSession->GetServerSessionID();
}

void CClientReplayContext::CleanupUnneededBlocks()
{
	CL_GetRecordingSessionManager()->CleanupUnneededBlocks();
}

void CClientReplayContext::ReportErrorsToUser( wchar_t *pErrorText )
{
	// Display a message now
//	Replay_MsgBox( pErrorText );

	if ( !pErrorText || pErrorText[0] == L'\0' )
		return;

	const int nErrorLen = wcslen( pErrorText );
	static char s_szError[1024];
	wcstombs( s_szError, pErrorText, MIN( 1024, nErrorLen ) );
	Warning( "Replay error system: %s\n", s_szError );
}

void CClientReplayContext::DisableReplayOnClient( bool bDisable )
{
	if ( m_bClientSideReplayDisabled == bDisable )
		return;

	m_bClientSideReplayDisabled = bDisable;

	// Display a message to the user
	Replay_HudMsg( bDisable ? "#Replay_ClientSideDisabled" : "#Replay_ClientSideEnabled", NULL, true );
}

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

CClientRecordingSessionManager *CL_GetRecordingSessionManager()
{
	return static_cast< CClientRecordingSessionManager * >( g_pClientReplayContextInternal->GetRecordingSessionManager() );
}

CClientRecordingSession *CL_GetRecordingSessionInProgress()
{
	return CL_CastSession( CL_GetRecordingSessionManager()->GetRecordingSessionInProgress() );
}

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