source-engine/replay/cl_recordingsessionmanager.cpp

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

#include "cl_recordingsessionmanager.h"
#include "replaysystem.h"
#include "cl_replaymanager.h"
#include "cl_recordingsession.h"
#include "cl_sessionblockdownloader.h"
#include "vprof.h"

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

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

#define CLIENTRECORDINGSESSIONMANAGER_VERSION	0

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

CClientRecordingSessionManager::CClientRecordingSessionManager( IReplayContext *pContext )
:	CBaseRecordingSessionManager( pContext ),
	m_nNumSessionBlockDownloaders( 0 ),
	m_flNextBlockUpdateTime( 0.0f ),
	m_flNextPossibleDownloadTime( 0.0f )
{
}

CClientRecordingSessionManager::~CClientRecordingSessionManager()
{
}

bool CClientRecordingSessionManager::Init()
{
	AddEventsForListen();

	return BaseClass::Init();
}

void CClientRecordingSessionManager::CleanupUnneededBlocks()
{
	Msg( "Cleaning up unneeded replay block data...\n" );
	FOR_EACH_OBJ( this, i )
	{
		CClientRecordingSession *pCurSession = CL_CastSession( m_vecObjs[ i ] );
		pCurSession->LoadBlocksForSession();
		pCurSession->DeleteBlocks();
	}
	Msg( "Replay cleanup done.\n" );
}

void CClientRecordingSessionManager::AddEventsForListen()
{
	g_pGameEventManager->AddListener( this, "replay_endrecord", false );
	g_pGameEventManager->AddListener( this, "replay_sessioninfo", false );
	g_pGameEventManager->AddListener( this, "player_death", false );
}

const char *CClientRecordingSessionManager::GetNewSessionName() const
{
	return m_ServerRecordingState.m_strSessionName;
}

CBaseRecordingSession *CClientRecordingSessionManager::OnSessionStart( int nCurrentRecordingStartTick, const char *pSessionName )
{
	return BaseClass::OnSessionStart( nCurrentRecordingStartTick, pSessionName );
}

void CClientRecordingSessionManager::OnSessionEnd()
{
	if ( m_pRecordingSession )
	{
		// Update whether all blocks have been downloaded
		AssertMsg( !m_pRecordingSession->m_bRecording, "This flag should have been cleared already!  See CBaseRecordingSession::OnStopRecording()" );
		CL_CastSession( m_pRecordingSession )->UpdateAllBlocksDownloaded();
	}

	BaseClass::OnSessionEnd();

	m_ServerRecordingState.Clear();
}

void CClientRecordingSessionManager::FireGameEvent( IGameEvent *pEvent )
{
	DBG( "CReplayHistoryManager::FireGameEvent()\n" );

	if ( g_pEngineClient->IsDemoPlayingBack() )
		return;
	
	const char *pEventName = pEvent->GetName();

	if ( !V_stricmp( "replay_sessioninfo", pEventName ) )
	{
		DBG( "   replay_sessioninfo\n" );

		bool bDisableReplayOnClient = false;

		const CUtlString strSessionName = pEvent->GetString( "sn" );
		if ( strSessionName.IsEmpty() )
		{
			CL_GetErrorSystem()->AddErrorFromTokenName( "#Replay_Err_SessionInfo_BadSessionName" );
			bDisableReplayOnClient = true;
		}

		const int nDumpInterval = pEvent->GetInt( "di", 0 );
		if ( nDumpInterval < MIN_SERVER_DUMP_INTERVAL ||
			 nDumpInterval > MAX_SERVER_DUMP_INTERVAL )
		{
			CL_GetErrorSystem()->AddErrorFromTokenName( "#Replay_Err_SessionInfo_BadDumpInterval" );
			bDisableReplayOnClient = true;
		}

		const int nCurrentBlock = pEvent->GetInt( "cb", -1 );
		if ( nCurrentBlock < 0 )
		{
			CL_GetErrorSystem()->AddErrorFromTokenName( "#Replay_Err_SessionInfo_BadCurrentBlock" );
			bDisableReplayOnClient = true;
		}

		const int nStartTick = pEvent->GetInt( "st", -1 );
		if ( nStartTick < 0 )
		{
			CL_GetErrorSystem()->AddErrorFromTokenName( "Replay_Err_SessionInfo_BadStartTick" );
			bDisableReplayOnClient = true;
		}

		// Cache session state
		m_ServerRecordingState.m_strSessionName = strSessionName;
		m_ServerRecordingState.m_nDumpInterval = nDumpInterval;
		m_ServerRecordingState.m_nCurrentBlock = nCurrentBlock + 1;		// This will account for any different between when the server actually dumps a block and the client predicts a dump
		m_ServerRecordingState.m_nStartTick = nStartTick;

		// If the server's in a weird state, disable replay on the client so they don't
		// create any replays that don't play, etc.
		g_pClientReplayContextInternal->DisableReplayOnClient( bDisableReplayOnClient );
		if ( bDisableReplayOnClient )
			return;

		OnSessionStart( nStartTick, strSessionName.Get() );

		CL_GetReplayManager()->OnSessionStart();

		// Update the current block based on the dump interval passed down from
		// the server so the client stays in sync w/ the current block index.
		m_flNextBlockUpdateTime = g_pEngine->GetHostTime() + nDumpInterval;
	}

	else if ( !V_stricmp( "replay_endrecord", pEventName ) )
	{
		DBG( "   replay_stoprecord\n" );

		// Clear pending replay URL cache, complete any pending replay
		CL_GetReplayManager()->OnSessionEnd();

		// Notify the session - it will mark itself as no longer recording.
		if ( m_pRecordingSession )
		{
			m_pRecordingSession->OnStopRecording();
		}

		// Resets current session pointer
		OnSessionEnd();
	}

	// When the player dies, we fill out the rest of the data here
	else if ( !V_stricmp( "player_death", pEventName ) &&
			  pEvent->GetInt( "victim_entindex" ) == g_pEngineClient->GetPlayerSlot() + 1 &&
			  g_pClient->ShouldCompletePendingReplay( pEvent ) )
	{
		CL_GetReplayManager()->CompletePendingReplay();
	}
}

