666 lines
18 KiB
C++
666 lines
18 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
//=======================================================================================//
|
|
|
|
#include "cl_replaymanager.h"
|
|
#include "replay/ienginereplay.h"
|
|
#include "replay/iclientreplay.h"
|
|
#include "replay/ireplaymoviemanager.h"
|
|
#include "replay/ireplayfactory.h"
|
|
#include "replay/replayutils.h"
|
|
#include "replay/ireplaymovierenderer.h"
|
|
#include "replay/shared_defs.h"
|
|
#include "baserecordingsession.h"
|
|
#include "cl_screenshotmanager.h"
|
|
#include "cl_recordingsession.h"
|
|
#include "cl_recordingsessionblock.h"
|
|
#include "replaysystem.h"
|
|
#include "cl_replaymoviemanager.h"
|
|
#include "replay_dbg.h"
|
|
#include "inetchannel.h"
|
|
#include "cl_replaycontext.h"
|
|
#include <time.h>
|
|
#include "vprof.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
extern IEngineClientReplay *g_pEngineClient;
|
|
extern ConVar replay_postdeathrecordtime;
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
#define REPLAY_INDEX_VERSION 0
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
CReplayManager::CReplayManager()
|
|
: m_pPendingReplay( NULL ),
|
|
m_pReplayLastLife( NULL ),
|
|
m_pReplayThisLife( NULL ),
|
|
m_flPlayerSpawnCreateReplayFailTime( 0.0f )
|
|
{
|
|
}
|
|
|
|
CReplayManager::~CReplayManager()
|
|
{
|
|
}
|
|
|
|
bool CReplayManager::Init( CreateInterfaceFn fnCreateFactory )
|
|
{
|
|
// Get out if the user is running an unsupported mod or platform
|
|
if ( !g_pEngine->IsSupportedModAndPlatform() )
|
|
return false;
|
|
|
|
// Clear anything already loaded (since we reuse the same instance)
|
|
Clear();
|
|
|
|
// Register replay factory
|
|
m_pReplayFactory = GetReplayFactory( fnCreateFactory ); Assert( m_pReplayFactory );
|
|
|
|
// Load all replays from disk
|
|
if ( !BaseClass::Init() )
|
|
{
|
|
Warning( "Failed to load replay history!\n" );
|
|
}
|
|
|
|
// Session manager init'd by this point - go through and link up replays to sessions
|
|
CL_GetRecordingSessionManager()->OnReplaysLoaded();
|
|
|
|
return true;
|
|
}
|
|
|
|
void CReplayManager::Shutdown()
|
|
{
|
|
// Get out if the user is running an unsupported mod or platform
|
|
if ( !g_pEngine->IsSupportedModAndPlatform() )
|
|
return;
|
|
|
|
// Make sure we aren't waiting to write
|
|
BaseClass::Shutdown(); // Saves
|
|
}
|
|
|
|
IReplayFactory *CReplayManager::GetReplayFactory( CreateInterfaceFn fnCreateFactory )
|
|
{
|
|
return (IReplayFactory *)fnCreateFactory( INTERFACE_VERSION_REPLAY_FACTORY, NULL );
|
|
}
|
|
|
|
void CReplayManager::OnSessionStart()
|
|
{
|
|
// The pending replay doesn't exist yet at this point as far as I've seen, since the "replay_sessioninfo"
|
|
// event comes down a frame or more after the "replay_recording" replicated cvar is set to 1, which is
|
|
// what triggers AttemptToSetupNewReplay().
|
|
if ( !m_pPendingReplay )
|
|
{
|
|
AttemptToSetupNewReplay();
|
|
}
|
|
|
|
if ( m_pPendingReplay )
|
|
{
|
|
// Link up the pending replay to the recording session in progress
|
|
if ( m_pPendingReplay->m_hSession == REPLAY_HANDLE_INVALID )
|
|
{
|
|
ReplayHandle_t hSessionInProgress = CL_GetRecordingSessionManager()->GetRecordingSessionInProgress()->GetHandle();
|
|
m_pPendingReplay->m_hSession = hSessionInProgress;
|
|
}
|
|
|
|
// Make sure the spawn tick has the proper server start tick subtracted out
|
|
if ( m_pPendingReplay->m_nSpawnTick < 0 )
|
|
{
|
|
const int nServerStartTick = CL_GetRecordingSessionManager()->m_ServerRecordingState.m_nStartTick; Assert( nServerStartTick > 0 );
|
|
m_pPendingReplay->m_nSpawnTick = MAX( 0, -m_pPendingReplay->m_nSpawnTick - nServerStartTick );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CReplayManager::OnSessionEnd()
|
|
{
|
|
// Complete the pending replay, if there is one
|
|
CompletePendingReplay();
|
|
}
|
|
|
|
const char *CReplayManager::GetRelativeIndexPath() const
|
|
{
|
|
return Replay_va( "%s%c", SUBDIR_REPLAYS, CORRECT_PATH_SEPARATOR );
|
|
}
|
|
|
|
CReplay *CReplayManager::Create()
|
|
{
|
|
return m_pReplayFactory->Create();
|
|
}
|
|
|
|
IReplayContext *CReplayManager::GetReplayContext() const
|
|
{
|
|
return g_pClientReplayContextInternal;
|
|
}
|
|
|
|
bool CReplayManager::ShouldLoadObj( const CReplay *pReplay ) const
|
|
{
|
|
return pReplay && pReplay->m_bComplete;
|
|
}
|
|
|
|
void CReplayManager::OnObjLoaded( CReplay *pReplay )
|
|
{
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
pReplay->m_bSavedDuringThisSession = false;
|
|
}
|
|
|
|
int CReplayManager::GetVersion() const
|
|
{
|
|
return REPLAY_INDEX_VERSION;
|
|
}
|
|
|
|
void CReplayManager::ClearPendingReplay()
|
|
{
|
|
m_pPendingReplay = NULL;
|
|
}
|
|
|
|
void CReplayManager::SanityCheckReplay( CReplay *pReplay )
|
|
{
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
// DEBUG: Make sure this replay does not already exist in the list
|
|
FOR_EACH_VEC( Replays(), i )
|
|
{
|
|
if ( Replays()[ i ]->GetHandle() == pReplay->GetHandle() )
|
|
{
|
|
IF_REPLAY_DBG( Warning( "Replay %i already found in history!\n", pReplay->GetHandle() ) );
|
|
}
|
|
}
|
|
|
|
if ( pReplay->m_nDeathTick < pReplay->m_nSpawnTick )
|
|
{
|
|
IF_REPLAY_DBG( Warning( "Spawn tick (%i) is greater than death tick (%i)!\n", pReplay->m_nSpawnTick, pReplay->m_nDeathTick ) );
|
|
}
|
|
}
|
|
|
|
void CReplayManager::SaveDanglingReplay()
|
|
{
|
|
if ( !m_pReplayThisLife )
|
|
return;
|
|
|
|
if ( m_pReplayThisLife->m_bRequestedByUser )
|
|
{
|
|
CompletePendingReplay();
|
|
FlagReplayForFlush( m_pReplayThisLife, false );
|
|
}
|
|
}
|
|
|
|
void CReplayManager::FreeLifeIfNotSaved( CReplay *&pReplay )
|
|
{
|
|
if ( pReplay )
|
|
{
|
|
if ( !pReplay->m_bSaved && !IsDirty( pReplay ) )
|
|
{
|
|
CleanupReplay( pReplay );
|
|
}
|
|
else
|
|
{
|
|
// If it's been saved, don't free the memory, just clear the pointer
|
|
pReplay = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CReplayManager::CleanupReplay( CReplay *&pReplay )
|
|
{
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
// Get rid of a replay that was never committed:
|
|
// Remove screenshots taken
|
|
CL_GetScreenshotManager()->DeleteScreenshotsForReplay( pReplay );
|
|
|
|
// Free
|
|
delete pReplay;
|
|
pReplay = NULL;
|
|
}
|
|
|
|
void CReplayManager::OnReplayRecordingCvarChanged()
|
|
{
|
|
DBG( "OnReplayRecordingCvarChanged()\n" );
|
|
|
|
// If set to 0, get out - we don't care
|
|
extern ConVar replay_recording;
|
|
if ( !replay_recording.GetBool() )
|
|
{
|
|
DBG( " replay_recording is false...aborting\n" );
|
|
return;
|
|
}
|
|
|
|
// If OnPlayerSpawn() hasn't failed to create the scratch replay, get out
|
|
if ( m_flPlayerSpawnCreateReplayFailTime == 0.0f )
|
|
{
|
|
DBG( " m_flPlayerSpawnCreateReplayFailTime == 0.0f...aborting.\n" );
|
|
return;
|
|
}
|
|
|
|
DBG( " Calling AttemptToSetupNewReplay()\n" );
|
|
|
|
// Try to create & setup again
|
|
AttemptToSetupNewReplay();
|
|
|
|
// Reset
|
|
m_flPlayerSpawnCreateReplayFailTime = 0.0f;
|
|
}
|
|
|
|
void CReplayManager::OnClientSideDisconnect()
|
|
{
|
|
SaveDanglingReplay();
|
|
ClearPendingReplay();
|
|
|
|
FreeLifeIfNotSaved( m_pReplayLastLife );
|
|
FreeLifeIfNotSaved( m_pReplayThisLife );
|
|
|
|
m_flPlayerSpawnCreateReplayFailTime = 0.0f;
|
|
}
|
|
|
|
void CReplayManager::CommitPendingReplayAndBeginDownload()
|
|
{
|
|
// Update the last session block we should download
|
|
CClientRecordingSession *pSession = CL_CastSession( CL_GetRecordingSessionManager()->FindSession( m_pReplayThisLife->m_hSession ) );
|
|
const int iPostDeathBlockIndex = pSession->UpdateLastBlockToDownload();
|
|
|
|
// Update the # of blocks required to reconstruct the replay
|
|
m_pReplayThisLife->m_iMaxSessionBlockRequired = iPostDeathBlockIndex;
|
|
|
|
Commit( m_pReplayThisLife );
|
|
}
|
|
|
|
void CReplayManager::CompletePendingReplay()
|
|
{
|
|
// Get out if no pending replay
|
|
if ( !m_pPendingReplay )
|
|
return;
|
|
|
|
// Get session associated w/ the replay
|
|
CBaseRecordingSession *pSession = CL_GetRecordingSessionManager()->FindSession( m_pPendingReplay->m_hSession );
|
|
|
|
// Sometimes the session isn't valid here, like when we're first joining a server
|
|
if ( !pSession )
|
|
return;
|
|
|
|
Assert( pSession->m_nServerStartRecordTick >= 0 );
|
|
|
|
// Cache death tick
|
|
m_pPendingReplay->m_nDeathTick = g_pEngineClient->GetLastServerTickTime() - pSession->m_nServerStartRecordTick;
|
|
|
|
SanityCheckReplay( m_pPendingReplay );
|
|
|
|
// Calc replay length
|
|
m_pPendingReplay->m_flLength = g_pEngine->TicksToTime(
|
|
m_pPendingReplay->m_nDeathTick -
|
|
m_pPendingReplay->m_nSpawnTick +
|
|
g_pEngine->TimeToTicks( replay_postdeathrecordtime.GetFloat() )
|
|
);
|
|
|
|
// Cache player slot so we can start playback of replays from recorder player's perspective
|
|
m_pPendingReplay->m_nPlayerSlot = g_pEngineClient->GetPlayerSlot() + 1;
|
|
|
|
// Setup status
|
|
m_pPendingReplay->m_nStatus = CReplay::REPLAYSTATUS_DOWNLOADPHASE;
|
|
|
|
// The replay is now "complete," ie has all the data needed
|
|
m_pPendingReplay->m_bComplete = true;
|
|
|
|
// Let derived classes do whatever it wants
|
|
m_pPendingReplay->OnComplete();
|
|
|
|
// If the replay was requested by the user already, update the # of blocks we should download & commit the replay
|
|
if ( m_pPendingReplay->m_bRequestedByUser )
|
|
{
|
|
#ifdef DBGFLAG_ASSERT
|
|
Assert( m_pReplayThisLife->m_bComplete );
|
|
#endif
|
|
CommitPendingReplayAndBeginDownload();
|
|
}
|
|
|
|
// Before we copy the pointer to "this life," end recording so the replay can do any cleanup (eg listening for game events)
|
|
m_pPendingReplay->OnEndRecording();
|
|
|
|
// Cache off scratch replay to "this life"
|
|
m_pReplayThisLife = m_pPendingReplay;
|
|
|
|
ClearPendingReplay();
|
|
}
|
|
|
|
bool CReplayManager::Commit( CReplay *pNewReplay )
|
|
{
|
|
if ( !g_pClientReplayContextInternal->IsInitialized() || !pNewReplay )
|
|
return false;
|
|
|
|
SanityCheckReplay( pNewReplay );
|
|
|
|
// NOTE: Marks index as dirty, as well as pNewReplay
|
|
Add( pNewReplay );
|
|
|
|
// Save now
|
|
Save();
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// IReplayManager implementation
|
|
//
|
|
CReplay *CReplayManager::GetReplay( ReplayHandle_t hReplay )
|
|
{
|
|
if ( m_pReplayThisLife && m_pReplayThisLife->GetHandle() == hReplay )
|
|
return m_pReplayThisLife;
|
|
|
|
return Find( hReplay );
|
|
}
|
|
|
|
void CReplayManager::DeleteReplay( ReplayHandle_t hReplay, bool bNotifyUI )
|
|
{
|
|
CReplay *pReplay = GetReplay( hReplay ); Assert( pReplay );
|
|
|
|
// The session manager will delete the .dem, the session .dmx and remove the session
|
|
// item itself if this is the last replay associated with it.
|
|
CL_GetRecordingSessionManager()->OnReplayDeleted( pReplay );
|
|
|
|
// Notify the replay browser if necessary
|
|
if ( bNotifyUI )
|
|
{
|
|
extern IClientReplay *g_pClient;
|
|
g_pClient->OnDeleteReplay( hReplay );
|
|
}
|
|
|
|
// Remove it
|
|
Remove( pReplay );
|
|
|
|
// If the replay deleted was just saved and we haven't respawned yet,
|
|
// we need to clear out some stuff so GetReplay() doesn't crash.
|
|
if ( m_pReplayThisLife == pReplay )
|
|
{
|
|
m_pReplayThisLife = NULL;
|
|
m_pPendingReplay = NULL;
|
|
}
|
|
|
|
if ( m_pReplayLastLife == pReplay )
|
|
{
|
|
m_pReplayLastLife = NULL;
|
|
}
|
|
}
|
|
|
|
void CReplayManager::FlagReplayForFlush( CReplay *pReplay, bool bForceImmediate )
|
|
{
|
|
FlagForFlush( pReplay, bForceImmediate );
|
|
}
|
|
|
|
int CReplayManager::GetUnrenderedReplayCount()
|
|
{
|
|
int nCount = 0;
|
|
FOR_EACH_VEC( m_vecObjs, i )
|
|
{
|
|
CReplay *pCurReplay = m_vecObjs[ i ];
|
|
if ( !pCurReplay->m_bRendered &&
|
|
pCurReplay->m_nStatus == CReplay::REPLAYSTATUS_READYTOCONVERT )
|
|
{
|
|
++nCount;
|
|
}
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
void CReplayManager::InitReplay( CReplay *pReplay )
|
|
{
|
|
// Setup record time right now
|
|
pReplay->m_RecordTime.InitDateAndTimeToNow();
|
|
|
|
// Store start time
|
|
pReplay->m_flStartTime = g_pEngine->GetHostTime();
|
|
|
|
// Get map name (w/o the path)
|
|
V_FileBase( g_pEngineClient->GetLevelName(), m_pPendingReplay->m_szMapName, sizeof( m_pPendingReplay->m_szMapName ) );
|
|
|
|
// Give the replay a default name
|
|
pReplay->AutoNameTitleIfEmpty();
|
|
}
|
|
|
|
CReplay *CReplayManager::CreatePendingReplay()
|
|
{
|
|
Assert( m_pPendingReplay == NULL );
|
|
m_pPendingReplay = CreateAndGenerateHandle();
|
|
|
|
// If we've already begun recording, link to the session now, otherwise link once
|
|
// we start recording.
|
|
CBaseRecordingSession *pSessionInProgress = CL_GetRecordingSessionInProgress();
|
|
if ( pSessionInProgress )
|
|
{
|
|
m_pPendingReplay->m_hSession = pSessionInProgress->GetHandle();
|
|
}
|
|
|
|
InitReplay( m_pPendingReplay );
|
|
|
|
// Setup replay handle for screenshots
|
|
CL_GetScreenshotManager()->SetScreenshotReplay( m_pPendingReplay->GetHandle() );
|
|
|
|
return m_pPendingReplay;
|
|
}
|
|
|
|
void CReplayManager::AttemptToSetupNewReplay()
|
|
{
|
|
DBG( "AttemptToSetupNewReplay()\n" );
|
|
|
|
if ( !g_pReplay->IsRecording() || g_pEngineClient->IsPlayingReplayDemo() )
|
|
{
|
|
DBG( " Aborting...not recording, or playing back replay.\n" );
|
|
m_flPlayerSpawnCreateReplayFailTime = g_pEngine->GetHostTime();
|
|
return;
|
|
}
|
|
|
|
// Create the replay if necessary - we only do setup if we're creating
|
|
// a new replay, because on a full update this function may be called
|
|
// even though we're not actually spawning.
|
|
if ( !m_pPendingReplay )
|
|
{
|
|
DBG( " Creating new replay...\n" );
|
|
|
|
// If there is a "last life" replay that was not saved already, delete it
|
|
FreeLifeIfNotSaved( m_pReplayLastLife );
|
|
|
|
// Cache last life
|
|
m_pReplayLastLife = m_pReplayThisLife;
|
|
|
|
// Create the scratch replay (sets m_pPendingReplay and returns it)
|
|
CReplay *pPendingReplay = CreatePendingReplay();
|
|
|
|
SanityCheckReplay( pPendingReplay );
|
|
|
|
// "This life" is the scratch replay
|
|
m_pReplayThisLife = pPendingReplay;
|
|
|
|
// Setup spawn tick
|
|
const int nServerStartTick = CL_GetRecordingSessionManager()->m_ServerRecordingState.m_nStartTick;
|
|
pPendingReplay->m_nSpawnTick = g_pEngineClient->GetLastServerTickTime() - nServerStartTick;
|
|
if ( nServerStartTick == 0 )
|
|
{
|
|
// Didn't receive the replay_sessioninfo event yet - make spawn tick negative so when the
|
|
// event IS received, we can detect that the server start tick still needs to be subtracted.
|
|
pPendingReplay->m_nSpawnTick *= -1;
|
|
}
|
|
|
|
// Setup post-death record time
|
|
extern ConVar replay_postdeathrecordtime;
|
|
pPendingReplay->m_nPostDeathRecordTime = replay_postdeathrecordtime.GetFloat();
|
|
|
|
// Let the replay know we're recording
|
|
pPendingReplay->OnBeginRecording();
|
|
}
|
|
else
|
|
{
|
|
DBG( " NOT creating new replay.\n" );
|
|
}
|
|
|
|
// Served its purpose
|
|
m_flPlayerSpawnCreateReplayFailTime = 0.0f;
|
|
}
|
|
|
|
void CReplayManager::Think()
|
|
{
|
|
VPROF_BUDGET( "CReplayManager::Think", VPROF_BUDGETGROUP_REPLAY );
|
|
|
|
BaseClass::Think();
|
|
|
|
DebugThink();
|
|
|
|
// Only update pending replay, since it's recording
|
|
// NOTE: we use Sys_FloatTime() here, since the client sets the next update time with engine->Time(),
|
|
// which also uses Sys_FloatTime().
|
|
if ( m_pPendingReplay && m_pPendingReplay->m_flNextUpdateTime <= Sys_FloatTime() )
|
|
{
|
|
m_pPendingReplay->Update(); // Allow the replay's Update() function to set the next update time
|
|
}
|
|
}
|
|
|
|
void CReplayManager::DebugThink()
|
|
{
|
|
// Debugging
|
|
if ( replay_debug.GetBool() )
|
|
{
|
|
const char *pReplayNames[] = { "Scratch", "This life", "Last life" };
|
|
CReplay *pReplays[] = { m_pPendingReplay, m_pReplayThisLife, m_pReplayLastLife };
|
|
for ( int i = 0; i < 3; ++i )
|
|
{
|
|
CReplay *pCurReplay = pReplays[ i ];
|
|
if ( !pCurReplay )
|
|
{
|
|
g_pEngineClient->Con_NPrintf( i, "%s: NULL", pReplayNames[ i ] );
|
|
continue;
|
|
}
|
|
|
|
g_pEngineClient->Con_NPrintf( i, "%s: handle=%i [%i, %i] C? %s R? %s MaxBlock: %i", pReplayNames[ i ],
|
|
pCurReplay->GetHandle(), pCurReplay->m_nSpawnTick,
|
|
pCurReplay->m_nDeathTick, pCurReplay->m_bComplete ? "YES" : "NO",
|
|
pCurReplay->m_bRequestedByUser ? "YES" : "NO",
|
|
pCurReplay->m_iMaxSessionBlockRequired
|
|
);
|
|
|
|
// Screenshot handle
|
|
int nCurLine = 5;
|
|
g_pEngineClient->Con_NPrintf( nCurLine, "Screenshot replay: handle=%i", CL_GetScreenshotManager()->GetScreenshotReplay() );
|
|
nCurLine += 2;
|
|
|
|
// Saved replay handles
|
|
g_pEngineClient->Con_NPrintf( nCurLine++, "REPLAYS:" );
|
|
FOR_EACH_REPLAY( j )
|
|
{
|
|
CReplay *pReplay = GET_REPLAY_AT( j );
|
|
g_pEngineClient->Con_NPrintf( nCurLine++, "%i: handle=%i ticks=[%i %i]", i, pReplay->GetHandle(),
|
|
pReplay->m_nSpawnTick, pReplay->m_nDeathTick );
|
|
}
|
|
|
|
// Current tick:
|
|
g_pEngineClient->Con_NPrintf( ++nCurLine, "MAIN tick: %f", g_pEngineClient->GetLastServerTickTime() );
|
|
g_pEngineClient->Con_NPrintf( ++nCurLine, " server tick: %f", g_pEngineClient->GetLastServerTickTime() );
|
|
nCurLine += 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
float CReplayManager::GetNextThinkTime() const
|
|
{
|
|
return g_pEngine->GetHostTime() + 0.1f;
|
|
}
|
|
|
|
CReplay *CReplayManager::GetPlayingReplay()
|
|
{
|
|
return g_pReplayDemoPlayer->GetCurrentReplay();
|
|
}
|
|
|
|
CReplay *CReplayManager::GetReplayForCurrentLife()
|
|
{
|
|
return m_pReplayThisLife;
|
|
}
|
|
|
|
void CReplayManager::GetReplays( CUtlLinkedList< CReplay *, int > &lstReplays )
|
|
{
|
|
lstReplays.RemoveAll();
|
|
FOR_EACH_REPLAY( i )
|
|
{
|
|
lstReplays.AddToTail( GET_REPLAY_AT( i ) );
|
|
}
|
|
}
|
|
|
|
void CReplayManager::GetReplaysAsQueryableItems( CUtlLinkedList< IQueryableReplayItem *, int > &lstReplays )
|
|
{
|
|
lstReplays.RemoveAll();
|
|
FOR_EACH_REPLAY( i )
|
|
{
|
|
lstReplays.AddToHead( dynamic_cast< IQueryableReplayItem * >( GET_REPLAY_AT( i ) ) );
|
|
}
|
|
|
|
if ( m_pPendingReplay &&
|
|
!m_pPendingReplay->m_bComplete &&
|
|
m_pPendingReplay->m_bRequestedByUser )
|
|
{
|
|
Assert( lstReplays.Find( m_pPendingReplay ) == lstReplays.InvalidIndex() );
|
|
lstReplays.AddToHead( m_pPendingReplay );
|
|
}
|
|
}
|
|
|
|
int CReplayManager::GetNumReplaysDependentOnSession( ReplayHandle_t hSession )
|
|
{
|
|
int nResult = 0;
|
|
FOR_EACH_REPLAY( i )
|
|
{
|
|
CReplay *pCurReplay = GET_REPLAY_AT( i );
|
|
if ( pCurReplay->m_hSession == hSession )
|
|
{
|
|
++nResult;
|
|
}
|
|
}
|
|
return nResult;
|
|
}
|
|
|
|
const char *CReplayManager::GetReplaysDir() const
|
|
{
|
|
return GetIndexPath();
|
|
}
|
|
|
|
float CReplayManager::GetDownloadProgress( const CReplay *pReplay )
|
|
{
|
|
// Give each downloadable session block equal weight since we won't know the size of blocks that
|
|
// have not been created/written yet on the server.
|
|
|
|
// Go through all blocks in the replay and figure out how many bytes have been downloaded
|
|
float flSum = 0.0f;
|
|
|
|
CClientRecordingSession *pSession = CL_CastSession( CL_GetRecordingSessionManager()->FindSession( pReplay->m_hSession ) ); Assert( pSession );
|
|
if ( !pSession )
|
|
return 0.0f;
|
|
|
|
const CBaseRecordingSession::BlockContainer_t &vecBlocks = pSession->GetBlocks();
|
|
FOR_EACH_VEC( vecBlocks, i )
|
|
{
|
|
CClientRecordingSessionBlock *pCurBlock = CL_CastBlock( vecBlocks[ i ] );
|
|
if ( !pReplay->IsSignificantBlock( pCurBlock->m_iReconstruction ) )
|
|
continue;
|
|
|
|
// Calculate progress for this block
|
|
Assert( pCurBlock->m_uFileSize > 0 );
|
|
const float flSubProgress = pCurBlock->m_uFileSize == 0 ? 0.0f : clamp( (float)pCurBlock->m_uBytesDownloaded / pCurBlock->m_uFileSize, 0.0f, 1.0f );
|
|
|
|
flSum += flSubProgress;
|
|
}
|
|
|
|
// Account for blocks that haven't been created yet
|
|
// NOTE: This will cause a bug in download progress if the round ends and cuts the number of
|
|
// expected blocks down - but that situation is probably less likely to occur than the situation
|
|
// where a client is expecting more blocks that *will* be created. To avoid pops in the latter
|
|
// situation, we account for those blocks here.
|
|
const int nTotalSubBlocks = pReplay->m_iMaxSessionBlockRequired + 1;
|
|
|
|
// Calculate mean
|
|
Assert( nTotalSubBlocks > 0 );
|
|
return nTotalSubBlocks == 0 ? 0.0f : ( flSum / (float)nTotalSubBlocks );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|