: m_pPendingReplay( NULL ),

m_pReplayLastLife( NULL ),

m_pReplayThisLife( NULL ),

m_flPlayerSpawnCreateReplayFailTime( 0.0f )

{

{

// 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;

{

// 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

{

// 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 );

}

}

{

// Complete the pending replay, if there is one

CompletePendingReplay();

{

if ( !pReplay )

return;

pReplay->m_bSavedDuringThisSession = false;

{

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 ) );

}

{

if ( !m_pReplayThisLife )

return;

if ( m_pReplayThisLife->m_bRequestedByUser )

{

CompletePendingReplay();

FlagReplayForFlush( m_pReplayThisLife, false );

}

{

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;

}

}

{

if ( !pReplay )

return;

// Get rid of a replay that was never committed:

// Remove screenshots taken

CL_GetScreenshotManager()->DeleteScreenshotsForReplay( pReplay );

// Free

delete pReplay;

pReplay = NULL;

{

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;

{

SaveDanglingReplay();

ClearPendingReplay();

FreeLifeIfNotSaved( m_pReplayLastLife );

FreeLifeIfNotSaved( m_pReplayThisLife );

m_flPlayerSpawnCreateReplayFailTime = 0.0f;

{

// 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 );

{

// 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();

{

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;

{

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;

}

{

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;

{

// 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();

{

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;

{

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

}

{

// 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;

}

}

{

lstReplays.RemoveAll();

FOR_EACH_REPLAY( i )

{

lstReplays.AddToTail( GET_REPLAY_AT( i ) );

}

{

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 nResult = 0;

FOR_EACH_REPLAY( i )

{

CReplay *pCurReplay = GET_REPLAY_AT( i );

if ( pCurReplay->m_hSession == hSession )

{

++nResult;

}

}

return nResult;

{

// 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 );