int CClientRecordingSessionManager::GetVersion() const
{
	return CLIENTRECORDINGSESSIONMANAGER_VERSION;
}

void CClientRecordingSessionManager::Think()
{
	VPROF_BUDGET( "CClientRecordingSessionManager::Think", VPROF_BUDGETGROUP_REPLAY );

	BaseClass::Think();

	// Manage all session block downloads
	DownloadThink();

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

	if ( g_pEngineClient->IsDemoPlayingBack() )
		return;

	const float flHostTime = g_pEngine->GetHostTime();

	if ( replay_debug.GetBool() )
	{
		extern ConVar replay_postdeathrecordtime;
		g_pEngineClient->Con_NPrintf( 100, "Time until block dump: ~%f", m_flNextBlockUpdateTime - flHostTime );
		g_pEngineClient->Con_NPrintf( 101, "Post-death record time: %f", replay_postdeathrecordtime.GetFloat() );
	}

	if ( m_flNextBlockUpdateTime <= flHostTime )
	{
		// Increment current block
		++m_ServerRecordingState.m_nCurrentBlock;

		// NOTE: Now the number of blocks in the recording session in progress should be
		// different from the number of blocks in its list - so it should spawn a download
		// thread to grab the session info and create the new block.

		IF_REPLAY_DBG( Warning( "# session blocks updating: %i\n", m_ServerRecordingState.m_nCurrentBlock ) );

		// Setup next think
		m_flNextBlockUpdateTime = flHostTime + m_ServerRecordingState.m_nDumpInterval;
	}
}

void CClientRecordingSessionManager::DownloadThink()
{
	bool bKickedOffDownload = false;
	const float flHostTime = g_pEngine->GetHostTime();

	// For session in progress - check predicted # of blocks on the server based on current number
	// of blocks in our list - if different, download the session info and create any outstanding
	// blocks on the client.
	bool bEnoughTimeHasPassed = flHostTime >= m_flNextPossibleDownloadTime;
	if ( !bEnoughTimeHasPassed )
		return;

	// Go through all sessions to see if we need to create session block downloaders
	FOR_EACH_OBJ( this, i )
	{
		CClientRecordingSession *pCurSession = CL_CastSession( m_vecObjs[ i ] );

		// Already have a session block downloader?  NOTE: The think manager calls its Think().
		if ( pCurSession->HasSessionInfoDownloader() )
			continue;

		// If the # of blocks on the client is out of sync with the number of blocks we need
		// to eventually download, sync with the server, i.e. download the session info and
		// create blocks/sync block data as needed.
		if ( pCurSession->ShouldSyncBlocksWithServer() )
		{
			pCurSession->SyncSessionBlocks();
			bKickedOffDownload = true;
		}
	}

	// Set next possible download time if we just kicked off a download
	if ( bKickedOffDownload )
	{
		m_flNextPossibleDownloadTime = flHostTime + MAX( MIN_SERVER_DUMP_INTERVAL, CL_GetRecordingSessionManager()->m_ServerRecordingState.m_nDumpInterval );
	}
}

CBaseRecordingSession *CClientRecordingSessionManager::Create()
{
	return new CClientRecordingSession( m_pContext );
}

IReplayContext *CClientRecordingSessionManager::GetReplayContext() const
{
	return g_pClientReplayContextInternal;
}

void CClientRecordingSessionManager::OnObjLoaded( CBaseRecordingSession *pSession )
{
	// Make sure the session doesn't try to start downloading if it's done
	CL_CastSession( pSession )->UpdateAllBlocksDownloaded();
}

void CClientRecordingSessionManager::OnReplayDeleted( CReplay *pReplay )
{
	// Notify the session that a replay has been deleted, in case it needs to do any cleanup.
	CClientRecordingSession *pSession = CL_CastSession( FindSession( pReplay->m_hSession ) );
	if ( pSession )
	{
		pSession->OnReplayDeleted( pReplay );
	}

	// Get the # of replays that depend on the given session
	int nNumDependentReplays = CL_GetReplayManager()->GetNumReplaysDependentOnSession( pReplay->m_hSession );
	if ( nNumDependentReplays == 1 )
	{
		// Delete the session - remove the item from the manager itself, delete the
		// .dem file, and any .dmx.
		DeleteSession( pReplay->m_hSession, false );
	}
}

void CClientRecordingSessionManager::OnReplaysLoaded()
{
	// Cache replay pointers in sessions for quick access
	FOR_EACH_REPLAY( i )
	{
		CReplay *pCurReplay = GET_REPLAY_AT( i );
		CClientRecordingSession *pOwnerSession = CL_CastSession( CL_GetRecordingSessionManager()->FindSession( pCurReplay->m_hSession ) );	Assert( pOwnerSession );
		if ( !pOwnerSession )
		{
			CL_GetErrorSystem()->AddErrorFromTokenName( "#Replay_Err_Load_BadOwnerSession" );
			continue;
		}

		pOwnerSession->CacheReplay( pCurReplay );
	}
}

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