mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
912 lines
25 KiB
C++
912 lines
25 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include <proto_version.h>
|
|
#include <netmessages.h>
|
|
#include "hltvclientstate.h"
|
|
#include "hltvserver.h"
|
|
#include "quakedef.h"
|
|
#include "cl_main.h"
|
|
#include "host.h"
|
|
#include "dt_recv_eng.h"
|
|
#include "dt_common_eng.h"
|
|
#include "framesnapshot.h"
|
|
#include "clientframe.h"
|
|
#include "ents_shared.h"
|
|
#include "server.h"
|
|
#include "eiface.h"
|
|
#include "server_class.h"
|
|
#include "cdll_engine_int.h"
|
|
#include "sv_main.h"
|
|
#include "changeframelist.h"
|
|
#include "GameEventManager.h"
|
|
#include "dt_recv_decoder.h"
|
|
#include "utllinkedlist.h"
|
|
#include "cl_demo.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// copy message data from in to out buffer
|
|
#define CopyDataInToOut(msg) \
|
|
int size = PAD_NUMBER( Bits2Bytes(msg->m_nLength), 4); \
|
|
byte *buffer = (byte*) stackalloc( size ); \
|
|
msg->m_DataIn.ReadBits( buffer, msg->m_nLength ); \
|
|
msg->m_DataOut.StartWriting( buffer, size, msg->m_nLength );\
|
|
|
|
static void HLTV_Callback_InstanceBaseline( void *object, INetworkStringTable *stringTable, int stringNumber, char const *newString, void const *newData )
|
|
{
|
|
// relink server classes to instance baselines
|
|
CHLTVServer *pHLTV = (CHLTVServer*)object;
|
|
pHLTV->LinkInstanceBaselines();
|
|
}
|
|
|
|
extern CUtlLinkedList< CRecvDecoder *, unsigned short > g_RecvDecoders;
|
|
|
|
extern ConVar tv_autorecord;
|
|
static ConVar tv_autoretry( "tv_autoretry", "1", 0, "Relay proxies retry connection after network timeout" );
|
|
static ConVar tv_timeout( "tv_timeout", "30", 0, "SourceTV connection timeout in seconds." );
|
|
ConVar tv_snapshotrate("tv_snapshotrate", "16", 0, "Snapshots broadcasted per second" );
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
CHLTVClientState::CHLTVClientState()
|
|
{
|
|
m_pNewClientFrame = NULL;
|
|
m_pCurrentClientFrame = NULL;
|
|
m_bSaveMemory = false;
|
|
}
|
|
|
|
CHLTVClientState::~CHLTVClientState()
|
|
{
|
|
|
|
}
|
|
|
|
void CHLTVClientState::CopyNewEntity(
|
|
CEntityReadInfo &u,
|
|
int iClass,
|
|
int iSerialNum
|
|
)
|
|
{
|
|
ServerClass *pServerClass = SV_FindServerClass( iClass );
|
|
Assert( pServerClass );
|
|
|
|
ClientClass *pClientClass = GetClientClass( iClass );
|
|
Assert( pClientClass );
|
|
|
|
const int ent = u.m_nNewEntity;
|
|
|
|
// copy class & serial
|
|
CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot();
|
|
pSnapshot->m_pEntities[ent].m_nSerialNumber = iSerialNum;
|
|
pSnapshot->m_pEntities[ent].m_pClass = pServerClass;
|
|
|
|
// Get either the static or instance baseline.
|
|
const void *pFromData = NULL;
|
|
int nFromBits = 0;
|
|
int nFromTick = 0; // MOTODO get tick when baseline last changed
|
|
|
|
PackedEntity *baseline = u.m_bAsDelta ? GetEntityBaseline( u.m_nBaseline, ent ) : NULL;
|
|
|
|
if ( baseline && baseline->m_pClientClass == pClientClass )
|
|
{
|
|
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(
|
|
GetClassBaseline( iClass, &pFromData, &nFromBits ),
|
|
("HLTV_CopyNewEntity: GetDynamicBaseline(%d) failed.", iClass)
|
|
);
|
|
nFromBits *= 8; // convert to bits
|
|
}
|
|
|
|
// create new ChangeFrameList containing all properties set as changed
|
|
int nFlatProps = SendTable_GetNumFlatProps( pServerClass->m_pTable );
|
|
IChangeFrameList *pChangeFrame = NULL;
|
|
|
|
if ( !m_bSaveMemory )
|
|
{
|
|
pChangeFrame = AllocChangeFrameList( nFlatProps, nFromTick );
|
|
}
|
|
|
|
// Now make a PackedEntity and store the new packed data in there.
|
|
PackedEntity *pPackedEntity = framesnapshotmanager->CreatePackedEntity( pSnapshot, ent );
|
|
pPackedEntity->SetChangeFrameList( pChangeFrame );
|
|
pPackedEntity->SetServerAndClientClass( pServerClass, pClientClass );
|
|
|
|
// Make space for the baseline data.
|
|
ALIGN4 char packedData[MAX_PACKEDENTITY_DATA] ALIGN4_POST;
|
|
bf_read fromBuf( "HLTV_ReadEnterPVS1", pFromData, Bits2Bytes( nFromBits ), nFromBits );
|
|
bf_write writeBuf( "HLTV_ReadEnterPVS2", packedData, sizeof( packedData ) );
|
|
|
|
int changedProps[MAX_DATATABLE_PROPS];
|
|
|
|
// decode basline, is compressed against zero values
|
|
int nChangedProps = RecvTable_MergeDeltas( pClientClass->m_pRecvTable, &fromBuf,
|
|
u.m_pBuf, &writeBuf, -1, changedProps );
|
|
|
|
// update change tick in ChangeFrameList
|
|
if ( pChangeFrame )
|
|
{
|
|
pChangeFrame->SetChangeTick( changedProps, nChangedProps, pSnapshot->m_nTickCount );
|
|
}
|
|
|
|
if ( u.m_bUpdateBaselines )
|
|
{
|
|
SetEntityBaseline( (u.m_nBaseline==0)?1:0, pClientClass, u.m_nNewEntity, packedData, writeBuf.GetNumBytesWritten() );
|
|
}
|
|
|
|
pPackedEntity->AllocAndCopyPadded( packedData, writeBuf.GetNumBytesWritten() );
|
|
|
|
// If ent doesn't think it's in PVS, signal that it is
|
|
Assert( u.m_pTo->last_entity <= ent );
|
|
u.m_pTo->last_entity = ent;
|
|
u.m_pTo->transmit_entity.Set( ent );
|
|
}
|
|
|
|
static inline void HLTV_CopyExitingEnt( CEntityReadInfo &u )
|
|
{
|
|
if ( !u.m_bAsDelta ) // Should never happen on a full update.
|
|
{
|
|
Assert(0); // cl.validsequence = 0;
|
|
ConMsg( "WARNING: CopyExitingEnt on full update.\n" );
|
|
u.m_UpdateType = Failed; // break out
|
|
return;
|
|
}
|
|
|
|
CFrameSnapshot *pFromSnapshot = u.m_pFrom->GetSnapshot(); // get from snapshot
|
|
|
|
const int ent = u.m_nOldEntity;
|
|
|
|
CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot(); // get to snapshot
|
|
|
|
// copy ent handle, serial numbers & class info
|
|
Assert( ent < pFromSnapshot->m_nNumEntities );
|
|
pSnapshot->m_pEntities[ent] = pFromSnapshot->m_pEntities[ent];
|
|
|
|
Assert( pSnapshot->m_pEntities[ent].m_pPackedData != INVALID_PACKED_ENTITY_HANDLE );
|
|
|
|
// increase PackedEntity reference counter
|
|
PackedEntity *pEntity = framesnapshotmanager->GetPackedEntity( pSnapshot, ent );
|
|
Assert( pEntity );
|
|
pEntity->m_ReferenceCount++;
|
|
|
|
|
|
Assert( u.m_pTo->last_entity <= ent );
|
|
|
|
// mark flags as received
|
|
u.m_pTo->last_entity = ent;
|
|
u.m_pTo->transmit_entity.Set( ent );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A svc_signonnum has been received, perform a client side setup
|
|
// Output : void CL_SignonReply
|
|
//-----------------------------------------------------------------------------
|
|
bool CHLTVClientState::SetSignonState ( int state, int count )
|
|
{
|
|
// ConDMsg ("CL_SignonReply: %i\n", cl.signon);
|
|
|
|
if ( !CBaseClientState::SetSignonState( state, count ) )
|
|
return false;
|
|
|
|
Assert ( m_nSignonState == state );
|
|
|
|
switch ( m_nSignonState )
|
|
{
|
|
case SIGNONSTATE_CHALLENGE : break;
|
|
case SIGNONSTATE_CONNECTED : {
|
|
// allow longer timeout
|
|
m_NetChannel->SetTimeout( SIGNON_TIME_OUT );
|
|
|
|
m_NetChannel->Clear();
|
|
// set user settings (rate etc)
|
|
NET_SetConVar convars;
|
|
Host_BuildConVarUpdateMessage( &convars, FCVAR_USERINFO, false );
|
|
|
|
// let server know that we are a proxy server:
|
|
NET_SetConVar::cvar_t acvar;
|
|
V_strcpy_safe( acvar.name, "tv_relay" );
|
|
V_strcpy_safe( acvar.value, "1" );
|
|
convars.m_ConVars.AddToTail( acvar );
|
|
|
|
m_NetChannel->SendNetMsg( convars );
|
|
}
|
|
break;
|
|
|
|
case SIGNONSTATE_NEW : SendClientInfo();
|
|
break;
|
|
|
|
case SIGNONSTATE_PRESPAWN : break;
|
|
|
|
case SIGNONSTATE_SPAWN : m_pHLTV->SignonComplete();
|
|
break;
|
|
|
|
case SIGNONSTATE_FULL : m_NetChannel->SetTimeout( tv_timeout.GetFloat() );
|
|
// start new recording if autorecord is enabled
|
|
if ( tv_autorecord.GetBool() )
|
|
{
|
|
hltv->m_DemoRecorder.StartAutoRecording();
|
|
m_NetChannel->SetDemoRecorder( &hltv->m_DemoRecorder );
|
|
}
|
|
break;
|
|
|
|
case SIGNONSTATE_CHANGELEVEL: m_pHLTV->Changelevel();
|
|
m_NetChannel->SetTimeout( SIGNON_TIME_OUT ); // allow 5 minutes timeout
|
|
break;
|
|
}
|
|
|
|
if ( m_nSignonState >= SIGNONSTATE_CONNECTED )
|
|
{
|
|
// tell server that we entered now that state
|
|
NET_SignonState signonState( m_nSignonState, count );
|
|
m_NetChannel->SendNetMsg( signonState );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CHLTVClientState::SendClientInfo( void )
|
|
{
|
|
CLC_ClientInfo info;
|
|
|
|
info.m_nSendTableCRC = SendTable_GetCRC();
|
|
info.m_nServerCount = m_nServerCount;
|
|
info.m_bIsHLTV = true;
|
|
#if defined( REPLAY_ENABLED )
|
|
info.m_bIsReplay = false;
|
|
#endif
|
|
info.m_nFriendsID = 0;
|
|
info.m_FriendsName[0] = 0;
|
|
|
|
// CheckOwnCustomFiles(); // load & verfiy custom player files
|
|
|
|
for ( int i=0; i< MAX_CUSTOM_FILES; i++ )
|
|
info.m_nCustomFiles[i] = 0;
|
|
|
|
m_NetChannel->SendNetMsg( info );
|
|
}
|
|
|
|
|
|
void CHLTVClientState::SendPacket()
|
|
{
|
|
if ( !IsConnected() )
|
|
return;
|
|
|
|
if ( ( net_time < m_flNextCmdTime ) || !m_NetChannel->CanPacket() )
|
|
return;
|
|
|
|
if ( IsActive() )
|
|
{
|
|
NET_Tick tick( m_nDeltaTick, host_frametime_unbounded, host_frametime_stddeviation );
|
|
m_NetChannel->SendNetMsg( tick );
|
|
}
|
|
|
|
m_NetChannel->SendDatagram( NULL );
|
|
|
|
if ( IsActive() )
|
|
{
|
|
// use full update rate when active
|
|
float commandInterval = (2.0f/3.0f) / tv_snapshotrate.GetInt();
|
|
float maxDelta = min ( host_state.interval_per_tick, commandInterval );
|
|
float delta = clamp( (float)(net_time - m_flNextCmdTime), 0.0f, maxDelta );
|
|
m_flNextCmdTime = net_time + commandInterval - delta;
|
|
}
|
|
else
|
|
{
|
|
// during signon process send only 5 packets/second
|
|
m_flNextCmdTime = net_time + ( 1.0f / 5.0f );
|
|
}
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessStringCmd(NET_StringCmd *msg)
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessSetConVar(NET_SetConVar *msg)
|
|
{
|
|
if ( !CBaseClientState::ProcessSetConVar( msg ) )
|
|
return false;
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
void CHLTVClientState::Clear()
|
|
{
|
|
CBaseClientState::Clear();
|
|
|
|
m_pNewClientFrame = NULL;
|
|
m_pCurrentClientFrame = NULL;
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessServerInfo(SVC_ServerInfo *msg )
|
|
{
|
|
// Reset client state
|
|
Clear();
|
|
|
|
// is server a HLTV proxy or demo file ?
|
|
if ( !m_pHLTV->IsPlayingBack() )
|
|
{
|
|
if ( !msg->m_bIsHLTV )
|
|
{
|
|
ConMsg ( "Server (%s) is not a SourceTV proxy.\n", m_NetChannel->GetAddress() );
|
|
Disconnect( "Server is not a SourceTV proxy", true );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// tell HLTV relay to clear everything
|
|
m_pHLTV->StartRelay();
|
|
|
|
// Process the message
|
|
if ( !CBaseClientState::ProcessServerInfo( msg ) )
|
|
{
|
|
Disconnect( "CBaseClientState::ProcessServerInfo failed", true );
|
|
return false;
|
|
}
|
|
|
|
m_StringTableContainer = m_pHLTV->m_StringTables;
|
|
|
|
Assert( m_StringTableContainer->GetNumTables() == 0); // must be empty
|
|
|
|
#ifndef SHARED_NET_STRING_TABLES
|
|
// relay uses normal string tables without a change history
|
|
m_StringTableContainer->EnableRollback( false );
|
|
#endif
|
|
|
|
// copy setting from HLTV client to HLTV server
|
|
m_pHLTV->m_nGameServerMaxClients = m_nMaxClients;
|
|
m_pHLTV->serverclasses = m_nServerClasses;
|
|
m_pHLTV->serverclassbits = m_nServerClassBits;
|
|
m_pHLTV->m_nPlayerSlot = m_nPlayerSlot;
|
|
|
|
// copy other settings to HLTV server
|
|
V_memcpy( m_pHLTV->worldmapMD5.bits, msg->m_nMapMD5.bits, MD5_DIGEST_LENGTH );
|
|
m_pHLTV->m_flTickInterval = msg->m_fTickInterval;
|
|
|
|
host_state.interval_per_tick = msg->m_fTickInterval;
|
|
|
|
Q_strncpy( m_pHLTV->m_szMapname, msg->m_szMapName, sizeof(m_pHLTV->m_szMapname) );
|
|
Q_strncpy( m_pHLTV->m_szSkyname, msg->m_szSkyName, sizeof(m_pHLTV->m_szSkyname) );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessClassInfo( SVC_ClassInfo *msg )
|
|
{
|
|
if ( !msg->m_bCreateOnClient )
|
|
{
|
|
ConMsg("HLTV SendTable CRC differs from server.\n");
|
|
Disconnect( "HLTV SendTable CRC differs from server.", true );
|
|
return false;
|
|
}
|
|
|
|
#ifdef _HLTVTEST
|
|
RecvTable_Term( false );
|
|
#endif
|
|
|
|
// Create all of the send tables locally
|
|
DataTable_CreateClientTablesFromServerTables();
|
|
|
|
// Now create all of the server classes locally, too
|
|
DataTable_CreateClientClassInfosFromServerClasses( this );
|
|
|
|
LinkClasses(); // link server and client classes
|
|
|
|
#ifdef DEDICATED
|
|
bool bAllowMismatches = false;
|
|
#else
|
|
bool bAllowMismatches = ( demoplayer && demoplayer->IsPlayingBack() );
|
|
#endif // DEDICATED
|
|
|
|
if ( !RecvTable_CreateDecoders( serverGameDLL->GetStandardSendProxies(), bAllowMismatches ) ) // create receive table decoders
|
|
{
|
|
Host_EndGame( true, "CL_ParseClassInfo_EndClasses: CreateDecoders failed.\n" );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CHLTVClientState::PacketEnd( void )
|
|
{
|
|
// did we get a snapshot with this packet ?
|
|
if ( m_pNewClientFrame )
|
|
{
|
|
// if so, add a new frame to HLTV
|
|
m_pCurrentClientFrame = m_pHLTV->AddNewFrame( m_pNewClientFrame );
|
|
delete m_pNewClientFrame; // release own refernces
|
|
m_pNewClientFrame = NULL;
|
|
}
|
|
}
|
|
|
|
bool CHLTVClientState::HookClientStringTable( char const *tableName )
|
|
{
|
|
INetworkStringTable *table = GetStringTable( tableName );
|
|
if ( !table )
|
|
return false;
|
|
|
|
// Hook instance baseline table
|
|
if ( !Q_strcasecmp( tableName, INSTANCE_BASELINE_TABLENAME ) )
|
|
{
|
|
table->SetStringChangedCallback( m_pHLTV, HLTV_Callback_InstanceBaseline );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CHLTVClientState::InstallStringTableCallback( char const *tableName )
|
|
{
|
|
INetworkStringTable *table = GetStringTable( tableName );
|
|
|
|
if ( !table )
|
|
return;
|
|
|
|
// Hook instance baseline table
|
|
if ( !Q_strcasecmp( tableName, INSTANCE_BASELINE_TABLENAME ) )
|
|
{
|
|
table->SetStringChangedCallback( m_pHLTV, HLTV_Callback_InstanceBaseline );
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessSetView( SVC_SetView *msg )
|
|
{
|
|
if ( !CBaseClientState::ProcessSetView( msg ) )
|
|
return false;
|
|
|
|
return m_pHLTV->SendNetMsg( *msg );
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessVoiceInit( SVC_VoiceInit *msg )
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessVoiceData( SVC_VoiceData *msg )
|
|
{
|
|
int size = PAD_NUMBER( Bits2Bytes(msg->m_nLength), 4);
|
|
byte *buffer = (byte*) stackalloc( size );
|
|
msg->m_DataIn.ReadBits( buffer, msg->m_nLength );
|
|
msg->m_DataOut = buffer;
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessSounds(SVC_Sounds *msg)
|
|
{
|
|
CopyDataInToOut( msg );
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessPrefetch( SVC_Prefetch *msg )
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessFixAngle( SVC_FixAngle *msg )
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessCrosshairAngle( SVC_CrosshairAngle *msg )
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessBSPDecal( SVC_BSPDecal *msg )
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessGameEvent( SVC_GameEvent *msg )
|
|
{
|
|
bf_read tmpBuf = msg->m_DataIn;
|
|
|
|
IGameEvent *event = g_GameEventManager.UnserializeEvent( &tmpBuf );
|
|
|
|
if ( event )
|
|
{
|
|
const char *pszName = event->GetName();
|
|
|
|
bool bDontForward = false;
|
|
|
|
if ( Q_strcmp( pszName, "hltv_status" ) == 0 )
|
|
{
|
|
m_pHLTV->m_nGlobalSlots = event->GetInt("slots");;
|
|
m_pHLTV->m_nGlobalProxies = event->GetInt("proxies");
|
|
m_pHLTV->m_nGlobalClients = event->GetInt("clients");
|
|
m_pHLTV->m_RootServer.SetFromString( event->GetString("master") );
|
|
bDontForward = true;
|
|
}
|
|
else if ( Q_strcmp( pszName, "hltv_title" ) == 0 )
|
|
{
|
|
// ignore title messages
|
|
bDontForward = true;
|
|
}
|
|
|
|
// free event resources
|
|
g_GameEventManager.FreeEvent( event );
|
|
|
|
if ( bDontForward )
|
|
return true;
|
|
}
|
|
|
|
// forward event
|
|
CopyDataInToOut( msg );
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessGameEventList( SVC_GameEventList *msg )
|
|
{
|
|
// copy message before processing
|
|
SVC_GameEventList tmpMsg = *msg;
|
|
CBaseClientState::ProcessGameEventList( &tmpMsg );
|
|
|
|
CopyDataInToOut( msg );
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessUserMessage( SVC_UserMessage *msg )
|
|
{
|
|
CopyDataInToOut( msg );
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessEntityMessage( SVC_EntityMessage *msg )
|
|
{
|
|
CopyDataInToOut( msg );
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessMenu( SVC_Menu *msg )
|
|
{
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessPacketEntities( SVC_PacketEntities *entmsg )
|
|
{
|
|
CClientFrame *oldFrame = NULL;
|
|
|
|
#ifdef _HLTVTEST
|
|
if ( g_RecvDecoders.Count() == 0 )
|
|
return false;
|
|
#endif
|
|
|
|
if ( entmsg->m_bIsDelta )
|
|
{
|
|
if ( 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 = m_pHLTV->GetClientFrame( entmsg->m_nDeltaFrom );
|
|
}
|
|
|
|
// create new empty snapshot
|
|
CFrameSnapshot* pSnapshot = framesnapshotmanager->CreateEmptySnapshot( GetServerTickCount(), entmsg->m_nMaxEntries );
|
|
|
|
Assert( m_pNewClientFrame == NULL );
|
|
|
|
m_pNewClientFrame = new CClientFrame( pSnapshot );
|
|
|
|
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;
|
|
CopyEntityBaseline( entmsg->m_nBaseline, nUpdateBaseline );
|
|
|
|
// send new baseline acknowledgement(as reliable)
|
|
CLC_BaselineAck baseline( GetServerTickCount(), entmsg->m_nBaseline );
|
|
m_NetChannel->SendNetMsg( baseline, true );
|
|
}
|
|
|
|
// copy classes and serial numbers from current frame
|
|
if ( m_pCurrentClientFrame )
|
|
{
|
|
CFrameSnapshot* pLastSnapshot = m_pCurrentClientFrame->GetSnapshot();
|
|
CFrameSnapshotEntry *pEntry = pSnapshot->m_pEntities;
|
|
CFrameSnapshotEntry *pLastEntry = pLastSnapshot->m_pEntities;
|
|
|
|
Assert( pLastSnapshot->m_nNumEntities <= pSnapshot->m_nNumEntities );
|
|
|
|
for ( int i = 0; i<pLastSnapshot->m_nNumEntities; i++ )
|
|
{
|
|
pEntry->m_nSerialNumber = pLastEntry->m_nSerialNumber;
|
|
pEntry->m_pClass = pLastEntry->m_pClass;
|
|
|
|
pEntry++;
|
|
pLastEntry++;
|
|
}
|
|
}
|
|
|
|
CEntityReadInfo u;
|
|
u.m_pBuf = &entmsg->m_DataIn;
|
|
u.m_pFrom = oldFrame;
|
|
u.m_pTo = m_pNewClientFrame;
|
|
u.m_bAsDelta = entmsg->m_bIsDelta;
|
|
u.m_nHeaderCount = entmsg->m_nUpdatedEntries;
|
|
u.m_nBaseline = entmsg->m_nBaseline;
|
|
u.m_bUpdateBaselines = entmsg->m_bUpdateBaseline;
|
|
|
|
ReadPacketEntities( u );
|
|
|
|
// adjust reference count to be 1
|
|
pSnapshot->ReleaseReference();
|
|
|
|
return CBaseClientState::ProcessPacketEntities( entmsg );
|
|
}
|
|
|
|
bool CHLTVClientState::ProcessTempEntities( SVC_TempEntities *msg )
|
|
{
|
|
CopyDataInToOut( msg );
|
|
|
|
return m_pHLTV->SendNetMsg( *msg ); // relay to server
|
|
}
|
|
|
|
void CHLTVClientState::ReadEnterPVS( CEntityReadInfo &u )
|
|
{
|
|
int iClass = u.m_pBuf->ReadUBitLong( m_nServerClassBits );
|
|
|
|
int iSerialNum = u.m_pBuf->ReadUBitLong( NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS );
|
|
|
|
CopyNewEntity( u, iClass, iSerialNum );
|
|
|
|
if ( u.m_nNewEntity == u.m_nOldEntity ) // that was a recreate
|
|
u.NextOldEntity();
|
|
}
|
|
|
|
void CHLTVClientState::ReadLeavePVS( CEntityReadInfo &u )
|
|
{
|
|
// do nothing, this entity was removed
|
|
Assert( !u.m_pTo->transmit_entity.Get(u.m_nOldEntity) );
|
|
|
|
if ( u.m_UpdateFlags & FHDR_DELETE )
|
|
{
|
|
CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot();
|
|
CFrameSnapshotEntry *pEntry = &pSnapshot->m_pEntities[u.m_nOldEntity];
|
|
|
|
// clear entity references
|
|
pEntry->m_nSerialNumber = -1;
|
|
pEntry->m_pClass = NULL;
|
|
Assert( pEntry->m_pPackedData == INVALID_PACKED_ENTITY_HANDLE );
|
|
}
|
|
|
|
u.NextOldEntity();
|
|
|
|
}
|
|
|
|
void CHLTVClientState::ReadDeltaEnt( CEntityReadInfo &u )
|
|
{
|
|
const int i = u.m_nNewEntity;
|
|
CFrameSnapshot *pFromSnapshot = u.m_pFrom->GetSnapshot();
|
|
|
|
CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot();
|
|
|
|
Assert( i < pFromSnapshot->m_nNumEntities );
|
|
pSnapshot->m_pEntities[i] = pFromSnapshot->m_pEntities[i];
|
|
|
|
PackedEntity *pToPackedEntity = framesnapshotmanager->CreatePackedEntity( pSnapshot, i );
|
|
|
|
// WARNING! get pFromPackedEntity after new pPackedEntity has been created, otherwise pointer may be wrong
|
|
PackedEntity *pFromPackedEntity = framesnapshotmanager->GetPackedEntity( pFromSnapshot, i );
|
|
|
|
pToPackedEntity->SetServerAndClientClass( pFromPackedEntity->m_pServerClass, pFromPackedEntity->m_pClientClass );
|
|
|
|
// create a copy of the pFromSnapshot ChangeFrameList
|
|
IChangeFrameList* pChangeFrame = NULL;
|
|
|
|
if ( !m_bSaveMemory )
|
|
{
|
|
pChangeFrame = pFromPackedEntity->GetChangeFrameList()->Copy();
|
|
pToPackedEntity->SetChangeFrameList( pChangeFrame );
|
|
}
|
|
|
|
// Make space for the baseline data.
|
|
ALIGN4 char packedData[MAX_PACKEDENTITY_DATA] ALIGN4_POST;
|
|
const void *pFromData;
|
|
int nFromBits;
|
|
|
|
if ( pFromPackedEntity->IsCompressed() )
|
|
{
|
|
pFromData = m_pHLTV->UncompressPackedEntity( pFromPackedEntity, nFromBits );
|
|
}
|
|
else
|
|
{
|
|
pFromData = pFromPackedEntity->GetData();
|
|
nFromBits = pFromPackedEntity->GetNumBits();
|
|
}
|
|
|
|
bf_read fromBuf( "HLTV_ReadEnterPVS1", pFromData, Bits2Bytes( nFromBits ), nFromBits );
|
|
bf_write writeBuf( "HLTV_ReadEnterPVS2", packedData, sizeof( packedData ) );
|
|
|
|
int changedProps[MAX_DATATABLE_PROPS];
|
|
|
|
// decode baseline, is compressed against zero values
|
|
int nChangedProps = RecvTable_MergeDeltas( pToPackedEntity->m_pClientClass->m_pRecvTable,
|
|
&fromBuf, u.m_pBuf, &writeBuf, -1, changedProps, false );
|
|
|
|
// update change tick in ChangeFrameList
|
|
if ( pChangeFrame )
|
|
{
|
|
pChangeFrame->SetChangeTick( changedProps, nChangedProps, pSnapshot->m_nTickCount );
|
|
}
|
|
|
|
if ( m_bSaveMemory )
|
|
{
|
|
int bits = writeBuf.GetNumBitsWritten();
|
|
|
|
const char *compressedData = m_pHLTV->CompressPackedEntity(
|
|
pToPackedEntity->m_pServerClass,
|
|
(char*)writeBuf.GetData(),
|
|
bits );
|
|
|
|
// store as compressed data and don't use mem pools
|
|
pToPackedEntity->AllocAndCopyPadded( compressedData, Bits2Bytes(bits) );
|
|
pToPackedEntity->SetCompressed();
|
|
}
|
|
else
|
|
{
|
|
// store as normal
|
|
pToPackedEntity->AllocAndCopyPadded( packedData, writeBuf.GetNumBytesWritten() );
|
|
}
|
|
|
|
u.m_pTo->last_entity = u.m_nNewEntity;
|
|
u.m_pTo->transmit_entity.Set( u.m_nNewEntity );
|
|
|
|
u.NextOldEntity();
|
|
}
|
|
|
|
void CHLTVClientState::ReadPreserveEnt( CEntityReadInfo &u )
|
|
{
|
|
// copy one of the old entities over to the new packet unchanged
|
|
|
|
// XXX(JohnS): This was historically checking for NewEntity overflow, though this path does not care (and new entity
|
|
// may be -1). The old entity bounds check here seems like what was intended, but since nNewEntity
|
|
// should not be overflowed either, I've left that check in case it was guarding against a case I am
|
|
// overlooking.
|
|
if ( u.m_nOldEntity >= MAX_EDICTS || u.m_nOldEntity < 0 || u.m_nNewEntity >= MAX_EDICTS )
|
|
{
|
|
Host_Error( "CL_ReadPreserveEnt: Entity out of bounds. Old: %i, New: %i",
|
|
u.m_nOldEntity, u.m_nNewEntity );
|
|
}
|
|
|
|
HLTV_CopyExitingEnt( u );
|
|
|
|
u.NextOldEntity();
|
|
}
|
|
|
|
void CHLTVClientState::ReadDeletions( CEntityReadInfo &u )
|
|
{
|
|
while ( u.m_pBuf->ReadOneBit()!=0 )
|
|
{
|
|
int idx = u.m_pBuf->ReadUBitLong( MAX_EDICT_BITS );
|
|
|
|
Assert( !u.m_pTo->transmit_entity.Get( idx ) );
|
|
|
|
CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot();
|
|
CFrameSnapshotEntry *pEntry = &pSnapshot->m_pEntities[idx];
|
|
|
|
// clear entity references
|
|
pEntry->m_nSerialNumber = -1;
|
|
pEntry->m_pClass = NULL;
|
|
Assert( pEntry->m_pPackedData == INVALID_PACKED_ENTITY_HANDLE );
|
|
}
|
|
}
|
|
|
|
int CHLTVClientState::GetConnectionRetryNumber() const
|
|
{
|
|
if ( tv_autoretry.GetBool() )
|
|
{
|
|
// in autoretry mode try extra long
|
|
return CL_CONNECTION_RETRIES * 4;
|
|
}
|
|
else
|
|
{
|
|
return CL_CONNECTION_RETRIES;
|
|
}
|
|
}
|
|
|
|
void CHLTVClientState::ConnectionCrashed(const char *reason)
|
|
{
|
|
CBaseClientState::ConnectionCrashed( reason );
|
|
|
|
if ( tv_autoretry.GetBool() && m_szRetryAddress[0] )
|
|
{
|
|
Cbuf_AddText( va( "tv_relay %s\n", m_szRetryAddress ) );
|
|
}
|
|
}
|
|
|
|
void CHLTVClientState::ConnectionClosing( const char *reason )
|
|
{
|
|
CBaseClientState::ConnectionClosing( reason );
|
|
|
|
if ( tv_autoretry.GetBool() && m_szRetryAddress[0] )
|
|
{
|
|
Cbuf_AddText( va( "tv_relay %s\n", m_szRetryAddress ) );
|
|
}
|
|
}
|
|
|
|
void CHLTVClientState::RunFrame()
|
|
{
|
|
CBaseClientState::RunFrame();
|
|
|
|
if ( m_NetChannel && m_NetChannel->IsTimedOut() && IsConnected() )
|
|
{
|
|
ConMsg ("\nSourceTV connection timed out.\n");
|
|
Disconnect( "nSourceTV connection timed out", true );
|
|
return;
|
|
}
|
|
|
|
UpdateStats();
|
|
}
|
|
|
|
void CHLTVClientState::UpdateStats()
|
|
{
|
|
if ( m_nSignonState < SIGNONSTATE_FULL )
|
|
{
|
|
m_fNextSendUpdateTime = 0.0f;
|
|
return;
|
|
}
|
|
|
|
if ( m_fNextSendUpdateTime > net_time )
|
|
return;
|
|
|
|
m_fNextSendUpdateTime = net_time + 8.0f;
|
|
|
|
int proxies, slots, clients;
|
|
|
|
m_pHLTV->GetRelayStats( proxies, slots, clients );
|
|
|
|
proxies += 1; // add self to number of proxies
|
|
slots += m_pHLTV->GetMaxClients(); // add own slots
|
|
clients += m_pHLTV->GetNumClients(); // add own clients
|
|
|
|
NET_SetConVar conVars;
|
|
NET_SetConVar::cvar_t acvar;
|
|
|
|
Q_strncpy( acvar.name, "hltv_proxies", sizeof(acvar.name) );
|
|
Q_snprintf( acvar.value, sizeof(acvar.value), "%d", proxies );
|
|
conVars.m_ConVars.AddToTail( acvar );
|
|
|
|
Q_strncpy( acvar.name, "hltv_clients", sizeof(acvar.name) );
|
|
Q_snprintf( acvar.value, sizeof(acvar.value), "%d", clients );
|
|
conVars.m_ConVars.AddToTail( acvar );
|
|
|
|
Q_strncpy( acvar.name, "hltv_slots", sizeof(acvar.name) );
|
|
Q_snprintf( acvar.value, sizeof(acvar.value), "%d", slots );
|
|
conVars.m_ConVars.AddToTail( acvar );
|
|
|
|
Q_strncpy( acvar.name, "hltv_addr", sizeof(acvar.name) );
|
|
Q_snprintf( acvar.value, sizeof(acvar.value), "%s:%u", net_local_adr.ToString(true), m_pHLTV->GetUDPPort() );
|
|
conVars.m_ConVars.AddToTail( acvar );
|
|
|
|
m_NetChannel->SendNetMsg( conVars );
|
|
}
|
|
|