//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //=============================================================================// // replayserver.cpp: implementation of the CReplayServer class. // ////////////////////////////////////////////////////////////////////// #if defined( REPLAY_ENABLED ) #include #include #include #include #include #include #include #include #include #include "replayserver.h" #include "sv_client.h" #include "replayclient.h" #include "server.h" #include "sv_main.h" #include "framesnapshot.h" #include "networkstringtable.h" #include "cmodel_engine.h" #include "dt_recv_eng.h" #include "cdll_engine_int.h" #include "GameEventManager.h" #include "host.h" #include "dt_common_eng.h" #include "baseautocompletefilelist.h" #include "sv_steamauth.h" #include "con_nprint.h" #include "tier0/icommandline.h" #include "client_class.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" extern CNetworkStringTableContainer *networkStringTableContainerClient; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CReplayServer *replay = NULL; static void replay_title_changed_f( IConVar *var, const char *pOldString, float flOldValue ) { if ( replay && replay->IsActive() ) { replay->BroadcastLocalTitle(); } } static void replay_name_changed_f( IConVar *var, const char *pOldValue, float flOldValue ) { Steam3Server().NotifyOfServerNameChange(); } static ConVar replay_maxclients( "replay_maxclients", "128", 0, "Maximum client number on Replay server.", true, 0, true, 255 ); ConVar replay_autorecord( "replay_autorecord", "1", 0, "Automatically records all games as Replay demos." ); ConVar replay_name( "replay_name", "Replay", 0, "Replay host name", replay_name_changed_f ); static ConVar replay_password( "replay_password", "", FCVAR_NOTIFY | FCVAR_PROTECTED | FCVAR_DONTRECORD, "Replay password for all clients" ); static ConVar replay_overridemaster( "replay_overridemaster", "0", 0, "Overrides the Replay master root address." ); static ConVar replay_dispatchmode( "replay_dispatchmode", "1", 0, "Dispatch clients to relay proxies: 0=never, 1=if appropriate, 2=always" ); ConVar replay_transmitall( "replay_transmitall", "1", FCVAR_REPLICATED, "Transmit all entities (not only director view)" ); ConVar replay_debug( "replay_debug", "0", 0, "Replay debug info." ); ConVar replay_title( "replay_title", "Replay", 0, "Set title for Replay spectator UI", replay_title_changed_f ); static ConVar replay_deltacache( "replay_deltacache", "2", 0, "Enable delta entity bit stream cache" ); static ConVar replay_relayvoice( "replay_relayvoice", "1", 0, "Relay voice data: 0=off, 1=on" ); ConVar replay_movielength( "replay_movielength", "60", FCVAR_REPLICATED | FCVAR_DONTRECORD, "Replay movie length in seconds" ); ConVar replay_demolifespan( "replay_demolifespan", "5", FCVAR_REPLICATED | FCVAR_DONTRECORD, "The number of days allowed to pass before cleaning up replay demos.", true, 1, true, 30 ); ConVar replay_cleanup_time( "replay_cleanup_time", "1", FCVAR_REPLICATED | FCVAR_DONTRECORD, "The Replay system will periodically remove stale (never downloaded) .dem files from disk. This variable represents the " "amount of time (in hours) between each cleanup.", true, 1, true, 24 ); CReplayDeltaEntityCache::CReplayDeltaEntityCache() { Q_memset( m_Cache, 0, sizeof(m_Cache) ); m_nTick = 0; m_nMaxEntities = 0; m_nCacheSize = 0; } CReplayDeltaEntityCache::~CReplayDeltaEntityCache() { Flush(); } void CReplayDeltaEntityCache::Flush() { if ( m_nMaxEntities != 0 ) { // at least one entity was set for ( int i=0; i= m_nMaxEntities ) return NULL; DeltaEntityEntry_s *pEntry = m_Cache[nEntityIndex]; while ( pEntry ) { if ( pEntry->nDeltaTick == nDeltaTick ) { nBits = pEntry->nBits; return (unsigned char*)(pEntry) + sizeof(DeltaEntityEntry_s); } else { // keep searching entry list pEntry = pEntry->pNext; } } return NULL; } void CReplayDeltaEntityCache::AddDeltaBits( int nEntityIndex, int nDeltaTick, int nBits, bf_write *pBuffer ) { if ( nEntityIndex < 0 || nEntityIndex >= m_nMaxEntities || m_nCacheSize <= 0 ) return; int nBufferSize = PAD_NUMBER( Bits2Bytes(nBits), 4); DeltaEntityEntry_s *pEntry = m_Cache[nEntityIndex]; if ( pEntry == NULL ) { if ( (int)(nBufferSize+sizeof(DeltaEntityEntry_s)) > m_nCacheSize ) return; // way too big, don't even create an entry pEntry = m_Cache[nEntityIndex] = (DeltaEntityEntry_s *) malloc( m_nCacheSize ); } else { char *pEnd = (char*)(pEntry) + m_nCacheSize; // end marker while( pEntry->pNext ) { pEntry = pEntry->pNext; } int entrySize = sizeof(DeltaEntityEntry_s) + PAD_NUMBER( Bits2Bytes(pEntry->nBits), 4); DeltaEntityEntry_s *pNew = (DeltaEntityEntry_s*)((char*)(pEntry) + entrySize); if ( ((char*)(pNew) + sizeof(DeltaEntityEntry_s) + nBufferSize) > pEnd ) return; // data wouldn't fit into cache anymore, don't add new entries pEntry->pNext = pEntry = pNew; } pEntry->pNext = NULL; // link to next pEntry->nDeltaTick = nDeltaTick; pEntry->nBits = nBits; if ( nBits > 0 ) { bf_read inBuffer; inBuffer.StartReading( pBuffer->GetData(), pBuffer->m_nDataBytes, pBuffer->GetNumBitsWritten() ); bf_write outBuffer( (char*)(pEntry) + sizeof(DeltaEntityEntry_s), nBufferSize ); outBuffer.WriteBitsFromBuffer( &inBuffer, nBits ); } } static RecvTable* FindRecvTable( const char *pName, RecvTable **pRecvTables, int nRecvTables ) { for ( int i=0; i< nRecvTables; i++ ) { if ( !Q_strcmp( pName, pRecvTables[i]->GetName() ) ) return pRecvTables[i]; } return NULL; } static RecvTable* AddRecvTableR( SendTable *sendt, RecvTable **pRecvTables, int &nRecvTables ) { RecvTable *recvt = FindRecvTable( sendt->m_pNetTableName, pRecvTables, nRecvTables ); if ( recvt ) return recvt; // already in list if ( sendt->m_nProps > 0 ) { RecvProp *receiveProps = new RecvProp[sendt->m_nProps]; for ( int i=0; i < sendt->m_nProps; i++ ) { // copy property data SendProp * sp = sendt->GetProp( i ); RecvProp * rp = &receiveProps[i]; rp->m_pVarName = sp->m_pVarName; rp->m_RecvType = sp->m_Type; if ( sp->IsExcludeProp() ) { // if prop is excluded, give different name rp->m_pVarName = "IsExcludedProp"; } if ( sp->IsInsideArray() ) { rp->SetInsideArray(); rp->m_pVarName = "InsideArrayProp"; // give different name } if ( sp->GetType() == DPT_Array ) { Assert ( sp->GetArrayProp() == sendt->GetProp( i-1 ) ); Assert( receiveProps[i-1].IsInsideArray() ); rp->SetArrayProp( &receiveProps[i-1] ); rp->InitArray( sp->m_nElements, sp->m_ElementStride ); } if ( sp->GetType() == DPT_DataTable ) { // recursive create Assert ( sp->GetDataTable() ); RecvTable *subTable = AddRecvTableR( sp->GetDataTable(), pRecvTables, nRecvTables ); rp->SetDataTable( subTable ); } } recvt = new RecvTable( receiveProps, sendt->m_nProps, sendt->m_pNetTableName ); } else { // table with no properties recvt = new RecvTable( NULL, 0, sendt->m_pNetTableName ); } pRecvTables[nRecvTables] = recvt; nRecvTables++; return recvt; } void CReplayServer::FreeClientRecvTables() { for ( int i=0; i< m_nRecvTables; i++ ) { RecvTable *rt = m_pRecvTables[i]; // delete recv table props if ( rt->m_pProps ) { Assert( rt->m_nProps > 0 ); delete [] rt->m_pProps; } // delete the table itself delete rt; } Q_memset( m_pRecvTables, 0, sizeof( m_pRecvTables ) ); m_nRecvTables = 0; } // creates client receive tables from server send tables void CReplayServer::InitClientRecvTables() { ServerClass* pCur = NULL; if ( ClientDLL_GetAllClasses() != NULL ) return; //already initialized // first create all SendTables for ( pCur = serverGameDLL->GetAllServerClasses(); pCur; pCur=pCur->m_pNext ) { // create receive table from send table. AddRecvTableR( pCur->m_pTable, m_pRecvTables, m_nRecvTables ); ErrorIfNot( m_nRecvTables < ARRAYSIZE( m_pRecvTables ), ("AddRecvTableR: overflowed MAX_DATATABLES") ); } // now register client classes for ( pCur = serverGameDLL->GetAllServerClasses(); pCur; pCur=pCur->m_pNext ) { ErrorIfNot( m_nRecvTables < ARRAYSIZE( m_pRecvTables ), ("ClientDLL_InitRecvTableMgr: overflowed MAX_DATATABLES") ); // find top receive table for class RecvTable * recvt = FindRecvTable( pCur->m_pTable->GetName(), m_pRecvTables, m_nRecvTables ); Assert ( recvt ); // register class, constructor addes clientClass to g_pClientClassHead list ClientClass * clientclass = new ClientClass( pCur->m_pNetworkName, NULL, NULL, recvt ); if ( !clientclass ) { Msg("REPLAY_InitRecvTableMgr: failed to allocate client class %s.\n", pCur->m_pNetworkName ); return; } } RecvTable_Init( m_pRecvTables, m_nRecvTables ); } CReplayFrame::CReplayFrame() { } CReplayFrame::~CReplayFrame() { FreeBuffers(); } void CReplayFrame::Reset( void ) { for ( int i=0; i 0 ) return true; } return false; } void CReplayFrame::CopyReplayData( CReplayFrame &frame ) { // copy reliable messages int bits = frame.m_Messages[REPLAY_BUFFER_RELIABLE].GetNumBitsWritten(); if ( bits > 0 ) { int bytes = PAD_NUMBER( Bits2Bytes(bits), 4 ); m_Messages[REPLAY_BUFFER_RELIABLE].StartWriting( new char[ bytes ], bytes, bits ); Q_memcpy( m_Messages[REPLAY_BUFFER_RELIABLE].GetBasePointer(), frame.m_Messages[REPLAY_BUFFER_RELIABLE].GetBasePointer(), bytes ); } // copy unreliable messages bits = frame.m_Messages[REPLAY_BUFFER_UNRELIABLE].GetNumBitsWritten(); bits += frame.m_Messages[REPLAY_BUFFER_TEMPENTS].GetNumBitsWritten(); bits += frame.m_Messages[REPLAY_BUFFER_SOUNDS].GetNumBitsWritten(); if ( replay_relayvoice.GetBool() ) bits += frame.m_Messages[REPLAY_BUFFER_VOICE].GetNumBitsWritten(); if ( bits > 0 ) { // collapse all unreliable buffers in one int bytes = PAD_NUMBER( Bits2Bytes(bits), 4 ); m_Messages[REPLAY_BUFFER_UNRELIABLE].StartWriting( new char[ bytes ], bytes ); m_Messages[REPLAY_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[REPLAY_BUFFER_UNRELIABLE].GetData(), frame.m_Messages[REPLAY_BUFFER_UNRELIABLE].GetNumBitsWritten() ); m_Messages[REPLAY_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[REPLAY_BUFFER_TEMPENTS].GetData(), frame.m_Messages[REPLAY_BUFFER_TEMPENTS].GetNumBitsWritten() ); m_Messages[REPLAY_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[REPLAY_BUFFER_SOUNDS].GetData(), frame.m_Messages[REPLAY_BUFFER_SOUNDS].GetNumBitsWritten() ); if ( replay_relayvoice.GetBool() ) m_Messages[REPLAY_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[REPLAY_BUFFER_VOICE].GetData(), frame.m_Messages[REPLAY_BUFFER_VOICE].GetNumBitsWritten() ); } } void CReplayFrame::AllocBuffers( void ) { // allocate buffers for input frame for ( int i=0; i < REPLAY_BUFFER_MAX; i++ ) { Assert( m_Messages[i].GetBasePointer() == NULL ); m_Messages[i].StartWriting( new char[NET_MAX_PAYLOAD], NET_MAX_PAYLOAD); } } void CReplayFrame::FreeBuffers( void ) { for ( int i=0; i 0 ) { RecvTable_Term(); FreeClientRecvTables(); } // make sure everything was destroyed Assert( m_CurrentFrame == NULL ); Assert( CountClientFrames() == 0 ); } void CReplayServer::SetMaxClients( int number ) { // allow max clients 0 in Replay m_nMaxclients = clamp( number, 0, ABSOLUTE_PLAYER_LIMIT ); } void CReplayServer::StartMaster(CGameClient *client) { Clear(); // clear old settings & buffers if ( !client ) { ConMsg("Replay client not found.\n"); return; } m_Director = serverReplayDirector; if ( !m_Director ) { ConMsg("Mod doesn't support Replay. No director module found.\n"); return; } m_MasterClient = client; m_MasterClient->m_bIsHLTV = false; m_MasterClient->m_bIsReplay = true; // let game.dll know that we are the Replay client Assert( serverGameClients ); CPlayerState *player = serverGameClients->GetPlayerState( m_MasterClient->edict ); player->replay = true; m_Server = (CGameServer*)m_MasterClient->GetServer(); // set default user settings m_MasterClient->m_ConVars->SetString( "name", replay_name.GetString() ); m_MasterClient->m_ConVars->SetString( "cl_team", "1" ); m_MasterClient->m_ConVars->SetString( "rate", va( "%d", DEFAULT_RATE ) ); m_MasterClient->m_ConVars->SetString( "cl_updaterate", "32" ); m_MasterClient->m_ConVars->SetString( "cl_interp_ratio", "1.0" ); m_MasterClient->m_ConVars->SetString( "cl_predict", "0" ); m_nViewEntity = m_MasterClient->GetPlayerSlot() + 1; m_nPlayerSlot = m_MasterClient->GetPlayerSlot(); // copy server settings from m_Server m_nGameServerMaxClients = m_Server->GetMaxClients(); // maxclients is different on proxy (128) serverclasses = m_Server->serverclasses; serverclassbits = m_Server->serverclassbits; worldmapCRC = m_Server->worldmapCRC; clientDllCRC = m_Server->clientDllCRC; m_flTickInterval= m_Server->GetTickInterval(); // allocate buffers for input frame m_ReplayFrame.AllocBuffers(); InstallStringTables(); // activate director in game.dll m_Director->SetReplayServer( this ); // register as listener for mod specific events const char **modevents = m_Director->GetModEvents(); int j = 0; while ( modevents[j] != NULL ) { const char *eventname = modevents[j]; CGameEventDescriptor *descriptor = g_GameEventManager.GetEventDescriptor( eventname ); if ( descriptor ) { g_GameEventManager.AddListener( this, descriptor, CGameEventManager::CLIENTSTUB ); } else { DevMsg("CReplayServer::StartMaster: game event %s not found.\n", eventname ); } j++; } // copy signon buffers m_Signon.StartWriting( m_Server->m_Signon.GetBasePointer(), m_Server->m_Signon.m_nDataBytes, m_Server->m_Signon.GetNumBitsWritten() ); Q_strncpy( m_szMapname, m_Server->m_szMapname, sizeof(m_szMapname) ); Q_strncpy( m_szSkyname, m_Server->m_szSkyname, sizeof(m_szSkyname) ); NET_ListenSocket( m_Socket, true ); // activated Replay TCP socket m_MasterClient->ExecuteStringCommand( "spectate" ); // become a spectator m_MasterClient->UpdateUserSettings(); // make sure UserInfo is correct // hack reduce signontick by one to catch changes made in the current tick m_MasterClient->m_nSignonTick--; if ( m_bMasterOnlyMode ) { // we allow only one client in master only mode replay_maxclients.SetValue( MIN(1,replay_maxclients.GetInt()) ); } SetMaxClients( replay_maxclients.GetInt() ); m_bSignonState = false; //master proxy is instantly connected m_nSpawnCount++; m_flStartTime = net_time; m_State = ss_active; // stop any previous recordings m_DemoRecorder.StopRecording(); // start new recording if autorecord is enabled if ( replay_autorecord.GetBool() ) { m_DemoRecorder.StartAutoRecording(); } ReconnectClients(); } void CReplayServer::StartDemo(const char *filename) { } bool CReplayServer::DispatchToRelay( CReplayClient *pClient ) { if ( replay_dispatchmode.GetInt() <= DISPATCH_MODE_OFF ) return false; // don't redirect CBaseClient *pBestProxy = NULL; float fBestRatio = 1.0f; // find best relay proxy for (int i=0; i < GetClientCount(); i++ ) { CBaseClient *pProxy = m_Clients[ i ]; // check all known proxies if ( !pProxy->IsConnected() || !pProxy->IsReplay() || (pClient == pProxy) ) continue; int slots = Q_atoi( pProxy->GetUserSetting( "replay_slots" ) ); int clients = Q_atoi( pProxy->GetUserSetting( "replay_clients" ) ); // skip overloaded proxies or proxies with no slots at all if ( (clients > slots) || slots <= 0 ) continue; // calc clients/slots ratio for this proxy float ratio = ((float)(clients))/((float)slots); if ( ratio < fBestRatio ) { fBestRatio = ratio; pBestProxy = pProxy; } } if ( pBestProxy == NULL ) { if ( replay_dispatchmode.GetInt() == DISPATCH_MODE_ALWAYS ) { // we are in always forward mode, drop client if we can't forward it pClient->Disconnect("No Replay relay available"); return true; } else { // just let client connect to this proxy return false; } } // check if client should stay on this relay server if ( (replay_dispatchmode.GetInt() == DISPATCH_MODE_AUTO) && (GetMaxClients() > 0) ) { // ratio = clients/slots. give relay proxies 25% bonus float myRatio = ((float)GetNumClients()/(float)GetMaxClients()) * 1.25f; myRatio = MIN( myRatio, 1.0f ); // clamp to 1 // if we have a better local ratio then other proxies, keep this client here if ( myRatio < fBestRatio ) return false; // don't redirect } const char *pszRelayAddr = pBestProxy->GetUserSetting("replay_addr"); if ( !pszRelayAddr ) return false; ConMsg( "Redirecting spectator %s to Replay relay %s\n", pClient->GetNetChannel()->GetAddress(), pszRelayAddr ); // first tell that client that we are a Replay server, // otherwise it's might ignore the "connect" command CSVCMsg_ServerInfo_t serverInfo; FillServerInfo( serverInfo ); pClient->SendNetMsg( serverInfo, true ); // tell the client to connect to this new address CNETMsg_StringCmd_t cmdMsg( va("connect %s\n", pszRelayAddr ) ) ; pClient->SendNetMsg( cmdMsg, true ); // increase this proxies client number in advance so this proxy isn't used again next time int clients = Q_atoi( pBestProxy->GetUserSetting( "replay_clients" ) ); pBestProxy->SetUserCVar( "replay_clients", va("%d", clients+1 ) ); return true; } int CReplayServer::GetReplaySlot( void ) { return m_nPlayerSlot; } float CReplayServer::GetOnlineTime( void ) { return MAX(0, net_time - m_flStartTime); } void CReplayServer::BroadcastLocalTitle( CReplayClient *client ) { IGameEvent *event = g_GameEventManager.CreateEvent( "replay_title", true ); if ( !event ) return; event->SetString( "text", replay_title.GetString() ); CSVCMsg_GameEvent_t eventMsg; eventMsg.SetReliable( true ); // create bit stream from KeyValues if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) ) { DevMsg("CReplayServer: failed to serialize title '%s'.\n", event->GetName() ); g_GameEventManager.FreeEvent( event ); return; } if ( client ) { client->SendNetMsg( eventMsg ); } else { for ( int i = 0; i < m_Clients.Count(); i++ ) { client = Client(i); if ( !client->IsActive() || client->IsReplay() ) continue; client->SendNetMsg( eventMsg ); } } g_GameEventManager.FreeEvent( event ); } void CReplayServer::BroadcastLocalChat( const char *pszChat, const char *pszGroup ) { IGameEvent *event = g_GameEventManager.CreateEvent( "replay_chat", true ); if ( !event ) return; event->SetString( "text", pszChat ); CSVCMsg_GameEvent_t eventMsg; eventMsg.SetReliable( false ); // create bit stream from KeyValues if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) ) { DevMsg("CReplayServer: failed to serialize chat '%s'.\n", event->GetName() ); g_GameEventManager.FreeEvent( event ); return; } for ( int i = 0; i < m_Clients.Count(); i++ ) { CReplayClient *cl = Client(i); if ( !cl->IsActive() || !cl->IsSpawned() || cl->IsReplay() ) continue; // if this is a spectator chat message and client disabled it, don't show it if ( Q_strcmp( cl->m_szChatGroup, pszGroup) || cl->m_bNoChat ) continue; cl->SendNetMsg( eventMsg ); } g_GameEventManager.FreeEvent( event ); } void CReplayServer::BroadcastEventLocal( IGameEvent *event, bool bReliable ) { CSVCMsg_GameEvent_t eventMsg; eventMsg.SetReliable( bReliable ); // create bit stream from KeyValues if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) ) { DevMsg("CReplayServer: failed to serialize local event '%s'.\n", event->GetName() ); return; } for ( int i = 0; i < m_Clients.Count(); i++ ) { CReplayClient *cl = Client(i); if ( !cl->IsActive() || !cl->IsSpawned() || cl->IsReplay() ) continue; if ( !cl->SendNetMsg( eventMsg ) ) { if ( eventMsg.IsReliable() ) { DevMsg( "BroadcastMessage: Reliable broadcast message overflow for client %s", cl->GetClientName() ); } } } if ( replay_debug.GetBool() ) Msg("Replay broadcast local event: %s\n", event->GetName() ); } void CReplayServer::BroadcastEvent(IGameEvent *event) { CSVCMsg_GameEvent_t eventMsg; // create bit stream from KeyValues if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) ) { DevMsg("CReplayServer: failed to serialize event '%s'.\n", event->GetName() ); return; } BroadcastMessage( eventMsg, true, true ); if ( replay_debug.GetBool() ) Msg("Replay broadcast event: %s\n", event->GetName() ); } void CReplayServer::FireGameEvent(IGameEvent *event) { if ( !IsActive() ) return; CSVCMsg_GameEvent_t eventMsg; // create bit stream from KeyValues if ( g_GameEventManager.SerializeEvent( event, &eventMsg ) ) { SendNetMsg( eventMsg ); } else { DevMsg("CReplayServer::FireGameEvent: failed to serialize event '%s'.\n", event->GetName() ); } } int CReplayServer::GetEventDebugID() { return m_nDebugID; } bool CReplayServer::ShouldUpdateMasterServer() { if ( IsUsingMasterLegacyMode() ) { // In the legacy master server updater, we have to call the updater with our CBaseServer* for it to work right. return true; } else { // If the main game server is active, then we let it update Steam with the server info. return !sv.IsActive(); } } CBaseClient *CReplayServer::CreateNewClient(int slot ) { return new CReplayClient( slot, this ); } void CReplayServer::InstallStringTables( void ) { #ifndef SHARED_NET_STRING_TABLES int numTables = m_Server->m_StringTables->GetNumTables(); m_StringTables = &m_NetworkStringTables; Assert( m_StringTables->GetNumTables() == 0); // must be empty m_StringTables->AllowCreation( true ); // master replay needs to keep a list of changes for all table items m_StringTables->EnableRollback( true ); for ( int i =0; im_StringTables->GetTable( i ); if ( !serverTable ) continue; // get matching client table CNetworkStringTable *replayTable = (CNetworkStringTable*)m_StringTables->CreateStringTable( serverTable->GetTableName(), serverTable->GetMaxStrings(), serverTable->GetUserDataSize(), serverTable->GetUserDataSizeBits(), serverTable->IsUsingDictionary() ? NSF_DICTIONARY_ENABLED : NSF_NONE ); if ( !replayTable ) { DevMsg("SV_InstallReplayStringTableMirrors! Missing client table \"%s\".\n ", serverTable->GetTableName() ); continue; } // make replay table an exact copy of server table replayTable->CopyStringTable( serverTable ); // link replay table to server table serverTable->SetMirrorTable( replayTable ); } m_StringTables->AllowCreation( false ); #endif } void CReplayServer::RestoreTick( int tick ) { #ifndef SHARED_NET_STRING_TABLES int numTables = m_StringTables->GetNumTables(); for ( int i =0; iGetTable( i ); pTable->RestoreTick( tick ); } #endif } void CReplayServer::UserInfoChanged( int nClientIndex ) { // don't change UserInfo table, it keeps the infos of the original players } void CReplayServer::LinkInstanceBaselines( void ) { // Forces to update m_pInstanceBaselineTable. AUTO_LOCK_FM( g_svInstanceBaselineMutex ); GetInstanceBaselineTable(); Assert( m_pInstanceBaselineTable ); // update all found server classes for ( ServerClass *pClass = serverGameDLL->GetAllServerClasses(); pClass; pClass=pClass->m_pNext ) { char idString[32]; Q_snprintf( idString, sizeof( idString ), "%d", pClass->m_ClassID ); // Ok, make a new instance baseline so they can reference it. int index = m_pInstanceBaselineTable->FindStringIndex( idString ); if ( index != -1 ) { pClass->m_InstanceBaselineIndex = index; } else { pClass->m_InstanceBaselineIndex = INVALID_STRING_INDEX; } } } /* CReplayServer::GetOriginFromPackedEntity is such a bad, bad hack. extern float DecodeFloat(SendProp const *pProp, bf_read *pIn); Vector CReplayServer::GetOriginFromPackedEntity(PackedEntity* pe) { Vector origin; origin.Init(); SendTable *pSendTable = pe->m_pSendTable; // recursively go down until BaseEntity sendtable while ( Q_strcmp( pSendTable->GetName(), "DT_BaseEntity") ) { SendProp *pProp = pSendTable->GetProp( 0 ); // 0 = baseclass pSendTable = pProp->GetDataTable(); } for ( int i=0; i < pSendTable->GetNumProps(); i++ ) { SendProp *pProp = pSendTable->GetProp( i ); if ( Q_strcmp( pProp->GetName(), "m_vecOrigin" ) == 0 ) { Assert( pProp->GetType() == DPT_Vector ); bf_read buf( pe->LockData(), Bits2Bytes(pe->GetNumBits()), pProp->GetOffset() ); origin[0] = DecodeFloat(pProp, &buf); origin[1] = DecodeFloat(pProp, &buf); origin[2] = DecodeFloat(pProp, &buf); break; } } return origin; } */ CReplayEntityData *FindReplayDataInSnapshot( CFrameSnapshot * pSnapshot, int iEntIndex ) { int a = 0; int z = pSnapshot->m_nValidEntities-1; if ( iEntIndex < pSnapshot->m_pValidEntities[a] || iEntIndex > pSnapshot->m_pValidEntities[z] ) return NULL; while ( a < z ) { int m = (a+z)/2; int index = pSnapshot->m_pValidEntities[m]; if ( index == iEntIndex ) return &pSnapshot->m_pReplayEntityData[m]; if ( iEntIndex > index ) { if ( pSnapshot->m_pValidEntities[z] == iEntIndex ) return &pSnapshot->m_pReplayEntityData[z]; if ( a == m ) return NULL; a = m; } else { if ( pSnapshot->m_pValidEntities[a] == iEntIndex ) return &pSnapshot->m_pReplayEntityData[a]; if ( z == m ) return NULL; z = m; } } return NULL; } void CReplayServer::EntityPVSCheck( CClientFrame *pFrame ) { byte PVS[PAD_NUMBER( MAX_MAP_CLUSTERS,8 ) / 8]; int nPVSSize = (GetCollisionBSPData()->numclusters + 7) / 8; // setup engine PVS SV_ResetPVS( PVS, nPVSSize ); CFrameSnapshot * pSnapshot = pFrame->GetSnapshot(); Assert ( pSnapshot->m_pReplayEntityData != NULL ); int nDirectorEntity = m_Director->GetPVSEntity(); if ( pSnapshot && nDirectorEntity > 0 ) { CReplayEntityData *pReplayData = FindReplayDataInSnapshot( pSnapshot, nDirectorEntity ); if ( pReplayData ) { m_vPVSOrigin.x = pReplayData->origin[0]; m_vPVSOrigin.y = pReplayData->origin[1]; m_vPVSOrigin.z = pReplayData->origin[2]; } } else { m_vPVSOrigin = m_Director->GetPVSOrigin(); } SV_AddOriginToPVS( m_vPVSOrigin ); // know remove all entities that aren't in PVS int entindex = -1; while ( true ) { entindex = pFrame->transmit_entity.FindNextSetBit( entindex+1 ); if ( entindex < 0 ) break; // is transmit_always is set -> no PVS check if ( pFrame->transmit_always->Get(entindex) ) { pFrame->last_entity = entindex; continue; } CReplayEntityData *pReplayData = FindReplayDataInSnapshot( pSnapshot, entindex ); if ( !pReplayData ) continue; unsigned int nNodeCluster = pReplayData->m_nNodeCluster; // check if node or cluster is in PVS if ( nNodeCluster & (1<<31) ) { // it's a node SLOW nNodeCluster &= ~(1<<31); if ( CM_HeadnodeVisible( nNodeCluster, PVS, nPVSSize ) ) { pFrame->last_entity = entindex; continue; } } else { // it's a cluster QUICK if ( PVS[nNodeCluster >> 3] & (1 << (nNodeCluster & 7)) ) { pFrame->last_entity = entindex; continue; } } // entity is not in PVS, remove from transmit_entity list pFrame->transmit_entity.Clear( entindex ); } } CClientFrame *CReplayServer::AddNewFrame( CClientFrame *clientFrame ) { VPROF_BUDGET( "CReplayServer::AddNewFrame", "Replay" ); Assert ( clientFrame ); Assert( clientFrame->tick_count > m_nLastTick ); m_nLastTick = clientFrame->tick_count; m_ReplayFrame.SetSnapshot( clientFrame->GetSnapshot() ); m_ReplayFrame.tick_count = clientFrame->tick_count; m_ReplayFrame.last_entity = clientFrame->last_entity; m_ReplayFrame.transmit_entity = clientFrame->transmit_entity; // remember tick of first valid frame if ( m_nFirstTick < 0 ) { m_nFirstTick = clientFrame->tick_count; m_nTickCount = m_nFirstTick; } CReplayFrame *replayFrame = new CReplayFrame; // copy tickcount & entities from client frame replayFrame->CopyFrame( *clientFrame ); //copy rest (messages, tempents) from current Replay frame replayFrame->CopyReplayData( m_ReplayFrame ); // add frame to Replay server AddClientFrame( replayFrame ); if ( m_DemoRecorder.IsRecording() ) { m_DemoRecorder.WriteFrame( &m_ReplayFrame ); } // reset Replay frame for recording next messages etc. m_ReplayFrame.Reset(); m_ReplayFrame.SetSnapshot( NULL ); return replayFrame; } void CReplayServer::SendClientMessages ( bool bSendSnapshots ) { // build individual updates for ( int i=0; i< m_Clients.Count(); i++ ) { CReplayClient* client = Client(i); // Update Host client send state... if ( !client->ShouldSendMessages() ) { continue; } // Append the unreliable data (player updates and packet entities) if ( m_CurrentFrame && client->IsActive() ) { // don't send same snapshot twice client->SendSnapshot( m_CurrentFrame ); } else { // Connected, but inactive, just send reliable, sequenced info. client->m_NetChannel->Transmit(); } client->UpdateSendState(); client->m_fLastSendTime = net_time; } } bool CReplayServer::SendNetMsg( INetMessage &msg, bool bForceReliable ) { if ( m_bSignonState ) { return msg.WriteToBuffer( m_Signon ); } int buffer = REPLAY_BUFFER_UNRELIABLE; // default destination if ( msg.IsReliable() ) { buffer = REPLAY_BUFFER_RELIABLE; } else if ( msg.GetType() == svc_Sounds ) { buffer = REPLAY_BUFFER_SOUNDS; } else if ( msg.GetType() == svc_VoiceData ) { buffer = REPLAY_BUFFER_VOICE; } else if ( msg.GetType() == svc_TempEntities ) { buffer = REPLAY_BUFFER_TEMPENTS; } // anything else goes to the unreliable bin return msg.WriteToBuffer( m_ReplayFrame.m_Messages[buffer] ); } bf_write *CReplayServer::GetBuffer( int nBuffer ) { if ( nBuffer < 0 || nBuffer >= REPLAY_BUFFER_MAX ) return NULL; return &m_ReplayFrame.m_Messages[nBuffer]; } IServer *CReplayServer::GetBaseServer() { return (IServer*)this; } IReplayDirector *CReplayServer::GetDirector() { return m_Director; } CClientFrame *CReplayServer::GetDeltaFrame( int nTick ) { if ( !replay_deltacache.GetBool() ) return GetClientFrame( nTick ); //expensive // TODO make that a utlmap FOR_EACH_VEC( m_FrameCache, iFrame ) { if ( m_FrameCache[iFrame].nTick == nTick ) return m_FrameCache[iFrame].pFrame; } int i = m_FrameCache.AddToTail(); CReplayFrameCacheEntry_s &entry = m_FrameCache[i]; entry.nTick = nTick; entry.pFrame = GetClientFrame( nTick ); //expensive return entry.pFrame; } void CReplayServer::RunFrame() { VPROF_BUDGET( "CReplayServer::RunFrame", "Replay" ); // update network time etc NET_RunFrame( Plat_FloatTime() ); // check if Replay server if active if ( !IsActive() ) return; if ( host_frametime > 0 ) { m_flFPS = m_flFPS * 0.99f + 0.01f/host_frametime; } // get current tick time for director module and restore // world (stringtables, framebuffers) as they were at this time UpdateTick(); // Run any commands from client and play client Think functions if it is time. CBaseServer::RunFrame(); SendClientMessages( true ); // Update the Steam server if we're running a relay. if ( !sv.IsActive() ) Steam3Server().RunFrame(); UpdateMasterServer(); // ::Con_NPrintf( 9 , "server time: %d", host_tickcount ); // ::Con_NPrintf( 10, "replay time: %d", m_DemoRecorder.GetRecordingTick() ); } void CReplayServer::UpdateTick( void ) { VPROF_BUDGET( "CReplayServer::UpdateTick", "Replay" ); if ( m_nFirstTick < 0 ) { m_nTickCount = 0; m_CurrentFrame = NULL; return; } // HACK: I'm not so sure this is the right place for this, but essentially the start tick needs to // represent the "oldest" tick in the cache of frames for a replay demo - for a regular demo, it need // not be modified here. NOTE: If this is a regular demo, this call does nothing. m_DemoRecorder.m_DemoFile.UpdateStartTick( m_DemoRecorder.m_nStartTick ); // set tick time to last frame added int nNewTick = m_nLastTick; // get tick from director, he decides delay etc nNewTick = MAX( m_nFirstTick, m_Director->GetDirectorTick() ); // the the closest available frame CReplayFrame *newFrame = (CReplayFrame*) GetClientFrame( nNewTick, false ); if ( newFrame == NULL ) return; // we dont have a new frame if ( m_CurrentFrame == newFrame ) return; // current frame didn't change m_CurrentFrame = newFrame; m_nTickCount = m_CurrentFrame->tick_count; // restore string tables for this time RestoreTick( m_nTickCount ); // remove entities out of current PVS if ( !replay_transmitall.GetBool() ) { EntityPVSCheck( m_CurrentFrame ); } int removeTick = m_nTickCount - 16.0f/m_flTickInterval; // keep 16 second buffer if ( removeTick > 0 ) { DeleteClientFrames( removeTick ); } m_FrameCache.RemoveAll(); } const char *CReplayServer::GetName( void ) const { return replay_name.GetString(); } void CReplayServer::FillServerInfo(CSVCMsg_ServerInfo &serverinfo) { CBaseServer::FillServerInfo( serverinfo ); serverinfo.set_player_slot( m_nPlayerSlot ); // all spectators think they're the Replay client serverinfo.set_max_clients( m_nGameServerMaxClients ); } void CReplayServer::Clear( void ) { CBaseServer::Clear(); m_Director = NULL; m_MasterClient = NULL; m_Server = NULL; m_nFirstTick = -1; m_nLastTick = 0; m_nTickCount = 0; m_CurrentFrame = NULL; m_nPlayerSlot = 0; m_flStartTime = 0.0f; m_nViewEntity = 1; m_nGameServerMaxClients = 0; m_fNextSendUpdateTime = 0.0f; m_ReplayFrame.FreeBuffers(); m_vPVSOrigin.Init(); m_vecClientsDownloading.ClearAll(); DeleteClientFrames( -1 ); m_DeltaCache.Flush(); m_FrameCache.RemoveAll(); } void CReplayServer::Init(bool bIsDedicated) { CBaseServer::Init( bIsDedicated ); m_Socket = NS_REPLAY; // check if only master proxy is allowed, no broadcasting if ( CommandLine()->FindParm("-tvmasteronly") ) { m_bMasterOnlyMode = true; } } void CReplayServer::Changelevel() { m_DemoRecorder.StopRecording(); InactivateClients(); DeleteClientFrames(-1); m_CurrentFrame = NULL; } void CReplayServer::GetNetStats( float &avgIn, float &avgOut ) { CBaseServer::GetNetStats( avgIn, avgOut ); } void CReplayServer::Shutdown( void ) { m_DemoRecorder.StopRecording(); // if recording, stop now if ( m_MasterClient ) m_MasterClient->Disconnect( "Replay stop." ); if ( m_Director ) m_Director->SetReplayServer( NULL ); g_GameEventManager.RemoveListener( this ); CBaseServer::Shutdown(); } int CReplayServer::GetChallengeType ( netadr_t &adr ) { return PROTOCOL_HASHEDCDKEY; // Replay doesn't need Steam authentication } const char *CReplayServer::GetPassword() const { const char *password = replay_password.GetString(); // if password is empty or "none", return NULL if ( !password[0] || !Q_stricmp(password, "none" ) ) { return NULL; } return password; } IClient *CReplayServer::ConnectClient ( const ns_address &adr, int protocol, int challenge, int authProtocol, const char *name, const char *password, const char *hashedCDkey, int cdKeyLen, CUtlVector< CCLCMsg_SplitPlayerConnect_t * > & splitScreenClients, bool isClientLowViolence, CrossPlayPlatform_t clientPlatform, const byte *pbEncryptionKey, int nEncryptionKeyIndex ) { IClient *client = (CReplayClient*)CBaseServer::ConnectClient( adr, protocol, challenge,authProtocol, name, password, hashedCDkey, cdKeyLen, splitScreenClients, isClientLowViolence, clientPlatform, pbEncryptionKey, nEncryptionKeyIndex ); if ( client ) { // remember password CReplayClient *pReplayClient = (CReplayClient*)client; Q_strncpy( pReplayClient->m_szPassword, password, sizeof(pReplayClient->m_szPassword) ); } return client; } CON_COMMAND( replay_status, "Show Replay server status." ) { float in, out; char gd[MAX_OSPATH]; Q_FileBase( com_gamedir, gd, sizeof( gd ) ); if ( !replay || !replay->IsActive() ) { ConMsg("Replay not active.\n" ); return; } replay->GetNetStats( in, out ); in /= 1024; // as KB out /= 1024; ConMsg("--- Replay Status ---\n"); ConMsg("Online %s, FPS %.1f, Version %i (%s)\n", COM_FormatSeconds( replay->GetOnlineTime() ), replay->m_flFPS, build_number(), #ifdef _WIN32 "Win32" ); #else "Linux" ); #endif ConMsg("Master \"%s\", delay %.0f\n", replay->GetName(), replay->GetDirector()->GetDelay() ); ConMsg("Game Time %s, Mod \"%s\", Map \"%s\", Players %i\n", COM_FormatSeconds( replay->GetTime() ), gd, replay->GetMapName(), replay->GetNumPlayers() ); ConMsg("Local IP %s:%i, KB/sec In %.1f, Out %.1f\n", net_local_adr.ToString( true ), replay->GetUDPPort(), in ,out ); if ( replay->m_DemoRecorder.IsRecording() ) { ConMsg("Recording to \"%s\", length %s.\n", replay->m_DemoRecorder.GetDemoFile()->m_szFileName, COM_FormatSeconds( host_state.interval_per_tick * replay->m_DemoRecorder.GetRecordingTick() ) ); } } CON_COMMAND( replay_record, "Starts Replay demo recording." ) { #if 0 AssertMsg( 0, "Use replay_autorecord 1!" ); #else if ( !replay || !replay->IsActive() ) { ConMsg("Replay not active.\n" ); return; } if ( replay->m_DemoRecorder.IsRecording() ) { ConMsg("Replay already recording to %s.\n", replay->m_DemoRecorder.GetDemoFile()->m_szFileName ); return; } replay->m_DemoRecorder.StartAutoRecording(); #endif } CON_COMMAND( replay_stoprecord, "Stops Replay demo recording." ) { if ( !replay || !replay->IsActive() ) { ConMsg("Replay not active.\n" ); return; } replay->m_DemoRecorder.StopRecording(); } #endif