Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f753e8ef
csgo-2018-source/engine/sv_packedentities.cpp

964 lines
34 KiB
C++
Raw Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "server_pch.h"
#include "client.h"
#include "sv_packedentities.h"
#include "bspfile.h"
#include "eiface.h"
#include "dt_send_eng.h"
#include "dt_common_eng.h"
#include "changeframelist.h"
#include "sv_main.h"
#include "hltvserver.h"
#if defined( REPLAY_ENABLED )
#include "replayserver.h"
#endif
#include "dt_instrumentation_server.h"
#include "LocalNetworkBackdoor.h"
#include "tier0/vprof.h"
#include "host.h"
#include "networkstringtableserver.h"
#include "networkstringtable.h"
#include "utlbuffer.h"
#include "dt.h"
#include "con_nprint.h"
#include "smooth_average.h"
#include "vengineserver_impl.h"
#include "vstdlib/jobthread.h"
#include "enginethreads.h"
#include "networkvar.h"
#include "serializedentity.h"
#ifdef DEDICATED
IClientEntityList *entitylist = NULL;
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar sv_validate_edict_change_infos( "sv_validate_edict_change_infos", "0", FCVAR_RELEASE, "Verify that edict changeinfos are being calculated properly (used to debug local network backdoor mode)." );
ConVar sv_enable_delta_packing( "sv_enable_delta_packing", "0", FCVAR_RELEASE, "When enabled, this allows for entity packing to use the property changes for building up the data. This is many times faster, but can be disabled for error checking." );
ConVar sv_debugmanualmode( "sv_debugmanualmode", "0", FCVAR_RELEASE, "Make sure entities correctly report whether or not their network data has changed." );
static struct SPackedEntityStats
{
uint32 m_numFastPathEncodes;
uint32 m_numSlowPathEncodes;
} g_PackedEntityStats;
// Returns false and calls Host_Error if the edict's pvPrivateData is NULL.
static inline bool SV_EnsurePrivateData(edict_t *pEdict)
{
if(pEdict->GetUnknown())
{
return true;
}
else
{
Host_Error("SV_EnsurePrivateData: pEdict->pvPrivateData==NULL (ent %d).\n", pEdict - sv.edicts);
return false;
}
}
// This function makes sure that this entity class has an instance baseline.
// If it doesn't have one yet, it makes a new one.
void SV_EnsureInstanceBaseline( ServerClass *pServerClass, int iEdict, SerializedEntityHandle_t handle )
{
edict_t *pEnt = &sv.edicts[iEdict];
ErrorIfNot( pEnt->GetNetworkable(),
("SV_EnsureInstanceBaseline: edict %d missing ent", iEdict)
);
ServerClass *pClass = pEnt->GetNetworkable()->GetServerClass();
// See if we already have a baseline for this class.
if ( pClass->m_InstanceBaselineIndex == INVALID_STRING_INDEX )
{
AUTO_LOCK_FM( g_svInstanceBaselineMutex );
// We need this second check in case multiple instances of the same class have grabbed the lock.
if ( pClass->m_InstanceBaselineIndex == INVALID_STRING_INDEX )
{
char packedData[ MAX_PACKEDENTITY_DATA ];
bf_write buf( "SV_EnsureInstanceBaseline", packedData, sizeof( packedData ) );
// Write all fields (NULL) change list
SendTable_WritePropList( pServerClass->m_pTable, handle, &buf, iEdict, NULL );
char idString[32];
Q_snprintf( idString, sizeof( idString ), "%d", pClass->m_ClassID );
// Ok, make a new instance baseline so they can reference it.
int temp = sv.GetInstanceBaselineTable()->AddString(
true, idString, // Note we're sending a string with the ID number, not the class name.
buf.GetNumBytesWritten(), packedData );
Assert( temp != INVALID_STRING_INDEX );
// Copy the baseline data into the handles table
sv.m_BaselineHandles.Insert( temp, g_pSerializedEntities->CopySerializedEntity( handle, __FILE__, __LINE__ ) );
// Insert a compiler and/or CPU memory barrier to ensure that all side-effects have
// been published before the index is published. Otherwise the string index may
// be visible before its initialization has finished. This potential problem is caused
// by the use of double-checked locking -- the problem is that the code outside of the
// lock is looking at the variable that is protected by the lock. See this article for details:
// http://en.wikipedia.org/wiki/Double-checked_locking
// Write-release barrier
ThreadMemoryBarrier();
pClass->m_InstanceBaselineIndex = temp;
}
}
// Read-acquire barrier. This should be safe to omit because of dependencies
// which enforce read ordering.
//ThreadMemoryBarrier();
}
static inline bool DoesEdictChangeInfoContainPropIndex( SendTable *pSendTable, const CEdictChangeInfo *pCI, int nProp )
{
CSendTablePrecalc *pPrecalc = pSendTable->m_pPrecalc;
bool bFound = false;
for ( int i=0; i < pCI->m_nChangeOffsets && !bFound; i++ )
{
unsigned short index = pPrecalc->m_PropOffsetToIndexMap.Find( pCI->m_ChangeOffsets[i] );
if ( index == pPrecalc->m_PropOffsetToIndexMap.InvalidIndex() )
continue;
const PropIndicesCollection_t &coll = pPrecalc->m_PropOffsetToIndexMap[index];
for ( int nIndex=0; nIndex < ARRAYSIZE( coll.m_Indices ); nIndex++ )
{
if ( coll.m_Indices[nIndex] == nProp )
{
bFound = true;
break;
}
}
}
return bFound;
}
//given a previous frame and a change list of the delta properties, this will return a change list (either by taking it from the last frame if possible, or creating
//a copy) with the specified delta properties with an updated tick count
static inline CChangeFrameList * GetMergedChangeFrameList( PackedEntity* pPrevFrame, uint32 nNumProps, const CalcDeltaResultsList_t& ChangeList, uint32 nTick )
{
//if we have a previous frame, we need to try and reuse it's change list, either as a copy or a baseline
CChangeFrameList *pChangeFrame = NULL;
if( pPrevFrame )
{
CActiveHltvServerIterator hltv;
#ifndef _XBOX
#if defined( REPLAY_ENABLED )
if ( hltv || (replay && replay->IsActive()) )
#else
if ( hltv )
#endif
{
// in HLTV or Replay mode every PackedEntity keeps it's own ChangeFrameList
// we just copy the ChangeFrameList from prev frame and update it
pChangeFrame = pPrevFrame->GetChangeFrameList()->Copy();
}
else
#endif
{
// Ok, now snag the changeframe from the previous frame and update the 'last frame changed'
// for the properties in the delta.
pChangeFrame = pPrevFrame->SnagChangeFrameList();
}
ErrorIfNot( pChangeFrame, ("SV_PackEntity: SnagChangeFrameList returned null") );
ErrorIfNot( pChangeFrame->GetNumProps() == nNumProps,
("SV_PackEntity: SnagChangeFrameList mismatched number of props[%d vs %d]", nNumProps, pChangeFrame->GetNumProps() ) );
pChangeFrame->SetChangeTick( ChangeList.Base(), ChangeList.Count(), nTick );
}
else
{
pChangeFrame = new CChangeFrameList( nNumProps, nTick );
}
return pChangeFrame;
}
static void ValidateIncrementalChanges( ServerClass* pServerClass, const CalcDeltaResultsList_t& incremental, edict_t* edict, int edictIdx, SerializedEntityHandle_t tPrevProps )
{
const SendTable *pSendTable = pServerClass->m_pTable;
unsigned char tempData[ sizeof( CSendProxyRecipients ) * MAX_DATATABLE_PROXIES ];
CUtlMemory< CSendProxyRecipients > recip( (CSendProxyRecipients*)tempData, pSendTable->m_pPrecalc->GetNumDataTableProxies() );
//debug path, useful for detecting properties that differ from the binary diff and the change list
SerializedEntityHandle_t comparePackedProps = g_pSerializedEntities->AllocateSerializedEntity(__FILE__, __LINE__);
CalcDeltaResultsList_t compareDeltaProps;
//generate a change list using the normal route
SendTable_Encode( pSendTable, comparePackedProps, edict->GetUnknown(), edictIdx, &recip );
SendTable_CalcDelta( pSendTable, tPrevProps, comparePackedProps, edictIdx, compareDeltaProps );
//check to see if we have any missing properties or differing properties
for( uint32 nCurrIncremental = 0; nCurrIncremental < incremental.Count(); ++nCurrIncremental )
{
int nPropIndex = incremental[ nCurrIncremental ];
if( compareDeltaProps.Find( nPropIndex ) == -1 )
{
//missing a prop from our diff
const SendProp* pProp = pSendTable->m_pPrecalc->GetProp( nPropIndex );
Msg( "SV_PackEntity: Encountered property %s:%s for class %s (idx:%d) in incremental change that was not in the diff change. This can lead to slight network inefficiency (Index: %d, Array: %s)\n",
pSendTable->GetName(), pProp->GetName(), pServerClass->GetName(), edictIdx, nPropIndex, (pProp->m_pParentArrayPropName ? pProp->m_pParentArrayPropName : "N/A") );
}
}
for( uint32 nCurrDiff = 0; nCurrDiff < compareDeltaProps.Count(); ++nCurrDiff )
{
int nPropIndex = compareDeltaProps[ nCurrDiff ];
if( incremental.Find( nPropIndex ) == -1 )
{
//missing a prop from our incremental
const SendProp* pProp = pSendTable->m_pPrecalc->GetProp( nPropIndex );
//some properties are encoded against the tick count, of which can change with out the property changing. However, the value on the receiving end stays constants, so we need to
//be able to filter these out
if( pProp->GetFlags() & SPROP_ENCODED_AGAINST_TICKCOUNT )
continue;
Msg( "SV_PackEntity: Encountered property %s:%s for class %s (idx:%d) in diff change that was not in the incremental change. This can lead to values not making it down to the client (Index: %d, Array: %s)\n",
pSendTable->GetName(), pProp->GetName(), pServerClass->GetName(), edictIdx, nPropIndex, (pProp->m_pParentArrayPropName ? pProp->m_pParentArrayPropName : "N/A") );
}
}
g_pSerializedEntities->ReleaseSerializedEntity( comparePackedProps );
}
//-----------------------------------------------------------------------------
// Pack the entity....
//-----------------------------------------------------------------------------
static inline void SV_PackEntity(
int edictIdx,
edict_t* edict,
ServerClass* pServerClass,
CFrameSnapshot *pSnapshot )
{
Assert( edictIdx < pSnapshot->m_nNumEntities );
MEM_ALLOC_CREDIT();
const int iSerialNum = pSnapshot->m_pEntities[ edictIdx ].m_nSerialNumber;
//if the entity has no state changes, we can just reuse the previously sent packet
if( !edict->HasStateChanged() )
{
// Now this may not work if we didn't previously send a packet;
// if not, then we gotta compute it
bool bUsedPrev = framesnapshotmanager->UsePreviouslySentPacket( pSnapshot, edictIdx, iSerialNum );
if ( bUsedPrev && !sv_debugmanualmode.GetInt() )
{
edict->ClearStateChanged();
return;
}
}
//try and get our last frame
PackedEntity *pPrevFrame = framesnapshotmanager->GetPreviouslySentPacket( edictIdx, iSerialNum );
const SendTable *pSendTable = pServerClass->m_pTable;
//memory to hold onto our recipient list on the stack to avoid allocator overhead.
unsigned char tempData[ sizeof( CSendProxyRecipients ) * MAX_DATATABLE_PROXIES ];
CUtlMemory< CSendProxyRecipients > recip( (CSendProxyRecipients*)tempData, pSendTable->m_pPrecalc->GetNumDataTableProxies() );
//the new packed up properties and the delta list from the last frame we will be building
SerializedEntityHandle_t newPackedProps = SERIALIZED_ENTITY_HANDLE_INVALID;
CalcDeltaResultsList_t deltaProps;
//--------------------------------------
// Fast path - Partial updating (catches about 95% of entities)
//--------------------------------------
//see if we can take the fast path (requires a previous frame)
bool bCanFastPath = ( pPrevFrame && ( pPrevFrame->GetPackedData() != SERIALIZED_ENTITY_HANDLE_INVALID ) );
//also, we can't fast path if the entire object has changed
bCanFastPath &= !( edict->m_fStateFlags & FL_FULL_EDICT_CHANGED );
//and we need a valid change list set
bCanFastPath &= ( edict->GetChangeInfoSerialNumber() == g_pSharedChangeInfo->m_iSerialNumber );
//and allow for disabling this through the console
bCanFastPath &= ( sv_enable_delta_packing.GetBool() || sv_validate_edict_change_infos.GetBool() );
//see if we can do an incremental update from our last frame
if( bCanFastPath )
{
//see if we are in a situation where we are just doing diagnostics, meaning that we want to go through the work, but ultimately throw the results away after validating them
bool bDiscardResults = !( sv_enable_delta_packing.GetBool() );
//we can attempt a partial update
bool bCanReuseOldData;
newPackedProps = SendTable_BuildDeltaProperties( edict, edictIdx, pSendTable, pPrevFrame->GetPackedData(), deltaProps, &recip, bCanReuseOldData );
//see if we were unable to merge (which may have been a result of us being able to reuse the original data)
if( ( newPackedProps == SERIALIZED_ENTITY_HANDLE_INVALID ) )
{
//it wasn't able to overlay, so we need to fall back to the old way, unless it says nothing changed, at which point we can just reuse
if( bCanReuseOldData && pPrevFrame->CompareRecipients( recip ) )
{
if( framesnapshotmanager->UsePreviouslySentPacket( pSnapshot, edictIdx, iSerialNum ) )
{
//we are going to use the previous, but make sure that there is no delta that we are missing
if( sv_validate_edict_change_infos.GetBool() )
ValidateIncrementalChanges( pServerClass, deltaProps, edict, edictIdx, pPrevFrame->GetPackedData() );
//successfully used the last one
edict->ClearStateChanged();
return;
}
}
}
else
{
++g_PackedEntityStats.m_numFastPathEncodes;
if( sv_validate_edict_change_infos.GetBool() )
{
ValidateIncrementalChanges( pServerClass, deltaProps, edict, edictIdx, pPrevFrame->GetPackedData() );
//we need to throw away our data if this is just for diagnostics
if( bDiscardResults )
{
g_pSerializedEntities->ReleaseSerializedEntity( newPackedProps );
newPackedProps = SERIALIZED_ENTITY_HANDLE_INVALID;
}
}
}
}
//--------------------------------------
// Slow path - Must build a full data block and do a binary diff to spot the changes
//--------------------------------------
//if we made it through the fast path with no packed data, we need to pack it via the slow path
if( newPackedProps == SERIALIZED_ENTITY_HANDLE_INVALID )
{
++g_PackedEntityStats.m_numSlowPathEncodes;
//build all the properties for this object into a serialized entity data block
newPackedProps = g_pSerializedEntities->AllocateSerializedEntity(__FILE__, __LINE__);
if( !SendTable_Encode( pSendTable, newPackedProps, edict->GetUnknown(), edictIdx, &recip ) )
{
Host_Error( "SV_PackEntity: SendTable_Encode returned false (ent %d).\n", edictIdx );
}
// A "SetOnly", etc. for indicating the entity should be sent to player B who is a piggybacked split screen player sharing the network pipe for for player A, needs to be changed to go to player player A
SV_EnsureInstanceBaseline( pServerClass, edictIdx, newPackedProps );
// If this entity was previously in there, then it should have a valid CChangeFrameList
// which we can delta against to figure out which properties have changed.
if( pPrevFrame )
{
//do a binary diff and see which properties changed that way
SendTable_CalcDelta( pSendTable, pPrevFrame->GetPackedData(), newPackedProps, edictIdx, deltaProps );
// If it's non-manual-mode, but we detect that there are no changes here, then just
// use the previous pSnapshot if it's available (as though the entity were manual mode).
if ( ( deltaProps.Count() == 0 ) && pPrevFrame->CompareRecipients( recip ) )
{
if ( framesnapshotmanager->UsePreviouslySentPacket( pSnapshot, edictIdx, iSerialNum ) )
{
edict->ClearStateChanged();
g_pSerializedEntities->ReleaseSerializedEntity( newPackedProps );
return;
}
}
}
}
// Now make a PackedEntity and store the new packed data in there.
{
//get our change frame list for our new property set
int nFlatProps = SendTable_GetNumFlatProps( pSendTable );
CChangeFrameList* pChangeFrame = GetMergedChangeFrameList( pPrevFrame, nFlatProps, deltaProps, pSnapshot->m_nTickCount );
//and setup our packed entity to hold all of our data
PackedEntity *pPackedEntity = framesnapshotmanager->CreatePackedEntity( pSnapshot, edictIdx );
pPackedEntity->SetChangeFrameList( pChangeFrame );
pPackedEntity->SetServerAndClientClass( pServerClass, NULL );
pPackedEntity->SetPackedData( newPackedProps );
pPackedEntity->SetRecipients( recip );
}
edict->ClearStateChanged();
}
CON_COMMAND( sv_dump_entity_pack_stats, "Show stats on entity packing." )
{
Msg("Entity Packing stats:\n");
Msg(" numFastPathEncodes=%u\n", g_PackedEntityStats.m_numFastPathEncodes );
Msg(" numSlowPathEncodes=%u\n", g_PackedEntityStats.m_numSlowPathEncodes );
}
// in HLTV mode we ALWAYS have to store position and PVS info, even if entity didnt change
void SV_FillHLTVData( CFrameSnapshot *pSnapshot, edict_t *edict, int iValidEdict )
{
if ( pSnapshot->m_pHLTVEntityData && edict )
{
CHLTVEntityData *pHLTVData = &pSnapshot->m_pHLTVEntityData[iValidEdict];
PVSInfo_t *pvsInfo = edict->GetNetworkable()->GetPVSInfo();
if ( pvsInfo->m_nClusterCount == 1 )
{
// store cluster, if entity spawns only over one cluster
pHLTVData->m_nNodeCluster = pvsInfo->m_pClusters[0];
}
else
{
// otherwise save PVS head node for larger entities
pHLTVData->m_nNodeCluster = pvsInfo->m_nHeadNode | (1<<31);
}
// remember origin
pHLTVData->origin[0] = pvsInfo->m_vCenter[0];
pHLTVData->origin[1] = pvsInfo->m_vCenter[1];
pHLTVData->origin[2] = pvsInfo->m_vCenter[2];
}
}
#if defined( REPLAY_ENABLED )
// in Replay mode we ALWAYS have to store position and PVS info, even if entity didnt change
void SV_FillReplayData( CFrameSnapshot *pSnapshot, edict_t *edict, int iValidEdict )
{
if ( pSnapshot->m_pReplayEntityData && edict )
{
CReplayEntityData *pReplayData = &pSnapshot->m_pReplayEntityData[iValidEdict];
PVSInfo_t *pvsInfo = edict->GetNetworkable()->GetPVSInfo();
if ( pvsInfo->m_nClusterCount == 1 )
{
// store cluster, if entity spawns only over one cluster
pReplayData->m_nNodeCluster = pvsInfo->m_pClusters[0];
}
else
{
// otherwise save PVS head node for larger entities
pReplayData->m_nNodeCluster = pvsInfo->m_nHeadNode | (1<<31);
}
// remember origin
pReplayData->origin[0] = pvsInfo->m_vCenter[0];
pReplayData->origin[1] = pvsInfo->m_vCenter[1];
pReplayData->origin[2] = pvsInfo->m_vCenter[2];
}
}
#endif
// Returns the SendTable that should be used with the specified edict.
SendTable* GetEntSendTable(edict_t *pEdict)
{
if ( pEdict->GetNetworkable() )
{
ServerClass *pClass = pEdict->GetNetworkable()->GetServerClass();
if ( pClass )
{
return pClass->m_pTable;
}
}
return NULL;
}
void PackEntities_NetworkBackDoor(
int clientCount,
CGameClient **clients,
CFrameSnapshot *snapshot )
{
Assert( clientCount == 1 );
CGameClient *client = clients[0]; // update variables cl, pInfo, frame for current client
CCheckTransmitInfo *pInfo = &client->m_PackInfo;
//Msg ( " Using local network back door" );
for ( int iValidEdict=0; iValidEdict < snapshot->m_nValidEntities; iValidEdict++ )
{
int index = snapshot->m_pValidEntities[iValidEdict];
edict_t* edict = &sv.edicts[ index ];
// this is a bit of a hack to ensure that we get a "preview" of the
// packet timstamp that the server will send so that things that
// are encoded relative to packet time will be correct
Assert( edict->m_NetworkSerialNumber != -1 );
bool bShouldTransmit = pInfo->m_pTransmitEdict->Get( index ) ? true : false;
//CServerDTITimer timer( pSendTable, SERVERDTI_ENCODE );
// If we're using the fast path for a single-player game, just pass the entity
// directly over to the client.
Assert( index < snapshot->m_nNumEntities );
ServerClass *pSVClass = snapshot->m_pEntities[ index ].m_pClass;
g_pLocalNetworkBackdoor->EntState( index, edict->m_NetworkSerialNumber,
pSVClass->m_ClassID, pSVClass->m_pTable, edict->GetUnknown(), edict->HasStateChanged(), bShouldTransmit );
edict->ClearStateChanged();
}
// Tell the client about any entities that are now dormant.
g_pLocalNetworkBackdoor->ProcessDormantEntities();
InvalidateSharedEdictChangeInfos();
}
static ConVar sv_parallel_packentities( "sv_parallel_packentities",
#ifndef DEDICATED
"1",
#else //DEDICATED
"1",
#endif //DEDICATED
FCVAR_RELEASE );
struct PackWork_t
{
int nIdx;
edict_t *pEdict;
CFrameSnapshot *pSnapshot;
static void Process( PackWork_t &item )
{
SV_PackEntity( item.nIdx, item.pEdict, item.pSnapshot->m_pEntities[ item.nIdx ].m_pClass, item.pSnapshot );
}
};
void PackEntities_Normal(
int clientCount,
CGameClient **clients,
CFrameSnapshot *snapshot )
{
SNPROF("PackEntities_Normal");
Assert( snapshot->m_nValidEntities <= MAX_EDICTS );
PackWork_t workItems[MAX_EDICTS];
int workItemCount = 0;
// check for all active entities, if they are seen by at least on client, if
// so, bit pack them
for ( int iValidEdict=0; iValidEdict < snapshot->m_nValidEntities; ++iValidEdict )
{
int index = snapshot->m_pValidEntities[ iValidEdict ];
Assert( index < snapshot->m_nNumEntities );
edict_t* edict = &sv.edicts[ index ];
// if HLTV is running save PVS info for each entity
SV_FillHLTVData( snapshot, edict, iValidEdict );
#if defined( REPLAY_ENABLED )
// if Replay is running save PVS info for each entity
SV_FillReplayData( snapshot, edict, iValidEdict );
#endif
// Check to see if the entity changed this frame...
//ServerDTI_RegisterNetworkStateChange( pSendTable, ent->m_bStateChanged );
for ( int iClient = 0; iClient < clientCount; ++iClient )
{
// entities is seen by at least this client, pack it and exit loop
CGameClient *client = clients[iClient]; // update variables cl, pInfo, frame for current client
if ( client->IsHltvReplay() )
continue; // clients in HLTV replay use HLTV stream that has already been pre-packed for them by HLTV master client. No need to do any packing while streaming HLTV contents
CClientFrame *frame = client->m_pCurrentFrame;
if( frame->transmit_entity.Get( index ) )
{
workItems[workItemCount].nIdx = index;
workItems[workItemCount].pEdict = edict;
workItems[workItemCount].pSnapshot = snapshot;
workItemCount++;
break;
}
}
}
// Process work
if ( sv_parallel_packentities.GetBool() )
{
ParallelProcess( workItems, workItemCount, &PackWork_t::Process );
}
else
{
int c = workItemCount;
for ( int i = 0; i < c; ++i )
{
PackWork_t &w = workItems[ i ];
SV_PackEntity( w.nIdx, w.pEdict, w.pSnapshot->m_pEntities[ w.nIdx ].m_pClass, w.pSnapshot );
}
}
InvalidateSharedEdictChangeInfos();
}
//-----------------------------------------------------------------------------
// Writes the compressed packet of entities to all clients
//-----------------------------------------------------------------------------
void SV_ComputeClientPacks(
int clientCount,
CGameClient **clients,
CFrameSnapshot *snapshot )
{
SNPROF( "SV_ComputeClientPacks" );
MDLCACHE_CRITICAL_SECTION_(g_pMDLCache);
// Do some setup for each client
{
for (int iClient = 0; iClient < clientCount; ++iClient)
{
TM_ZONE( TELEMETRY_LEVEL1, TMZF_NONE, "CheckTransmit:%d", iClient );
if ( clients[ iClient ]->IsHltvReplay() )
{
clients[ iClient ]->SetupHltvFrame( snapshot->m_nTickCount);
continue; // skip all the transmit checks if we already have packs prepared by HLTV that we'll be sending anyway
}
CCheckTransmitInfo *pInfo = &clients[iClient]->m_PackInfo;
clients[iClient]->SetupPackInfo( snapshot );
if ( clients[iClient]->m_nDeltaTick < 0 )
{
serverGameEnts->PrepareForFullUpdate( clients[iClient]->edict );
}
serverGameEnts->CheckTransmit( pInfo, snapshot->m_pValidEntities, snapshot->m_nValidEntities );
clients[iClient]->SetupPrevPackInfo();
}
}
if ( g_pLocalNetworkBackdoor )
{
#if !defined( DEDICATED )
if ( GetBaseLocalClient().m_pServerClasses == NULL )
{
// Edge case - the local client has been cleaned up but we have a deferred tick to execute.
// As far as I know, this can only happen if the player quits the game with a synchronous cbuf_execute while a server tick is in flight.
// (e.g. user pauses the game, files a bug with vxconsole, then vxconsole unpauses the game while the user is still in the menu, then the user quits -> CRASH)
Warning( "Attempting to pack entities on server with invalid local client state. Probably a result of VXConsole or con commands. Aborting SV_ComputeClientPacks.\n" );
return;
}
#endif
// This will force network string table updates for local client to go through the backdoor if it's active
#ifdef SHARED_NET_STRING_TABLES
sv.m_StringTables->TriggerCallbacks( clients[0]->m_nDeltaTick );
#else
sv.m_StringTables->DirectUpdate( clients[0]->GetMaxAckTickCount() );
#endif
g_pLocalNetworkBackdoor->StartEntityStateUpdate();
#ifndef DEDICATED
int saveClientTicks = GetBaseLocalClient().GetClientTickCount();
int saveServerTicks = GetBaseLocalClient().GetServerTickCount();
bool bSaveSimulation = GetBaseLocalClient().insimulation;
float flSaveLastServerTickTime = GetBaseLocalClient().m_flLastServerTickTime;
GetBaseLocalClient().insimulation = true;
GetBaseLocalClient().SetClientTickCount( sv.m_nTickCount );
GetBaseLocalClient().SetServerTickCount( sv.m_nTickCount );
GetBaseLocalClient().m_flLastServerTickTime = sv.m_nTickCount * host_state.interval_per_tick;
g_ClientGlobalVariables.tickcount = GetBaseLocalClient().GetClientTickCount();
g_ClientGlobalVariables.curtime = GetBaseLocalClient().GetTime();
#endif
PackEntities_NetworkBackDoor( clientCount, clients, snapshot );
g_pLocalNetworkBackdoor->EndEntityStateUpdate();
#ifndef DEDICATED
GetBaseLocalClient().SetClientTickCount( saveClientTicks );
GetBaseLocalClient().SetServerTickCount( saveServerTicks );
GetBaseLocalClient().insimulation = bSaveSimulation;
GetBaseLocalClient().m_flLastServerTickTime = flSaveLastServerTickTime;
g_ClientGlobalVariables.tickcount = GetBaseLocalClient().GetClientTickCount();
g_ClientGlobalVariables.curtime = GetBaseLocalClient().GetTime();
#endif
PrintPartialChangeEntsList();
}
else
{
PackEntities_Normal( clientCount, clients, snapshot );
}
}
// If the table's ID is -1, writes its info into the buffer and increments curID.
void SV_MaybeWriteSendTable( SendTable *pTable, bf_write &pBuf, bool bNeedDecoder )
{
// Already sent?
if ( pTable->GetWriteFlag() )
return;
pTable->SetWriteFlag( true );
// write send table properties into stream
if ( !SendTable_WriteInfos(pTable, pBuf, bNeedDecoder, false ) )
{
Host_Error( "Send Table buffer for class '%s' overflowed!!!\n", pTable->GetName() );
}
}
// Calls SV_MaybeWriteSendTable recursively.
void SV_MaybeWriteSendTable_R( SendTable *pTable, bf_write &pBuf )
{
SV_MaybeWriteSendTable( pTable, pBuf, false );
// Make sure we send child send tables..
for(int i=0; i < pTable->m_nProps; i++)
{
SendProp *pProp = &pTable->m_pProps[i];
if( pProp->m_Type == DPT_DataTable )
SV_MaybeWriteSendTable_R( pProp->GetDataTable(), pBuf );
}
}
// Sets up SendTable IDs and sends an svc_sendtable for each table.
void SV_WriteSendTables( ServerClass *pClasses, bf_write &pBuf )
{
ServerClass *pCur;
DataTable_ClearWriteFlags( pClasses );
// First, we send all the leaf classes. These are the ones that will need decoders
// on the client.
for ( pCur=pClasses; pCur; pCur=pCur->m_pNext )
{
SV_MaybeWriteSendTable( pCur->m_pTable, pBuf, true );
}
// Now, we send their base classes. These don't need decoders on the client
// because we will never send these SendTables by themselves.
for ( pCur=pClasses; pCur; pCur=pCur->m_pNext )
{
SV_MaybeWriteSendTable_R( pCur->m_pTable, pBuf );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : crc -
//-----------------------------------------------------------------------------
void SV_ComputeClassInfosCRC( CRC32_t* crc )
{
ServerClass *pClasses = serverGameDLL->GetAllServerClasses();
for ( ServerClass *pClass=pClasses; pClass; pClass=pClass->m_pNext )
{
CRC32_ProcessBuffer( crc, (void *)pClass->m_pNetworkName, Q_strlen( pClass->m_pNetworkName ) );
CRC32_ProcessBuffer( crc, (void *)pClass->m_pTable->GetName(), Q_strlen(pClass->m_pTable->GetName() ) );
}
}
void CGameServer::AssignClassIds()
{
ServerClass *pClasses = serverGameDLL->GetAllServerClasses();
// Count the number of classes.
int nClasses = 0;
for ( ServerClass *pCount=pClasses; pCount; pCount=pCount->m_pNext )
{
++nClasses;
}
// These should be the same! If they're not, then it should detect an explicit create message.
ErrorIfNot( nClasses <= MAX_SERVER_CLASSES,
("CGameServer::AssignClassIds: too many server classes (%i, MAX = %i).\n", nClasses, MAX_SERVER_CLASSES );
);
serverclasses = nClasses;
serverclassbits = Q_log2( serverclasses ) + 1;
bool bSpew = CommandLine()->FindParm( "-netspike" ) ? true : false;
int curID = 0;
for ( ServerClass *pClass=pClasses; pClass; pClass=pClass->m_pNext )
{
pClass->m_ClassID = curID++;
if ( bSpew )
{
Msg( "%d == '%s'\n", pClass->m_ClassID, pClass->GetName() );
}
}
}
// Assign each class and ID and write an svc_classinfo for each one.
void SV_WriteClassInfos(ServerClass *pClasses, bf_write &pBuf)
{
// Assert( sv.serverclasses < MAX_SERVER_CLASSES );
CSVCMsg_ClassInfo_t classinfomsg;
classinfomsg.set_create_on_client( false );
for ( ServerClass *pClass=pClasses; pClass; pClass=pClass->m_pNext )
{
CSVCMsg_ClassInfo::class_t *svclass = classinfomsg.add_classes();
svclass->set_class_id( pClass->m_ClassID );
svclass->set_data_table_name( pClass->m_pTable->GetName() );
svclass->set_class_name( pClass->m_pNetworkName );
}
classinfomsg.WriteToBuffer( pBuf );
}
// This is implemented for the datatable code so its warnings can include an object's classname.
const char* GetObjectClassName( int objectID )
{
if ( objectID >= 0 && objectID < sv.num_edicts )
{
return sv.edicts[objectID].GetClassName();
}
else
{
return "[unknown]";
}
}
//-----------------------------------------------------------------------------
CON_COMMAND( sv_dump_class_info, "Dump server class infos." )
{
ServerClass *pClasses = serverGameDLL->GetAllServerClasses();
Msg( "ServerClassInfo:\n");
Msg( "\tNetName(TableName):nProps PreCalcProps\n");
for ( ServerClass *pCount=pClasses; pCount; pCount=pCount->m_pNext )
{
Msg("\t%s(%s):%d %d\n", pCount->GetName(), pCount->m_pTable->GetName(), pCount->m_pTable->m_nProps, pCount->m_pTable->m_pPrecalc ? pCount->m_pTable->m_pPrecalc->GetNumProps() : 0 );
}
}
//-----------------------------------------------------------------------------
#include "tier1/tokenset.h"
const tokenset_t< SendPropType > gSendPropTypeTokenSet[] =
{
{ "Int", DPT_Int },
{ "Float", DPT_Float },
{ "Vector", DPT_Vector },
{ "VectorXY", DPT_VectorXY }, // Only encodes the XY of a vector, ignores Z
{ "String", DPT_String },
{ "Array", DPT_Array }, // An array of the base types (can't be of datatables).
{ "DataTable", DPT_DataTable },
#if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!!
{ "Quaternion,DPT_Quaternion },
#endif
{ "Int64", DPT_Int64 },
{ NULL, (SendPropType)0 }
};
//-----------------------------------------------------------------------------
static void PrintSendProp( int index, const SendProp *pSendProp )
{
CUtlString flags;
if ( pSendProp->GetFlags() & SPROP_VARINT ) { flags += "|VARINT"; }
if ( pSendProp->GetFlags() & SPROP_UNSIGNED ) { flags += "|UNSIGNED"; }
if ( pSendProp->GetFlags() & SPROP_COORD ) { flags += "|COORD"; }
if ( pSendProp->GetFlags() & SPROP_NOSCALE ) { flags += "|NOSCALE"; }
if ( pSendProp->GetFlags() & SPROP_ROUNDDOWN ) { flags += "|ROUNDDOWN"; }
if ( pSendProp->GetFlags() & SPROP_ROUNDUP ) { flags += "|ROUNDUP"; }
if ( pSendProp->GetFlags() & SPROP_NORMAL ) { flags += "|NORMAL"; }
if ( pSendProp->GetFlags() & SPROP_EXCLUDE ) { flags += "|EXCLUDE"; }
if ( pSendProp->GetFlags() & SPROP_XYZE ) { flags += "|XYZE"; }
if ( pSendProp->GetFlags() & SPROP_INSIDEARRAY ) { flags += "|INSIDEARRAY"; }
if ( pSendProp->GetFlags() & SPROP_PROXY_ALWAYS_YES ) { flags += "|PROXY_ALWAYS_YES"; }
if ( pSendProp->GetFlags() & SPROP_IS_A_VECTOR_ELEM ) { flags += "|IS_A_VECTOR_ELEM"; }
if ( pSendProp->GetFlags() & SPROP_COLLAPSIBLE ) { flags += "|COLLAPSIBLE"; }
if ( pSendProp->GetFlags() & SPROP_COORD_MP ) { flags += "|COORD_MP"; }
if ( pSendProp->GetFlags() & SPROP_COORD_MP_LOWPRECISION ) { flags += "|COORD_MP_LOWPRECISION"; }
if ( pSendProp->GetFlags() & SPROP_COORD_MP_INTEGRAL ) { flags += "|COORD_MP_INTEGRAL"; }
if ( pSendProp->GetFlags() & SPROP_CELL_COORD ) { flags += "|CELL_COORD"; }
if ( pSendProp->GetFlags() & SPROP_CELL_COORD_LOWPRECISION ) { flags += "|CELL_COORD_LOWPRECISION"; }
if ( pSendProp->GetFlags() & SPROP_CELL_COORD_INTEGRAL ) { flags += "|CELL_COORD_INTEGRAL"; }
if ( pSendProp->GetFlags() & SPROP_CHANGES_OFTEN ) { flags += "|CHANGES_OFTEN"; }
if ( pSendProp->GetFlags() & SPROP_ENCODED_AGAINST_TICKCOUNT ) { flags += "|ENCODED_AGAINST_TICKCOUNT"; }
const char *pFlags = flags.Get();
if ( !flags.IsEmpty() && *flags.Get() == '|' )
{
pFlags = flags.Get() + 1;
}
CUtlString name;
if ( pSendProp->GetParentArrayPropName() )
{
name.Format( "%s:%s", pSendProp->GetParentArrayPropName(), pSendProp->GetName() );
}
else
{
name = pSendProp->GetName();
}
Msg( "\t%d,%s,%d,%d,%s,%s,%d\n",
index,
name.String(),
pSendProp->GetOffset(),
pSendProp->m_nBits,
gSendPropTypeTokenSet->GetNameByToken( pSendProp->GetType() ),
pFlags,
pSendProp->GetPriority()
);
}
//-----------------------------------------------------------------------------
CON_COMMAND( sv_dump_class_table, "Dump server class table matching the pattern (substr)." )
{
if ( args.ArgC() < 2 )
{
Msg( "Provide a substr to match class info against.\n" );
return;
}
ServerClass *pClasses = serverGameDLL->GetAllServerClasses();
for ( int a = 1; a < args.ArgC(); ++a )
{
for ( ServerClass *pCount=pClasses; pCount; pCount=pCount->m_pNext )
{
if ( pCount->m_pTable->m_pPrecalc && Q_stristr( pCount->GetName(), args[a] ) != NULL )
{
Msg( "%s:\n", pCount->GetName() );
Msg( "\tIndex,Name,Offset,Bits,Type,Flags,Priority\n" );
const CSendTablePrecalc *pPrecalc = pCount->m_pTable->m_pPrecalc;
for ( int i = 0; i < pPrecalc->GetNumProps(); ++i )
{
const SendProp *pSendProp = pPrecalc->GetProp( i );
PrintSendProp( i, pSendProp );
}
}
}
}
}
Reference in New Issue Copy Permalink