452 lines
15 KiB
C++
452 lines
15 KiB
C++
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
//=======================================================================================//
|
||
|
|
|
||
|
|
#include "cl_recordingsession.h"
|
||
|
|
#include "cl_sessioninfodownloader.h"
|
||
|
|
#include "cl_recordingsessionmanager.h"
|
||
|
|
#include "cl_replaymanager.h"
|
||
|
|
#include "cl_recordingsessionblock.h"
|
||
|
|
#include "cl_sessionblockdownloader.h"
|
||
|
|
#include "replay/ienginereplay.h"
|
||
|
|
#include "KeyValues.h"
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include "tier0/memdbgon.h"
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
extern IEngineReplay *g_pEngine;
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#define MAX_SESSION_INFO_DOWNLOAD_ATTEMPTS 3
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
CClientRecordingSession::CClientRecordingSession( IReplayContext *pContext )
|
||
|
|
: CBaseRecordingSession( pContext ),
|
||
|
|
m_iLastBlockToDownload( -1 ),
|
||
|
|
m_iGreatestConsecutiveBlockDownloaded( -1 ),
|
||
|
|
m_nSessionInfoDownloadAttempts( 0 ),
|
||
|
|
m_flLastUpdateTime( -1.0f ),
|
||
|
|
m_pSessionInfoDownloader( NULL ),
|
||
|
|
m_bTimedOut( false ),
|
||
|
|
m_bAllBlocksDownloaded( false )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
CClientRecordingSession::~CClientRecordingSession()
|
||
|
|
{
|
||
|
|
delete m_pSessionInfoDownloader;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CClientRecordingSession::AllReplaysReconstructed() const
|
||
|
|
{
|
||
|
|
FOR_EACH_LL( m_lstReplays, it )
|
||
|
|
{
|
||
|
|
const CReplay *pCurReplay = m_lstReplays[ it ];
|
||
|
|
if ( !pCurReplay->HasReconstructedReplay() )
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::DeleteBlocks()
|
||
|
|
{
|
||
|
|
// Only delete blocks if all replays have been reconstructed for this session
|
||
|
|
if ( !AllReplaysReconstructed() )
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Delete each block
|
||
|
|
FOR_EACH_VEC( m_vecBlocks, i )
|
||
|
|
{
|
||
|
|
m_pContext->GetRecordingSessionBlockManager()->DeleteBlock( m_vecBlocks[ i ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Clear out the list
|
||
|
|
m_vecBlocks.RemoveAll();
|
||
|
|
|
||
|
|
// Clear these out so we don't try to download the blocks again
|
||
|
|
m_iLastBlockToDownload = -1;
|
||
|
|
m_iGreatestConsecutiveBlockDownloaded = -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::SyncSessionBlocks()
|
||
|
|
{
|
||
|
|
// If the last update time hasn't been initialized yet, initialize it now since this will be the first time
|
||
|
|
// we are attempting to download the session info file.
|
||
|
|
if ( m_flLastUpdateTime < 0.0f )
|
||
|
|
{
|
||
|
|
m_flLastUpdateTime = g_pEngine->GetHostTime();
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( !m_pSessionInfoDownloader );
|
||
|
|
IF_REPLAY_DBG( Warning( "Downloading session info...\n" ) );
|
||
|
|
m_pSessionInfoDownloader = new CSessionInfoDownloader();
|
||
|
|
m_pSessionInfoDownloader->DownloadSessionInfoAndUpdateBlocks( this );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::OnReplayDeleted( CReplay *pReplay )
|
||
|
|
{
|
||
|
|
m_lstReplays.FindAndRemove( pReplay );
|
||
|
|
|
||
|
|
// This will load session blocks and delete them from disk if possible. In the case
|
||
|
|
// that all other replays for a session have already been reconstructed and pReplay
|
||
|
|
// was the last replay that was never reconstructed, we should delete session's blocks now.
|
||
|
|
// Note that these calls will only (a) load blocks if they aren't loaded already, and
|
||
|
|
// (b) Delete blocks if all associated replays have been reconstructed.
|
||
|
|
LoadBlocksForSession();
|
||
|
|
DeleteBlocks();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CClientRecordingSession::Read( KeyValues *pIn )
|
||
|
|
{
|
||
|
|
if ( !BaseClass::Read( pIn ) )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
m_iLastBlockToDownload = pIn->GetInt( "last_block_to_download", -1 );
|
||
|
|
m_iGreatestConsecutiveBlockDownloaded = pIn->GetInt( "last_consec_block_downloaded", -1 );
|
||
|
|
// m_bTimedOut = pIn->GetBool( "timed_out" );
|
||
|
|
m_uServerSessionID = pIn->GetUint64( "server_session_id" );
|
||
|
|
m_bAllBlocksDownloaded = pIn->GetBool( "all_blocks_downloaded" );
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::Write( KeyValues *pOut )
|
||
|
|
{
|
||
|
|
BaseClass::Write( pOut );
|
||
|
|
|
||
|
|
pOut->SetInt( "last_block_to_download", m_iLastBlockToDownload );
|
||
|
|
pOut->SetInt( "last_consec_block_downloaded", m_iGreatestConsecutiveBlockDownloaded );
|
||
|
|
// pOut->SetInt( "timed_out", (int)m_bTimedOut );
|
||
|
|
pOut->SetUint64( "server_session_id", m_uServerSessionID );
|
||
|
|
pOut->SetInt( "all_blocks_downloaded", (int)m_bAllBlocksDownloaded );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::AdjustLastBlockToDownload( int iNewLastBlockToDownload )
|
||
|
|
{
|
||
|
|
Assert( m_iLastBlockToDownload > iNewLastBlockToDownload );
|
||
|
|
m_iLastBlockToDownload = iNewLastBlockToDownload;
|
||
|
|
|
||
|
|
// Adjust any replays that refer to this session
|
||
|
|
FOR_EACH_LL( m_lstReplays, i )
|
||
|
|
{
|
||
|
|
CReplay *pCurReplay = m_lstReplays[ i ];
|
||
|
|
if ( pCurReplay->m_iMaxSessionBlockRequired > iNewLastBlockToDownload )
|
||
|
|
{
|
||
|
|
// Adjust replay
|
||
|
|
pCurReplay->m_iMaxSessionBlockRequired = iNewLastBlockToDownload;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int CClientRecordingSession::UpdateLastBlockToDownload()
|
||
|
|
{
|
||
|
|
// Here we calculate the block we'll need in order to reconstruct the replay at the post-death time,
|
||
|
|
// based on replay_postdeathrecordtime, NOT the current time. The index calculated here may be greater
|
||
|
|
// than the actual last block the server writes, since the round may end or the map may change. This
|
||
|
|
// is adjusted for when we actually download the blocks.
|
||
|
|
extern ConVar replay_postdeathrecordtime;
|
||
|
|
CClientRecordingSessionManager::ServerRecordingState_t *pServerState = &CL_GetRecordingSessionManager()->m_ServerRecordingState;
|
||
|
|
|
||
|
|
const int nCurBlock = pServerState->m_nCurrentBlock;
|
||
|
|
const int nDumpInterval = pServerState->m_nDumpInterval; Assert( nDumpInterval > 0 );
|
||
|
|
const int nAddedBlocks = (int)ceil( replay_postdeathrecordtime.GetFloat() / nDumpInterval ); // Round up
|
||
|
|
const int iPostDeathBlock = nCurBlock + nAddedBlocks;
|
||
|
|
|
||
|
|
IF_REPLAY_DBG( Warning( "nCurBlock: %i\n", nCurBlock ) );
|
||
|
|
IF_REPLAY_DBG( Warning( "nDumpInterval: %i\n", nDumpInterval ) );
|
||
|
|
IF_REPLAY_DBG( Warning( "nAddedBlocks: %i\n", nAddedBlocks ) );
|
||
|
|
IF_REPLAY_DBG( Warning( "iPostDeathBlock: %i\n", iPostDeathBlock ) );
|
||
|
|
|
||
|
|
// Never assign less blocks than we already need
|
||
|
|
m_iLastBlockToDownload = MAX( m_iLastBlockToDownload, iPostDeathBlock );
|
||
|
|
|
||
|
|
CL_GetRecordingSessionManager()->FlagForFlush( this, false );
|
||
|
|
|
||
|
|
IF_REPLAY_DBG( ConColorMsg( 0, Color(0,255,0), "Max block currently needed: %i\n", m_iLastBlockToDownload ) );
|
||
|
|
|
||
|
|
return m_iLastBlockToDownload;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::Think()
|
||
|
|
{
|
||
|
|
CBaseThinker::Think();
|
||
|
|
|
||
|
|
// If the session info downloader's done and can be deleted, free it.
|
||
|
|
if ( m_pSessionInfoDownloader &&
|
||
|
|
m_pSessionInfoDownloader->IsDone() &&
|
||
|
|
m_pSessionInfoDownloader->CanDelete() )
|
||
|
|
{
|
||
|
|
// Failure?
|
||
|
|
if ( m_pSessionInfoDownloader->m_nError != CSessionInfoDownloader::ERROR_NONE )
|
||
|
|
{
|
||
|
|
// If there was an error, increment the error count and update the appropriate replays if
|
||
|
|
// we've tried a sufficient number of times.
|
||
|
|
++m_nSessionInfoDownloadAttempts;
|
||
|
|
if ( m_nSessionInfoDownloadAttempts >= MAX_SESSION_INFO_DOWNLOAD_ATTEMPTS )
|
||
|
|
{
|
||
|
|
FOR_EACH_LL( m_lstReplays, i )
|
||
|
|
{
|
||
|
|
CReplay *pCurReplay = m_lstReplays[ i ];
|
||
|
|
|
||
|
|
// If this replay has already been set to "ready to convert" state (or beyond), skip.
|
||
|
|
if ( pCurReplay->m_nStatus >= CReplay::REPLAYSTATUS_READYTOCONVERT )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
// Update status
|
||
|
|
pCurReplay->m_nStatus = CReplay::REPLAYSTATUS_ERROR;
|
||
|
|
|
||
|
|
// Display an error message
|
||
|
|
ShowDownloadFailedMessage( pCurReplay );
|
||
|
|
|
||
|
|
// Save now
|
||
|
|
CL_GetReplayManager()->FlagReplayForFlush( pCurReplay, true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
IF_REPLAY_DBG( Warning( "...session info download complete. Freeing.\n" ) );
|
||
|
|
delete m_pSessionInfoDownloader;
|
||
|
|
m_pSessionInfoDownloader = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float CClientRecordingSession::GetNextThinkTime() const
|
||
|
|
{
|
||
|
|
return g_pEngine->GetHostTime() + 0.5f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::UpdateAllBlocksDownloaded()
|
||
|
|
{
|
||
|
|
// We're only "done" if this session is no longer recording and all blocks are downloaded.
|
||
|
|
const bool bOld = m_bAllBlocksDownloaded;
|
||
|
|
m_bAllBlocksDownloaded = !m_bRecording && ( m_iGreatestConsecutiveBlockDownloaded >= m_iLastBlockToDownload );
|
||
|
|
|
||
|
|
// Flag as modified if changed
|
||
|
|
if ( bOld != m_bAllBlocksDownloaded )
|
||
|
|
{
|
||
|
|
CL_GetRecordingSessionManager()->FlagForFlush( this, false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::EnsureDownloadingEnabled()
|
||
|
|
{
|
||
|
|
m_bAllBlocksDownloaded = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::UpdateGreatestConsecutiveBlockDownloaded()
|
||
|
|
{
|
||
|
|
// Assumes m_vecBlocks is sorted in ascending order (for both reconstruction indices and handle, which should be parallel)
|
||
|
|
int j = 0;
|
||
|
|
int iGreatestConsecutiveBlockDownloaded = 0;
|
||
|
|
FOR_EACH_VEC( m_vecBlocks, i )
|
||
|
|
{
|
||
|
|
CClientRecordingSessionBlock *pCurBlock = CL_CastBlock( m_vecBlocks[ i ] );
|
||
|
|
|
||
|
|
AssertMsg( pCurBlock->m_iReconstruction == j, "Session blocks must be sorted!" );
|
||
|
|
|
||
|
|
// If the block hasn't been downloaded, stop here
|
||
|
|
if ( pCurBlock->m_nDownloadStatus != CClientRecordingSessionBlock::DOWNLOADSTATUS_DOWNLOADED )
|
||
|
|
break;
|
||
|
|
|
||
|
|
// Block has been downloaded - update the counter
|
||
|
|
iGreatestConsecutiveBlockDownloaded = MAX( iGreatestConsecutiveBlockDownloaded, pCurBlock->m_iReconstruction );
|
||
|
|
|
||
|
|
++j;
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( iGreatestConsecutiveBlockDownloaded >= 0 );
|
||
|
|
Assert( iGreatestConsecutiveBlockDownloaded < m_vecBlocks.Count() );
|
||
|
|
|
||
|
|
// Cache
|
||
|
|
m_iGreatestConsecutiveBlockDownloaded = iGreatestConsecutiveBlockDownloaded;
|
||
|
|
|
||
|
|
// Mark session as dirty
|
||
|
|
CL_GetRecordingSessionManager()->FlagForFlush( this, false );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::UpdateReplayStatuses( CClientRecordingSessionBlock *pBlock )
|
||
|
|
{
|
||
|
|
AssertMsg( m_vecBlocks.Find( pBlock ) != m_vecBlocks.InvalidIndex(), "Block doesn't belong to session or was not added" );
|
||
|
|
|
||
|
|
// If the download was successful, update the greatest consecutive block downloaded index
|
||
|
|
if ( pBlock->m_nDownloadStatus == CClientRecordingSessionBlock::DOWNLOADSTATUS_DOWNLOADED )
|
||
|
|
{
|
||
|
|
UpdateGreatestConsecutiveBlockDownloaded();
|
||
|
|
UpdateAllBlocksDownloaded();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Block in error state?
|
||
|
|
const bool bFailed = pBlock->m_nDownloadStatus == CClientRecordingSessionBlock::DOWNLOADSTATUS_ERROR;
|
||
|
|
|
||
|
|
// Go through all replays that refer to this session and update their status if necessary
|
||
|
|
FOR_EACH_LL( m_lstReplays, i )
|
||
|
|
{
|
||
|
|
CReplay *pCurReplay = m_lstReplays[ i ];
|
||
|
|
|
||
|
|
// If this replay has already been set to "ready to convert" state (or beyond), skip.
|
||
|
|
if ( pCurReplay->m_nStatus >= CReplay::REPLAYSTATUS_READYTOCONVERT )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
bool bFlush = false;
|
||
|
|
|
||
|
|
// If the download failed and the block is required for this replay, mark as such
|
||
|
|
if ( bFailed && pCurReplay->m_iMaxSessionBlockRequired >= pBlock->m_iReconstruction )
|
||
|
|
{
|
||
|
|
pCurReplay->m_nStatus = CReplay::REPLAYSTATUS_ERROR;
|
||
|
|
bFlush = true;
|
||
|
|
|
||
|
|
// Display an error message
|
||
|
|
ShowDownloadFailedMessage( pCurReplay );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Have we downloaded all blocks required for the given replay?
|
||
|
|
else if ( !bFailed && pCurReplay->m_iMaxSessionBlockRequired <= m_iGreatestConsecutiveBlockDownloaded )
|
||
|
|
{
|
||
|
|
// Update replay's status and mark as dirty
|
||
|
|
pCurReplay->m_nStatus = CReplay::REPLAYSTATUS_READYTOCONVERT;
|
||
|
|
|
||
|
|
// Display a message on the client
|
||
|
|
g_pClient->DisplayReplayMessage( "#Replay_DownloadComplete", false, false, "replay\\downloadcomplete.wav" );
|
||
|
|
|
||
|
|
bFlush = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mark replay as dirty?
|
||
|
|
if ( bFlush )
|
||
|
|
{
|
||
|
|
CL_GetReplayManager()->FlagForFlush( pCurReplay, false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::OnDownloadTimeout()
|
||
|
|
{
|
||
|
|
m_bTimedOut = true;
|
||
|
|
|
||
|
|
// Go through all replays that refer to this session and update their status if necessary
|
||
|
|
FOR_EACH_LL( m_lstReplays, i )
|
||
|
|
{
|
||
|
|
CReplay *pCurReplay = m_lstReplays[ i ];
|
||
|
|
|
||
|
|
// If this replay has already been set to "ready to convert" state (or beyond), skip.
|
||
|
|
if ( pCurReplay->m_nStatus >= CReplay::REPLAYSTATUS_READYTOCONVERT )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
// Check to see if we have enough block info for the current replay
|
||
|
|
if ( m_iGreatestConsecutiveBlockDownloaded >= pCurReplay->m_iMaxSessionBlockRequired )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
// Update replay status
|
||
|
|
pCurReplay->m_nStatus = CReplay::REPLAYSTATUS_ERROR;
|
||
|
|
|
||
|
|
// Display an error message
|
||
|
|
ShowDownloadFailedMessage( pCurReplay );
|
||
|
|
|
||
|
|
// Save the replay
|
||
|
|
CL_GetReplayManager()->FlagForFlush( pCurReplay, false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::RefreshLastUpdateTime()
|
||
|
|
{
|
||
|
|
m_flLastUpdateTime = g_pEngine->GetHostTime();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::ShowDownloadFailedMessage( const CReplay *pReplay )
|
||
|
|
{
|
||
|
|
// Don't show the download failed message for replays that were saved during this run of the game.
|
||
|
|
if ( !pReplay || !pReplay->m_bSavedDuringThisSession )
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Display an error message
|
||
|
|
g_pClient->DisplayReplayMessage( "#Replay_DownloadFailed", true, false, "replay\\downloadfailed.wav" );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::CacheReplay( CReplay *pReplay )
|
||
|
|
{
|
||
|
|
Assert( m_lstReplays.Find( pReplay ) == m_lstReplays.InvalidIndex() );
|
||
|
|
m_lstReplays.AddToTail( pReplay );
|
||
|
|
|
||
|
|
// We should no longer auto-delete this session if CacheReplay() is being called. This
|
||
|
|
// can happen if the user connects to a server, saves a replay, deletes the replay (at
|
||
|
|
// which point auto-delete is flagged for the recording session), and then saves another
|
||
|
|
// replay. In this situation, we obviously don't want to delete the session anymore.
|
||
|
|
if ( m_bAutoDelete )
|
||
|
|
{
|
||
|
|
m_bAutoDelete = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CClientRecordingSession::ShouldSyncBlocksWithServer() const
|
||
|
|
{
|
||
|
|
// Already downloaded all blocks?
|
||
|
|
if ( m_bAllBlocksDownloaded )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// If block count is out of sync with the m_iLastBlockDownloaded we need to sync up
|
||
|
|
const bool bReachedMaxDownloadAttempts = m_nSessionInfoDownloadAttempts >= MAX_SESSION_INFO_DOWNLOAD_ATTEMPTS;
|
||
|
|
const bool bNeedToDownloadBlocks = m_iLastBlockToDownload >= 0;
|
||
|
|
// const bool bAlreadyDownloadedAllNeededBlocks = m_iLastBlockToDownload <= m_iGreatestConsecutiveBlockDownloaded;
|
||
|
|
const bool bAlreadyDownloadedAllNeededBlocks = m_iLastBlockToDownload < m_vecBlocks.Count(); // NOTE/TODO: Shouldn't this look at m_iGreatestConsecutiveBlockDownloaded? Tried for a week, but it caused bugs. Reverting for now. TODO
|
||
|
|
const bool bTimedOut = false;//TimedOut();
|
||
|
|
|
||
|
|
const bool bResult = !bReachedMaxDownloadAttempts &&
|
||
|
|
bNeedToDownloadBlocks &&
|
||
|
|
!bAlreadyDownloadedAllNeededBlocks &&
|
||
|
|
!bTimedOut;
|
||
|
|
|
||
|
|
if ( bResult )
|
||
|
|
{
|
||
|
|
IF_REPLAY_DBG( Warning( "Blocks out of sync for session %i - downloading session info now.\n", GetHandle() ) );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DBG3( "NOT syncing because:\n" );
|
||
|
|
if ( bReachedMaxDownloadAttempts ) DBG3( " - Reached maximum download attempts\n" );
|
||
|
|
if ( !bNeedToDownloadBlocks ) DBG3( " - No replay saved yet\n" );
|
||
|
|
if ( bAlreadyDownloadedAllNeededBlocks ) DBG3( " - Already downloaded all needed blocks\n" );
|
||
|
|
if ( bTimedOut ) DBG3( " - Download timed out (session info file didn't change after 90 seconds)\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
return bResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::PopulateWithRecordingData( int nCurrentRecordingStartTick )
|
||
|
|
{
|
||
|
|
BaseClass::PopulateWithRecordingData( nCurrentRecordingStartTick );
|
||
|
|
|
||
|
|
CClientRecordingSessionManager::ServerRecordingState_t *pServerState = &CL_GetRecordingSessionManager()->m_ServerRecordingState;
|
||
|
|
m_strName = pServerState->m_strSessionName;
|
||
|
|
|
||
|
|
// Get download URL from replicated cvars
|
||
|
|
m_strBaseDownloadURL = Replay_GetDownloadURL();
|
||
|
|
|
||
|
|
// Get server session ID
|
||
|
|
m_uServerSessionID = g_pClient->GetServerSessionId();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CClientRecordingSession::ShouldDitchSession() const
|
||
|
|
{
|
||
|
|
return BaseClass::ShouldDitchSession() || m_lstReplays.Count() == 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CClientRecordingSession::OnDelete()
|
||
|
|
{
|
||
|
|
// Abort any session block downloads now
|
||
|
|
CL_GetSessionBlockDownloader()->AbortDownloadsAndCleanup( this );
|
||
|
|
if ( m_pSessionInfoDownloader )
|
||
|
|
{
|
||
|
|
m_pSessionInfoDownloader->CleanupDownloader();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Delete blocks
|
||
|
|
BaseClass::OnDelete();
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------------
|