You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
755 lines
22 KiB
755 lines
22 KiB
5 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
// Purpose: Parsing of entity network packets.
|
||
|
|
//
|
||
|
|
// $NoKeywords: $
|
||
|
|
//=============================================================================//
|
||
|
|
|
||
|
|
|
||
|
|
#include "client_pch.h"
|
||
|
|
#include "con_nprint.h"
|
||
|
|
#include "iprediction.h"
|
||
|
|
#include "cl_entityreport.h"
|
||
|
|
#include "dt_recv_eng.h"
|
||
|
|
#include "net_synctags.h"
|
||
|
|
#include "ispatialpartitioninternal.h"
|
||
|
|
#include "LocalNetworkBackdoor.h"
|
||
|
|
#include "basehandle.h"
|
||
|
|
#include "dt_localtransfer.h"
|
||
|
|
#include "iprediction.h"
|
||
|
|
#include "netmessages.h"
|
||
|
|
#include "ents_shared.h"
|
||
|
|
#include "cl_ents_parse.h"
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include "tier0/memdbgon.h"
|
||
|
|
|
||
|
|
static ConVar cl_flushentitypacket("cl_flushentitypacket", "0", FCVAR_CHEAT, "For debugging. Force the engine to flush an entity packet.");
|
||
|
|
|
||
|
|
// Prints important entity creation/deletion events to console
|
||
|
|
#if defined( _DEBUG )
|
||
|
|
static ConVar cl_deltatrace( "cl_deltatrace", "0", 0, "For debugging, print entity creation/deletion info to console." );
|
||
|
|
#define TRACE_DELTA( text ) if ( cl_deltatrace.GetInt() ) { ConMsg( "%s", text ); };
|
||
|
|
#else
|
||
|
|
#define TRACE_DELTA( funcs )
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Debug networking stuff.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
|
||
|
|
// #define DEBUG_NETWORKING 1
|
||
|
|
|
||
|
|
#if defined( DEBUG_NETWORKING )
|
||
|
|
void SpewToFile( char const* pFmt, ... );
|
||
|
|
static ConVar cl_packettrace( "cl_packettrace", "1", 0, "For debugging, massive spew to file." );
|
||
|
|
#define TRACE_PACKET( text ) if ( cl_packettrace.GetInt() ) { SpewToFile text ; };
|
||
|
|
#else
|
||
|
|
#define TRACE_PACKET( text )
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#if defined( DEBUG_NETWORKING )
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Opens the recording file
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
static FileHandle_t OpenRecordingFile()
|
||
|
|
{
|
||
|
|
FileHandle_t fp = 0;
|
||
|
|
static bool s_CantOpenFile = false;
|
||
|
|
static bool s_NeverOpened = true;
|
||
|
|
if (!s_CantOpenFile)
|
||
|
|
{
|
||
|
|
fp = g_pFileSystem->Open( "cltrace.txt", s_NeverOpened ? "wt" : "at" );
|
||
|
|
if (!fp)
|
||
|
|
{
|
||
|
|
s_CantOpenFile = true;
|
||
|
|
}
|
||
|
|
s_NeverOpened = false;
|
||
|
|
}
|
||
|
|
return fp;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Records an argument for a command, flushes when the command is done
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void SpewToFile( char const* pFmt, ... )
|
||
|
|
{
|
||
|
|
static CUtlVector<unsigned char> s_RecordingBuffer;
|
||
|
|
|
||
|
|
char temp[2048];
|
||
|
|
va_list args;
|
||
|
|
|
||
|
|
va_start( args, pFmt );
|
||
|
|
int len = Q_vsnprintf( temp, sizeof( temp ), pFmt, args );
|
||
|
|
va_end( args );
|
||
|
|
assert( len < 2048 );
|
||
|
|
|
||
|
|
int idx = s_RecordingBuffer.AddMultipleToTail( len );
|
||
|
|
memcpy( &s_RecordingBuffer[idx], temp, len );
|
||
|
|
if ( 1 ) //s_RecordingBuffer.Size() > 8192)
|
||
|
|
{
|
||
|
|
FileHandle_t fp = OpenRecordingFile();
|
||
|
|
g_pFileSystem->Write( s_RecordingBuffer.Base(), s_RecordingBuffer.Size(), fp );
|
||
|
|
g_pFileSystem->Close( fp );
|
||
|
|
|
||
|
|
s_RecordingBuffer.RemoveAll();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // DEBUG_NETWORKING
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Frees the client DLL's binding to the object.
|
||
|
|
// Input : iEnt -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CL_DeleteDLLEntity( int iEnt, const char *reason, bool bOnRecreatingAllEntities )
|
||
|
|
{
|
||
|
|
IClientNetworkable *pNet = entitylist->GetClientNetworkable( iEnt );
|
||
|
|
|
||
|
|
if ( pNet )
|
||
|
|
{
|
||
|
|
ClientClass *pClientClass = pNet->GetClientClass();
|
||
|
|
TRACE_DELTA( va( "Trace %i (%s): delete (%s)\n", iEnt, pClientClass ? pClientClass->m_pNetworkName : "unknown", reason ) );
|
||
|
|
#ifndef _XBOX
|
||
|
|
CL_RecordDeleteEntity( iEnt, pClientClass );
|
||
|
|
#endif
|
||
|
|
if ( bOnRecreatingAllEntities )
|
||
|
|
{
|
||
|
|
pNet->SetDestroyedOnRecreateEntities();
|
||
|
|
}
|
||
|
|
|
||
|
|
pNet->Release();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Has the client DLL allocate its data for the object.
|
||
|
|
// Input : iEnt -
|
||
|
|
// iClass -
|
||
|
|
// Output : Returns true on success, false on failure.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
IClientNetworkable* CL_CreateDLLEntity( int iEnt, int iClass, int iSerialNum )
|
||
|
|
{
|
||
|
|
#if defined( _DEBUG )
|
||
|
|
IClientNetworkable *pOldNetworkable = entitylist->GetClientNetworkable( iEnt );
|
||
|
|
Assert( !pOldNetworkable );
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ClientClass *pClientClass;
|
||
|
|
if ( ( pClientClass = cl.m_pServerClasses[iClass].m_pClientClass ) != NULL )
|
||
|
|
{
|
||
|
|
TRACE_DELTA( va( "Trace %i (%s): create\n", iEnt, pClientClass->m_pNetworkName ) );
|
||
|
|
#ifndef _XBOX
|
||
|
|
CL_RecordAddEntity( iEnt );
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if ( !cl.IsActive() )
|
||
|
|
{
|
||
|
|
COM_TimestampedLog( "cl: create '%s'", pClientClass->m_pNetworkName );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create the entity.
|
||
|
|
return pClientClass->m_pCreateFn( iEnt, iSerialNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert(false);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void SpewBitStream( unsigned char* pMem, int bit, int lastbit )
|
||
|
|
{
|
||
|
|
int val = 0;
|
||
|
|
char buf[1024];
|
||
|
|
char* pTemp = buf;
|
||
|
|
int bitcount = 0;
|
||
|
|
int charIdx = 1;
|
||
|
|
while( bit < lastbit )
|
||
|
|
{
|
||
|
|
int byte = bit >> 3;
|
||
|
|
int bytebit = bit & 0x7;
|
||
|
|
|
||
|
|
val |= ((pMem[byte] & bytebit) != 0) << bitcount;
|
||
|
|
|
||
|
|
++bit;
|
||
|
|
++bitcount;
|
||
|
|
|
||
|
|
if (bitcount == 4)
|
||
|
|
{
|
||
|
|
if ((val >= 0) && (val <= 9))
|
||
|
|
pTemp[charIdx] = '0' + val;
|
||
|
|
else
|
||
|
|
pTemp[charIdx] = 'A' + val - 0xA;
|
||
|
|
if (charIdx == 1)
|
||
|
|
charIdx = 0;
|
||
|
|
else
|
||
|
|
{
|
||
|
|
charIdx = 1;
|
||
|
|
pTemp += 2;
|
||
|
|
}
|
||
|
|
bitcount = 0;
|
||
|
|
val = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((bitcount != 0) || (charIdx != 0))
|
||
|
|
{
|
||
|
|
if (bitcount > 0)
|
||
|
|
{
|
||
|
|
if ((val >= 0) && (val <= 9))
|
||
|
|
pTemp[charIdx] = '0' + val;
|
||
|
|
else
|
||
|
|
pTemp[charIdx] = 'A' + val - 0xA;
|
||
|
|
}
|
||
|
|
if (charIdx == 1)
|
||
|
|
{
|
||
|
|
pTemp[0] = '0';
|
||
|
|
}
|
||
|
|
pTemp += 2;
|
||
|
|
}
|
||
|
|
pTemp[0] = '\0';
|
||
|
|
|
||
|
|
TRACE_PACKET(( " CL Bitstream %s\n", buf ));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
inline static void CL_AddPostDataUpdateCall( CEntityReadInfo &u, int iEnt, DataUpdateType_t updateType )
|
||
|
|
{
|
||
|
|
ErrorIfNot( u.m_nPostDataUpdateCalls < MAX_EDICTS,
|
||
|
|
("CL_AddPostDataUpdateCall: overflowed u.m_PostDataUpdateCalls") );
|
||
|
|
|
||
|
|
u.m_PostDataUpdateCalls[u.m_nPostDataUpdateCalls].m_iEnt = iEnt;
|
||
|
|
u.m_PostDataUpdateCalls[u.m_nPostDataUpdateCalls].m_UpdateType = updateType;
|
||
|
|
++u.m_nPostDataUpdateCalls;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Get the receive table for the specified entity
|
||
|
|
// Input : *pEnt -
|
||
|
|
// Output : RecvTable*
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static inline RecvTable* GetEntRecvTable( int entnum )
|
||
|
|
{
|
||
|
|
IClientNetworkable *pNet = entitylist->GetClientNetworkable( entnum );
|
||
|
|
if ( pNet )
|
||
|
|
return pNet->GetClientClass()->m_pRecvTable;
|
||
|
|
else
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Returns true if the entity index corresponds to a player slot
|
||
|
|
// Input : index -
|
||
|
|
// Output : bool
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static inline bool CL_IsPlayerIndex( int index )
|
||
|
|
{
|
||
|
|
return ( index >= 1 && index <= cl.m_nMaxClients );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Bad data was received, just flushes incoming delta data.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CL_FlushEntityPacket( CClientFrame *packet, char const *errorString, ... )
|
||
|
|
{
|
||
|
|
con_nprint_t np;
|
||
|
|
char str[2048];
|
||
|
|
va_list marker;
|
||
|
|
|
||
|
|
// Spit out an error.
|
||
|
|
va_start(marker, errorString);
|
||
|
|
Q_vsnprintf(str, sizeof(str), errorString, marker);
|
||
|
|
va_end(marker);
|
||
|
|
|
||
|
|
ConMsg("%s", str);
|
||
|
|
|
||
|
|
np.fixed_width_font = false;
|
||
|
|
np.time_to_live = 1.0;
|
||
|
|
np.index = 0;
|
||
|
|
np.color[ 0 ] = 1.0;
|
||
|
|
np.color[ 1 ] = 0.2;
|
||
|
|
np.color[ 2 ] = 0.0;
|
||
|
|
Con_NXPrintf( &np, "WARNING: CL_FlushEntityPacket, %s", str );
|
||
|
|
|
||
|
|
// Free packet memory.
|
||
|
|
delete packet;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ----------------------------------------------------------------------------- //
|
||
|
|
// Regular handles for ReadPacketEntities.
|
||
|
|
// ----------------------------------------------------------------------------- //
|
||
|
|
|
||
|
|
void CL_CopyNewEntity(
|
||
|
|
CEntityReadInfo &u,
|
||
|
|
int iClass,
|
||
|
|
int iSerialNum
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if ( u.m_nNewEntity < 0 || u.m_nNewEntity >= MAX_EDICTS )
|
||
|
|
{
|
||
|
|
Host_Error ("CL_CopyNewEntity: u.m_nNewEntity < 0 || m_nNewEntity >= MAX_EDICTS");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If it's new, make sure we have a slot for it.
|
||
|
|
IClientNetworkable *ent = entitylist->GetClientNetworkable( u.m_nNewEntity );
|
||
|
|
|
||
|
|
if( iClass >= cl.m_nServerClasses )
|
||
|
|
{
|
||
|
|
Host_Error("CL_CopyNewEntity: invalid class index (%d).\n", iClass);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Delete the entity.
|
||
|
|
ClientClass *pClass = cl.m_pServerClasses[iClass].m_pClientClass;
|
||
|
|
bool bNew = false;
|
||
|
|
if ( ent )
|
||
|
|
{
|
||
|
|
// if serial number is different, destory old entity
|
||
|
|
if ( ent->GetIClientUnknown()->GetRefEHandle().GetSerialNumber() != iSerialNum )
|
||
|
|
{
|
||
|
|
CL_DeleteDLLEntity( u.m_nNewEntity, "CopyNewEntity" );
|
||
|
|
ent = NULL; // force a recreate
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !ent )
|
||
|
|
{
|
||
|
|
// Ok, it doesn't exist yet, therefore this is not an "entered PVS" message.
|
||
|
|
ent = CL_CreateDLLEntity( u.m_nNewEntity, iClass, iSerialNum );
|
||
|
|
if( !ent )
|
||
|
|
{
|
||
|
|
const char *pNetworkName = cl.m_pServerClasses[iClass].m_pClientClass ? cl.m_pServerClasses[iClass].m_pClientClass->m_pNetworkName : "";
|
||
|
|
Host_Error( "CL_ParsePacketEntities: Error creating entity %s(%i)\n", pNetworkName, u.m_nNewEntity );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
bNew = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
int start_bit = u.m_pBuf->GetNumBitsRead();
|
||
|
|
|
||
|
|
DataUpdateType_t updateType = bNew ? DATA_UPDATE_CREATED : DATA_UPDATE_DATATABLE_CHANGED;
|
||
|
|
ent->PreDataUpdate( updateType );
|
||
|
|
|
||
|
|
// Get either the static or instance baseline.
|
||
|
|
const void *pFromData;
|
||
|
|
int nFromBits;
|
||
|
|
|
||
|
|
PackedEntity *baseline = u.m_bAsDelta ? cl.GetEntityBaseline( u.m_nBaseline, u.m_nNewEntity ) : NULL;
|
||
|
|
if ( baseline && baseline->m_pClientClass == pClass )
|
||
|
|
{
|
||
|
|
Assert( !baseline->IsCompressed() );
|
||
|
|
pFromData = baseline->GetData();
|
||
|
|
nFromBits = baseline->GetNumBits();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Every entity must have a static or an instance baseline when we get here.
|
||
|
|
ErrorIfNot(
|
||
|
|
cl.GetClassBaseline( iClass, &pFromData, &nFromBits ),
|
||
|
|
("CL_CopyNewEntity: GetClassBaseline(%d) failed.", iClass)
|
||
|
|
);
|
||
|
|
|
||
|
|
nFromBits *= 8; // convert to bits
|
||
|
|
}
|
||
|
|
|
||
|
|
// Delta from baseline and merge to new baseline
|
||
|
|
bf_read fromBuf( "CL_CopyNewEntity->fromBuf", pFromData, Bits2Bytes(nFromBits), nFromBits );
|
||
|
|
|
||
|
|
RecvTable *pRecvTable = GetEntRecvTable( u.m_nNewEntity );
|
||
|
|
|
||
|
|
if( !pRecvTable )
|
||
|
|
Host_Error( "CL_ParseDelta: invalid recv table for ent %d.\n", u.m_nNewEntity );
|
||
|
|
|
||
|
|
if ( u.m_bUpdateBaselines )
|
||
|
|
{
|
||
|
|
// store this baseline in u.m_pUpdateBaselines
|
||
|
|
ALIGN4 char packedData[MAX_PACKEDENTITY_DATA] ALIGN4_POST;
|
||
|
|
bf_write writeBuf( "CL_CopyNewEntity->newBuf", packedData, sizeof(packedData) );
|
||
|
|
|
||
|
|
RecvTable_MergeDeltas( pRecvTable, &fromBuf, u.m_pBuf, &writeBuf, -1, NULL, true );
|
||
|
|
|
||
|
|
// set the other baseline
|
||
|
|
cl.SetEntityBaseline( (u.m_nBaseline==0)?1:0, pClass, u.m_nNewEntity, packedData, writeBuf.GetNumBytesWritten() );
|
||
|
|
|
||
|
|
fromBuf.StartReading( packedData, writeBuf.GetNumBytesWritten() );
|
||
|
|
|
||
|
|
RecvTable_Decode( pRecvTable, ent->GetDataTableBasePtr(), &fromBuf, u.m_nNewEntity, false );
|
||
|
|
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// write data from baseline into entity
|
||
|
|
RecvTable_Decode( pRecvTable, ent->GetDataTableBasePtr(), &fromBuf, u.m_nNewEntity, false );
|
||
|
|
|
||
|
|
// Now parse in the contents of the network stream.
|
||
|
|
RecvTable_Decode( pRecvTable, ent->GetDataTableBasePtr(), u.m_pBuf, u.m_nNewEntity, true );
|
||
|
|
}
|
||
|
|
|
||
|
|
CL_AddPostDataUpdateCall( u, u.m_nNewEntity, updateType );
|
||
|
|
|
||
|
|
// If ent doesn't think it's in PVS, signal that it is
|
||
|
|
Assert( u.m_pTo->last_entity <= u.m_nNewEntity );
|
||
|
|
u.m_pTo->last_entity = u.m_nNewEntity;
|
||
|
|
Assert( !u.m_pTo->transmit_entity.Get(u.m_nNewEntity) );
|
||
|
|
u.m_pTo->transmit_entity.Set( u.m_nNewEntity );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Net stats..
|
||
|
|
//
|
||
|
|
int bit_count = u.m_pBuf->GetNumBitsRead() - start_bit;
|
||
|
|
#ifndef _XBOX
|
||
|
|
if ( cl_entityreport.GetBool() )
|
||
|
|
CL_RecordEntityBits( u.m_nNewEntity, bit_count );
|
||
|
|
#endif
|
||
|
|
if ( CL_IsPlayerIndex( u.m_nNewEntity ) )
|
||
|
|
{
|
||
|
|
if ( u.m_nNewEntity == cl.m_nPlayerSlot + 1 )
|
||
|
|
{
|
||
|
|
u.m_nLocalPlayerBits += bit_count;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
u.m_nOtherPlayerBits += bit_count;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CL_PreserveExistingEntity( int nOldEntity )
|
||
|
|
{
|
||
|
|
IClientNetworkable *pEnt = entitylist->GetClientNetworkable( nOldEntity );
|
||
|
|
if ( !pEnt )
|
||
|
|
{
|
||
|
|
// If you hit this, this is because there's a networked client entity that got released
|
||
|
|
// by some method other than a server update. This can happen if client code calls
|
||
|
|
// release on a networked entity.
|
||
|
|
|
||
|
|
#if defined( STAGING_ONLY )
|
||
|
|
// Try to use the cl_removeentity_backtrace_capture code in cliententitylist.cpp...
|
||
|
|
Msg( "%s: missing client entity %d.\n", __FUNCTION__, nOldEntity );
|
||
|
|
Cbuf_AddText( CFmtStr( "cl_removeentity_backtrace_dump %d\n", nOldEntity ) );
|
||
|
|
Cbuf_Execute();
|
||
|
|
#endif // STAGING_ONLY
|
||
|
|
|
||
|
|
Host_Error( "CL_PreserveExistingEntity: missing client entity %d.\n", nOldEntity );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
pEnt->OnDataUnchangedInPVS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CL_CopyExistingEntity( CEntityReadInfo &u )
|
||
|
|
{
|
||
|
|
int start_bit = u.m_pBuf->GetNumBitsRead();
|
||
|
|
|
||
|
|
IClientNetworkable *pEnt = entitylist->GetClientNetworkable( u.m_nNewEntity );
|
||
|
|
if ( !pEnt )
|
||
|
|
{
|
||
|
|
Host_Error( "CL_CopyExistingEntity: missing client entity %d.\n", u.m_nNewEntity );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( u.m_pFrom->transmit_entity.Get(u.m_nNewEntity) );
|
||
|
|
|
||
|
|
// Read raw data from the network stream
|
||
|
|
pEnt->PreDataUpdate( DATA_UPDATE_DATATABLE_CHANGED );
|
||
|
|
|
||
|
|
RecvTable *pRecvTable = GetEntRecvTable( u.m_nNewEntity );
|
||
|
|
|
||
|
|
if( !pRecvTable )
|
||
|
|
{
|
||
|
|
Host_Error( "CL_ParseDelta: invalid recv table for ent %d.\n", u.m_nNewEntity );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
RecvTable_Decode( pRecvTable, pEnt->GetDataTableBasePtr(), u.m_pBuf, u.m_nNewEntity );
|
||
|
|
|
||
|
|
CL_AddPostDataUpdateCall( u, u.m_nNewEntity, DATA_UPDATE_DATATABLE_CHANGED );
|
||
|
|
|
||
|
|
u.m_pTo->last_entity = u.m_nNewEntity;
|
||
|
|
Assert( !u.m_pTo->transmit_entity.Get(u.m_nNewEntity) );
|
||
|
|
u.m_pTo->transmit_entity.Set( u.m_nNewEntity );
|
||
|
|
|
||
|
|
int bit_count = u.m_pBuf->GetNumBitsRead() - start_bit;
|
||
|
|
#ifndef _XBOX
|
||
|
|
if ( cl_entityreport.GetBool() )
|
||
|
|
CL_RecordEntityBits( u.m_nNewEntity, bit_count );
|
||
|
|
#endif
|
||
|
|
if ( CL_IsPlayerIndex( u.m_nNewEntity ) )
|
||
|
|
{
|
||
|
|
if ( u.m_nNewEntity == cl.m_nPlayerSlot + 1 )
|
||
|
|
{
|
||
|
|
u.m_nLocalPlayerBits += bit_count;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
u.m_nOtherPlayerBits += bit_count;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CL_MarkEntitiesOutOfPVS( CBitVec<MAX_EDICTS> *pvs_flags )
|
||
|
|
{
|
||
|
|
int highest_index = entitylist->GetHighestEntityIndex();
|
||
|
|
// Note that we go up to and including the highest_index
|
||
|
|
for ( int i = 0; i <= highest_index; i++ )
|
||
|
|
{
|
||
|
|
IClientNetworkable *ent = entitylist->GetClientNetworkable( i );
|
||
|
|
if ( !ent )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
// FIXME: We can remove IClientEntity here if we keep track of the
|
||
|
|
// last frame's entity_in_pvs
|
||
|
|
bool curstate = !ent->IsDormant();
|
||
|
|
bool newstate = pvs_flags->Get( i ) ? true : false;
|
||
|
|
|
||
|
|
if ( !curstate && newstate )
|
||
|
|
{
|
||
|
|
// Inform the client entity list that the entity entered the PVS
|
||
|
|
ent->NotifyShouldTransmit( SHOULDTRANSMIT_START );
|
||
|
|
}
|
||
|
|
else if ( curstate && !newstate )
|
||
|
|
{
|
||
|
|
// Inform the client entity list that the entity left the PVS
|
||
|
|
ent->NotifyShouldTransmit( SHOULDTRANSMIT_END );
|
||
|
|
#ifndef _XBOX
|
||
|
|
CL_RecordLeavePVS( i );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void CL_CallPostDataUpdates( CEntityReadInfo &u )
|
||
|
|
{
|
||
|
|
for ( int i=0; i < u.m_nPostDataUpdateCalls; i++ )
|
||
|
|
{
|
||
|
|
MDLCACHE_CRITICAL_SECTION_(g_pMDLCache);
|
||
|
|
CPostDataUpdateCall *pCall = &u.m_PostDataUpdateCalls[i];
|
||
|
|
|
||
|
|
IClientNetworkable *pEnt = entitylist->GetClientNetworkable( pCall->m_iEnt );
|
||
|
|
ErrorIfNot( pEnt,
|
||
|
|
("CL_CallPostDataUpdates: missing ent %d", pCall->m_iEnt) );
|
||
|
|
|
||
|
|
pEnt->PostDataUpdate( pCall->m_UpdateType );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static float g_flLastPerfRequest = 0.0f;
|
||
|
|
|
||
|
|
static ConVar cl_debug_player_perf( "cl_debug_player_perf", "0", 0 );
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: An svc_packetentities has just been parsed, deal with the
|
||
|
|
// rest of the data stream. This can be a delta from the baseline or from a previous
|
||
|
|
// client frame for this client.
|
||
|
|
// Input : delta -
|
||
|
|
// *playerbits -
|
||
|
|
// Output : void CL_ParsePacketEntities
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CL_ProcessPacketEntities ( SVC_PacketEntities *entmsg )
|
||
|
|
{
|
||
|
|
VPROF( "_CL_ParsePacketEntities" );
|
||
|
|
|
||
|
|
// Packed entities for that frame
|
||
|
|
// Allocate space for new packet info.
|
||
|
|
CClientFrame *newFrame = cl.AllocateFrame();
|
||
|
|
newFrame->Init( cl.GetServerTickCount() );
|
||
|
|
CClientFrame *oldFrame = NULL;
|
||
|
|
|
||
|
|
// if cl_flushentitypacket is set to N, the next N entity updates will be flushed
|
||
|
|
if ( cl_flushentitypacket.GetInt() )
|
||
|
|
{
|
||
|
|
// we can't use this, it is too old
|
||
|
|
CL_FlushEntityPacket( newFrame, "Forced by cvar\n" );
|
||
|
|
cl_flushentitypacket.SetValue( cl_flushentitypacket.GetInt() - 1 ); // Reduce the cvar.
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( entmsg->m_bIsDelta )
|
||
|
|
{
|
||
|
|
int nDeltaTicks = cl.GetServerTickCount() - entmsg->m_nDeltaFrom;
|
||
|
|
float flDeltaSeconds = TICKS_TO_TIME( nDeltaTicks );
|
||
|
|
|
||
|
|
// If we have cl_debug_player_perf set and we see a huge delta between what we've ack'd to the server and where it's at
|
||
|
|
// ask it for an instantaneous perf snapshot
|
||
|
|
if ( cl_debug_player_perf.GetBool() &&
|
||
|
|
( flDeltaSeconds > 0.5f ) && // delta is pretty out of date
|
||
|
|
( ( realtime - g_flLastPerfRequest ) > 5.0f ) ) // haven't requested in a while
|
||
|
|
{
|
||
|
|
g_flLastPerfRequest = realtime;
|
||
|
|
Warning( "Gap in server data, requesting connection perf data\n" );
|
||
|
|
cl.SendStringCmd( "playerperf\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( cl.GetServerTickCount() == entmsg->m_nDeltaFrom )
|
||
|
|
{
|
||
|
|
Host_Error( "Update self-referencing, connection dropped.\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Otherwise, mark where we are valid to and point to the packet entities we'll be updating from.
|
||
|
|
oldFrame = cl.GetClientFrame( entmsg->m_nDeltaFrom );
|
||
|
|
|
||
|
|
if ( !oldFrame )
|
||
|
|
{
|
||
|
|
CL_FlushEntityPacket( newFrame, "Update delta not found.\n" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ( cl_debug_player_perf.GetBool() )
|
||
|
|
{
|
||
|
|
Warning( "Received uncompressed server update\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Clear out the client's entity states..
|
||
|
|
for ( int i=0; i <= entitylist->GetHighestEntityIndex(); i++ )
|
||
|
|
{
|
||
|
|
CL_DeleteDLLEntity( i, "ProcessPacketEntities", true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// signal client DLL that we have started updating entities
|
||
|
|
ClientDLL_FrameStageNotify( FRAME_NET_UPDATE_START );
|
||
|
|
|
||
|
|
g_nPropsDecoded = 0;
|
||
|
|
|
||
|
|
Assert( entmsg->m_nBaseline >= 0 && entmsg->m_nBaseline < 2 );
|
||
|
|
|
||
|
|
if ( entmsg->m_bUpdateBaseline )
|
||
|
|
{
|
||
|
|
// server requested to use this snapshot as baseline update
|
||
|
|
int nUpdateBaseline = (entmsg->m_nBaseline == 0) ? 1 : 0;
|
||
|
|
cl.CopyEntityBaseline( entmsg->m_nBaseline, nUpdateBaseline );
|
||
|
|
|
||
|
|
// send new baseline acknowledgement(as reliable)
|
||
|
|
cl.m_NetChannel->SendNetMsg( CLC_BaselineAck( cl.GetServerTickCount(), entmsg->m_nBaseline ), true );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
CEntityReadInfo u;
|
||
|
|
u.m_pBuf = &entmsg->m_DataIn;
|
||
|
|
u.m_pFrom = oldFrame;
|
||
|
|
u.m_pTo = newFrame;
|
||
|
|
u.m_bAsDelta = entmsg->m_bIsDelta;
|
||
|
|
u.m_nHeaderCount = entmsg->m_nUpdatedEntries;
|
||
|
|
u.m_nBaseline = entmsg->m_nBaseline;
|
||
|
|
u.m_bUpdateBaselines = entmsg->m_bUpdateBaseline;
|
||
|
|
|
||
|
|
// update the entities
|
||
|
|
cl.ReadPacketEntities( u );
|
||
|
|
|
||
|
|
ClientDLL_FrameStageNotify( FRAME_NET_UPDATE_POSTDATAUPDATE_START );
|
||
|
|
|
||
|
|
// call PostDataUpdate() for each entity
|
||
|
|
CL_CallPostDataUpdates( u );
|
||
|
|
|
||
|
|
ClientDLL_FrameStageNotify( FRAME_NET_UPDATE_POSTDATAUPDATE_END );
|
||
|
|
|
||
|
|
// call NotifyShouldTransmit() for entities that entered or left the PVS
|
||
|
|
CL_MarkEntitiesOutOfPVS( &newFrame->transmit_entity );
|
||
|
|
|
||
|
|
// adjust net channel stats
|
||
|
|
|
||
|
|
cl.m_NetChannel->UpdateMessageStats( INetChannelInfo::LOCALPLAYER, u.m_nLocalPlayerBits );
|
||
|
|
cl.m_NetChannel->UpdateMessageStats( INetChannelInfo::OTHERPLAYERS, u.m_nOtherPlayerBits );
|
||
|
|
cl.m_NetChannel->UpdateMessageStats( INetChannelInfo::ENTITIES, -(u.m_nLocalPlayerBits+u.m_nOtherPlayerBits) );
|
||
|
|
|
||
|
|
cl.DeleteClientFrames( entmsg->m_nDeltaFrom );
|
||
|
|
|
||
|
|
// If the client has more than 64 frames, the host will start to eat too much memory.
|
||
|
|
// TODO: We should enforce this somehow.
|
||
|
|
if ( MAX_CLIENT_FRAMES < cl.AddClientFrame( newFrame ) )
|
||
|
|
{
|
||
|
|
DevMsg( 1, "CL_ProcessPacketEntities: frame window too big (>%i)\n", MAX_CLIENT_FRAMES );
|
||
|
|
}
|
||
|
|
|
||
|
|
// all update activities are finished
|
||
|
|
ClientDLL_FrameStageNotify( FRAME_NET_UPDATE_END );
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
==================
|
||
|
|
CL_PreprocessEntities
|
||
|
|
|
||
|
|
Server information pertaining to this client only
|
||
|
|
==================
|
||
|
|
*/
|
||
|
|
namespace CDebugOverlay
|
||
|
|
{
|
||
|
|
extern void PurgeServerOverlays( void );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CL_PreprocessEntities( void )
|
||
|
|
{
|
||
|
|
// Zero latency!!! (single player or listen server?)
|
||
|
|
bool bIsUsingMultiplayerNetworking = NET_IsMultiplayer();
|
||
|
|
bool bLastOutgoingCommandEqualsLastAcknowledgedCommand = cl.lastoutgoingcommand == cl.command_ack;
|
||
|
|
|
||
|
|
// We always want to re-run prediction when using the multiplayer networking, or if we're the listen server and we get a packet
|
||
|
|
// before any frames have run
|
||
|
|
if ( bIsUsingMultiplayerNetworking ||
|
||
|
|
bLastOutgoingCommandEqualsLastAcknowledgedCommand )
|
||
|
|
{
|
||
|
|
//Msg( "%i/%i CL_ParseClientdata: no latency server ack %i\n",
|
||
|
|
// host_framecount, cl.tickcount,
|
||
|
|
// command_ack );
|
||
|
|
CL_RunPrediction( PREDICTION_SIMULATION_RESULTS_ARRIVING_ON_SEND_FRAME );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Copy some results from prediction back into right spot
|
||
|
|
// Anything not sent over the network from server to client must be specified here.
|
||
|
|
//if ( cl.last_command_ack )
|
||
|
|
{
|
||
|
|
int number_of_commands_executed = ( cl.command_ack - cl.last_command_ack );
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
COM_Log( "cl.log", "Receiving frame acknowledging %i commands\n",
|
||
|
|
number_of_commands_executed );
|
||
|
|
|
||
|
|
COM_Log( "cl.log", " last command number executed %i\n",
|
||
|
|
cl.command_ack );
|
||
|
|
|
||
|
|
COM_Log( "cl.log", " previous last command number executed %i\n",
|
||
|
|
cl.last_command_ack );
|
||
|
|
|
||
|
|
COM_Log( "cl.log", " current world frame %i\n",
|
||
|
|
cl.m_nCurrentSequence );
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Copy last set of changes right into current frame.
|
||
|
|
g_pClientSidePrediction->PreEntityPacketReceived( number_of_commands_executed, cl.m_nCurrentSequence );
|
||
|
|
}
|
||
|
|
|
||
|
|
CDebugOverlay::PurgeServerOverlays();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|