csgo/cstrike15_src/engine/hltvserver.cpp

//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
// hltvserver.cpp: implementation of the CHLTVServer class.
//
//////////////////////////////////////////////////////////////////////

#include <server_class.h>
#include <inetmessage.h>
#include <tier0/vprof.h>
#include <keyvalues.h>
#include <edict.h>
#include <eiface.h>
#include <PlayerState.h>
#include <ihltvdirector.h>
#include <time.h>

#include "hltvserver.h"
#include "sv_client.h"
#include "hltvclient.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 "tier0/icommandline.h"
#include "mathlib/IceKey.H"
#include "tier1/fmtstr.h"
#include "serializedentity.h"
#include "changeframelist.h"
#include "ihltv.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

extern ConVar tv_snapshotrate, tv_snapshotrate1;

extern CNetworkStringTableContainer *networkStringTableContainerClient;

//we do not want our snapshot frames to be mixed in with the default snapshot frames
static const uint32 knHLTVSnapshotSet = CFrameSnapshotManager::knDefaultSnapshotSet + 1;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CHLTVServer *g_pHltvServer[ HLTV_SERVER_MAX_COUNT ] = { NULL, NULL };
bool IsHltvActive()
{
	CActiveHltvServerIterator hltv;
	if ( hltv )
		return true; // found at least one HLTV active
	else
		return false;
}

static void tv_title_changed_f( IConVar *var, const char *pOldString, float flOldValue )
{
	for ( CActiveHltvServerIterator hltv; hltv; hltv.Next() )
	{
		hltv->BroadcastLocalTitle();	// broadcast hltv_title to the respective clients of this HLTV server
	}
}

static void tv_name_changed_f( IConVar *var, const char *pOldValue, float flOldValue )
{
	Steam3Server().NotifyOfServerNameChange();
}

ConVar tv_maxclients( "tv_maxclients", "128", FCVAR_RELEASE, "Maximum client number on GOTV server.",
							  true, 0, true, 255 );
ConVar tv_maxclients_relayreserved( "tv_maxclients_relayreserved", "0", FCVAR_RELEASE, "Reserves a certain number of GOTV client slots for relays.",
	true, 0, true, 255 );

ConVar tv_autorecord( "tv_autorecord", "0", FCVAR_RELEASE, "Automatically records all games as GOTV demos." );
void OnTvBroadcast( IConVar *var, const char *pOldValue, float flOldValue );
ConVar tv_broadcast( "tv_broadcast", "0", FCVAR_RELEASE, "Automatically broadcasts all games as GOTV demos through Steam.", OnTvBroadcast );
ConVar tv_broadcast1( "tv_broadcast1", "0", FCVAR_RELEASE, "Automatically broadcasts all games as GOTV[1] demos through Steam.", OnTvBroadcast );
ConVar tv_name( "tv_name", "GOTV", FCVAR_RELEASE, "GOTV host name", tv_name_changed_f );
static ConVar tv_password( "tv_password", "", FCVAR_NOTIFY | FCVAR_PROTECTED | FCVAR_DONTRECORD | FCVAR_RELEASE, "GOTV password for all clients" );
static ConVar tv_advertise_watchable( "tv_advertise_watchable", "0", FCVAR_NOTIFY | FCVAR_PROTECTED | FCVAR_DONTRECORD | FCVAR_RELEASE, "GOTV advertises the match as watchable via game UI, clients watching via UI will not need to type password" );

static ConVar tv_overridemaster( "tv_overridemaster", "0", FCVAR_RELEASE, "Overrides the GOTV master root address." );
static ConVar tv_dispatchmode( "tv_dispatchmode", "1", FCVAR_RELEASE, "Dispatch clients to relay proxies: 0=never, 1=if appropriate, 2=always" );
static ConVar tv_dispatchweight( "tv_dispatchweight", "1.25", FCVAR_RELEASE, "Dispatch clients to relay proxies based on load, 1.25 will prefer for every 4 local clients to put 5 clients on every connected relay" );
ConVar tv_transmitall( "tv_transmitall", "1", FCVAR_REPLICATED | FCVAR_RELEASE, "Transmit all entities (not only director view)" );
ConVar tv_debug( "tv_debug", "0", FCVAR_RELEASE, "GOTV debug info." );
ConVar tv_title( "tv_title", "GOTV", FCVAR_RELEASE, "Set title for GOTV spectator UI", tv_title_changed_f );
static ConVar tv_deltacache( "tv_deltacache", "2", FCVAR_RELEASE, "Enable delta entity bit stream cache" );
static ConVar tv_relayvoice( "tv_relayvoice", "1", FCVAR_RELEASE, "Relay voice data: 0=off, 1=on" );
static ConVar tv_encryptdata_key( "tv_encryptdata_key", "", FCVAR_RELEASE, "When set to a valid key communication messages will be encrypted for GOTV" );
static ConVar tv_encryptdata_key_pub( "tv_encryptdata_key_pub", "", FCVAR_RELEASE, "When set to a valid key public communication messages will be encrypted for GOTV" );

static ConVar tv_window_size( "tv_window_size", "16.0", FCVAR_NONE, "Specifies the number of seconds worth of frames that the tv replay system should keep in memory. Increasing this greatly increases the amount of memory consumed by the TV system" );
static ConVar tv_enable_delta_frames( "tv_enable_delta_frames", "1", FCVAR_RELEASE, "Indicates whether or not the tv should use delta frames for storage of intermediate frames. This takes more CPU but significantly less memory." );
extern ConVar spec_replay_enable;
extern ConVar spec_replay_message_time;
ConVar	spec_replay_leadup_time( "spec_replay_leadup_time", "5.3438", FCVAR_RELEASE | FCVAR_REPLICATED, "Replay time in seconds before the highlighted event" );

ConVar tv_broadcast_url( "tv_broadcast_url", "http://localhost:8080", FCVAR_RELEASE, "URL of the broadcast relay" );


CHLTVServer::SHLTVDeltaFrame_t::SHLTVDeltaFrame_t() :
m_pRelativeFrame( NULL ),
	m_pSourceFrame( NULL ),
	m_pClientFrame( NULL ),
	m_nNumValidEntities( 0 ),
	m_nTotalEntities( 0 ),
	m_pEntities( NULL ),
	m_pNewerDeltaFrame( NULL )
{}

CHLTVServer::SHLTVDeltaFrame_t::~SHLTVDeltaFrame_t()
{
	delete [] m_pCopyEntities;
	m_pCopyEntities = NULL;

	//delete the client frame
	delete m_pClientFrame;
	m_pClientFrame = NULL;

	//delete our entity linked list
	while( m_pEntities )
	{
		SHLTVDeltaEntity_t* pDel = m_pEntities;
		m_pEntities = m_pEntities->m_pNext;
		delete pDel;
	}

	if( m_pRelativeFrame )
		m_pRelativeFrame->ReleaseReference();

	if( m_pSourceFrame )
		m_pSourceFrame->ReleaseReference();
}

CHLTVServer::SHLTVDeltaEntity_t::SHLTVDeltaEntity_t() :
	m_SerializedEntity( SERIALIZED_ENTITY_HANDLE_INVALID ),
	m_pServerClass( NULL ),
	m_pNewRecipients( NULL ),
	m_pNext( NULL )
{
}

CHLTVServer::SHLTVDeltaEntity_t::~SHLTVDeltaEntity_t()
{
	//free any recipients if we allocated them
	delete [] m_pNewRecipients;

	if( (m_SerializedEntity != knNoPackedData) && ( m_SerializedEntity != SERIALIZED_ENTITY_HANDLE_INVALID ) )
		delete ( CSerializedEntity* )m_SerializedEntity;
}


CDeltaEntityCache::CDeltaEntityCache()
{
	Q_memset( m_Cache, 0, sizeof(m_Cache) );
	m_nTick = 0;
	m_nMaxEntities = 0;
	m_nCacheSize = 0;
}

CDeltaEntityCache::~CDeltaEntityCache()
{
	Flush();
}

void CDeltaEntityCache::Flush()
{
	if ( m_nMaxEntities != 0 )
	{
		// at least one entity was set
		for ( int i=0; i<m_nMaxEntities; i++ )
		{
			if ( m_Cache[i] != NULL )
			{
				free( m_Cache[i] );
				m_Cache[i] = NULL;
			}
		}

		m_nMaxEntities = 0;
	}

	m_nCacheSize = 0;
}

void CDeltaEntityCache::SetTick( int nTick, int nMaxEntities )
{
	if ( nTick == m_nTick )
		return;

	Flush();

	m_nCacheSize = tv_deltacache.GetInt() * 1024;

	if ( m_nCacheSize <= 0 )
		return;

	m_nMaxEntities = MIN(nMaxEntities,MAX_EDICTS);
	m_nTick = nTick;
}

unsigned char* CDeltaEntityCache::FindDeltaBits( int nEntityIndex, int nDeltaTick, int &nBits )
{
	nBits = -1;
	
	if ( nEntityIndex < 0 || nEntityIndex >= 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 CDeltaEntityCache::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 CHLTVServer::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 CHLTVServer::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("HLTV_InitRecvTableMgr: failed to allocate client class %s.\n", pCur->m_pNetworkName );
			return;
		}
	}

	RecvTable_Init( m_pRecvTables, m_nRecvTables );
}



CHLTVFrame::CHLTVFrame()
{
	
}

CHLTVFrame::~CHLTVFrame()
{
	FreeBuffers();
}

void CHLTVFrame::Reset( void )
{
	for ( int i=0; i<HLTV_BUFFER_MAX; i++ )
	{
		m_Messages[i].Reset();
	}
}

bool CHLTVFrame::HasData( void )
{
	for ( int i=0; i<HLTV_BUFFER_MAX; i++ )
	{
		if ( m_Messages[i].GetNumBitsWritten() > 0 )
			return true;
	}

	return false;
}

void CHLTVFrame::CopyHLTVData( const CHLTVFrame &frame )
{
	// copy reliable messages
	int bits = frame.m_Messages[HLTV_BUFFER_RELIABLE].GetNumBitsWritten();

	if ( bits > 0 )
	{
		int bytes = PAD_NUMBER( Bits2Bytes(bits), 4 );
		m_Messages[HLTV_BUFFER_RELIABLE].StartWriting( new char[ bytes ], bytes, bits );
		Q_memcpy( m_Messages[HLTV_BUFFER_RELIABLE].GetData(), frame.m_Messages[HLTV_BUFFER_RELIABLE].GetData(), bytes );
	}

	// copy unreliable messages
	bits = frame.m_Messages[HLTV_BUFFER_UNRELIABLE].GetNumBitsWritten();
	bits += frame.m_Messages[HLTV_BUFFER_TEMPENTS].GetNumBitsWritten();
	bits += frame.m_Messages[HLTV_BUFFER_SOUNDS].GetNumBitsWritten();

	if ( bits > 0 )
	{
		// collapse all unreliable buffers in one
		int bytes = PAD_NUMBER( Bits2Bytes(bits), 4 );
		m_Messages[HLTV_BUFFER_UNRELIABLE].StartWriting( new char[ bytes ], bytes );
		m_Messages[HLTV_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[HLTV_BUFFER_UNRELIABLE].GetData(), frame.m_Messages[HLTV_BUFFER_UNRELIABLE].GetNumBitsWritten() ); 
		m_Messages[HLTV_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[HLTV_BUFFER_TEMPENTS].GetData(), frame.m_Messages[HLTV_BUFFER_TEMPENTS].GetNumBitsWritten() ); 
		m_Messages[HLTV_BUFFER_UNRELIABLE].WriteBits( frame.m_Messages[HLTV_BUFFER_SOUNDS].GetData(), frame.m_Messages[HLTV_BUFFER_SOUNDS].GetNumBitsWritten() ); 
	}

	if ( tv_relayvoice.GetBool() )
	{
		int nVoiceBits = frame.m_Messages[ HLTV_BUFFER_VOICE ].GetNumBitsWritten();
		if ( nVoiceBits > 0 )
		{
			int nVoiceBytes = PAD_NUMBER( Bits2Bytes( nVoiceBits ), 4 );
			m_Messages[ HLTV_BUFFER_VOICE ].StartWriting( new char[ nVoiceBytes ], nVoiceBytes );
			m_Messages[ HLTV_BUFFER_VOICE ].WriteBits( frame.m_Messages[ HLTV_BUFFER_VOICE ].GetData(), frame.m_Messages[ HLTV_BUFFER_VOICE ].GetNumBitsWritten() );
		}
	}
}


uint CHLTVFrame::GetMemSize()const
{
	uint nSize = sizeof( *this );
	for ( int i = 0; i < ARRAYSIZE( m_Messages ); ++i )
		nSize += m_Messages[ i ].GetMaxNumBits() / 8;
	return nSize;
}


void CHLTVFrame::AllocBuffers( void )
{
	// allocate buffers for input frame
	for ( int i=0; i < HLTV_BUFFER_MAX; i++ )
	{
		Assert( m_Messages[i].GetBasePointer() == NULL );
		m_Messages[i].StartWriting( new char[NET_MAX_PAYLOAD], NET_MAX_PAYLOAD);
	}
}

void CHLTVFrame::FreeBuffers( void )
{
	for ( int i=0; i<HLTV_BUFFER_MAX; i++ )
	{
		bf_write &msg = m_Messages[i];

		if ( msg.GetBasePointer() )
		{
			delete[] msg.GetBasePointer();
			msg.StartWriting( NULL, 0 );
		}
	}
}

CHLTVServer::CHLTVServer( uint nInstanceIndex, float flSnapshotRate )
	: m_DemoRecorder( this )
	, m_Broadcast( this )
	, m_ClientState( this )
	, m_nInstanceIndex( nInstanceIndex )
	, m_flSnapshotRate( flSnapshotRate )
{
	m_flTickInterval = 0.03;
	m_MasterClient = NULL;
	m_Server = NULL;
	m_Director = NULL;
	m_nFirstTick = -1;
	m_nLastTick = 0;
	m_CurrentFrame = NULL;
	m_nViewEntity = 0;
	m_nPlayerSlot = 0;
	m_bSignonState = false;
	m_flStartTime = 0;
	m_flFPS = 0;
	m_nGameServerMaxClients = 0;
	m_fNextSendUpdateTime = 0;
	Q_memset( m_pRecvTables, 0, sizeof( m_pRecvTables ) );
	m_nRecvTables = 0;
	m_vPVSOrigin.Init();
	m_nStartTick = 0;
	m_bPlayingBack = false;
	m_bPlaybackPaused = false;
	m_flPlaybackRateModifier = 0;
	m_nSkipToTick = 0;
	m_bMasterOnlyMode = false;
	Assert( m_ClientState.m_pHLTV == this ); // constructor of ClientState should've set thie HLTV. 
	m_nGlobalSlots = 0;
	m_nGlobalClients = 0;
	m_nGlobalProxies = 0;
	m_nExternalTotalViewers = 0;
	m_nExternalLinkedViewers = 0;

	m_nDebugID = EVENT_DEBUG_ID_INIT;

	m_pOldestDeltaFrame = NULL;
	m_pNewestDeltaFrame = NULL;

	m_pLastSourceSnapshot = NULL;
	m_pLastTargetSnapshot = NULL;
}

CHLTVServer::~CHLTVServer()
{
	m_nDebugID = EVENT_DEBUG_ID_SHUTDOWN;

	if ( m_nRecvTables > 0 )
	{
		RecvTable_Term();
		FreeClientRecvTables();
	}

	// make sure everything was destroyed
	Assert( m_CurrentFrame == NULL );
	Assert( CountClientFrames() == 0 );
}

void CHLTVServer::SetMaxClients( int number )
{
	// allow max clients 0 in HLTV
	m_nMaxclients = clamp( number, 0, ABSOLUTE_PLAYER_LIMIT );
}

void CHLTVServer::StartMaster(CGameClient *client)
{
	m_nExternalTotalViewers = 0;
	m_nExternalLinkedViewers = 0;
	Clear();  // clear old settings & buffers

	if ( !client )
	{
		ConMsg("GOTV client not found.\n");
		return;
	}

	m_Director = serverGameDirector;	

	if ( !m_Director )
	{
		ConMsg("Mod doesn't support GOTV. No director module found.\n");
		return;
	}

	m_MasterClient = client;
	m_MasterClient->m_bIsHLTV = true;
	m_MasterClient->m_pHltvSlaveServer = this;  // Master client needs to know which server (with which tickrate) it's sending packets
#if defined( REPLAY_ENABLED )
	m_MasterClient->m_bIsReplay = false;
#endif
	// let game.dll know that we are the HLTV client
	Assert( serverGameClients );

	CPlayerState *player = serverGameClients->GetPlayerState( m_MasterClient->edict );
	player->hltv = true;

	m_Server = (CGameServer*)m_MasterClient->GetServer();

	// set default user settings
	m_MasterClient->m_ConVars->SetString( "name", tv_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", va( "%f", GetSnapshotRate() ) ); // this may not be necessary...
	m_MasterClient->m_ConVars->SetString( "cl_cmdrate", "64" );
	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_HLTVFrame.AllocBuffers();
			
	InstallStringTables();

	// activate director in game.dll
	m_Director->AddHLTVServer( this ); // we RemoveHLTVServer later instead of setting it to NULL now

	// 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("CHLTVServer::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 HLTV 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
		tv_maxclients.SetValue( MIN(1,tv_maxclients.GetInt()) );
	}

	SetMaxClients( tv_maxclients.GetInt() );

	m_bSignonState = false; //master proxy is instantly connected

	m_nSpawnCount++;

	m_flStartTime = net_time;

	m_State = ss_active;

	// stop any previous recordings
	StopRecording();

	// start new recording if autorecord is enabled
	if ( tv_autorecord.GetBool() )
	{
		m_DemoRecorder.StartAutoRecording();
	}
	m_Broadcast.OnMasterStarted();
	if ( GetIndexedConVar( tv_broadcast, GetInstanceIndex() ).GetBool() )
	{
		StartBroadcast();
	}

	m_DemoEventWriteBuffer.StartWriting( m_DemoEventsBuffer, ARRAYSIZE( m_DemoEventsBuffer) );

	ReconnectClients();
}


void CHLTVServer::StartBroadcast()
{
	m_Broadcast.StartRecording( tv_broadcast_url.GetString() );
}

void CHLTVServer::StartDemo( const char *filename )
{

}

bool CHLTVServer::DispatchToRelay( CHLTVClient *pClient )
{
	if ( tv_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->IsHLTV() || (pClient == pProxy) )
			continue;

		int slots = Q_atoi( pProxy->GetUserSetting( "hltv_slots" ) );
		int clients = Q_atoi( pProxy->GetUserSetting( "hltv_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 ( tv_dispatchmode.GetInt() == DISPATCH_MODE_ALWAYS )
		{
			// we are in always forward mode, drop client if we can't forward it
			pClient->Disconnect("No GOTV relay available");
			return true;
		}
		else
		{
			// just let client connect to this proxy
			return false;
		}
	}

	// check if client should stay on this relay server unless we are the master,
	// masters always prefer to send clients to relays
	if ( (tv_dispatchmode.GetInt() == DISPATCH_MODE_AUTO) && (GetMaxClients() > 0) )
	{
		// ratio = clients/slots. give relay proxies 25% bonus
		int numSlots = GetMaxClients();
		if ( tv_maxclients_relayreserved.GetInt() > 0 )
			numSlots -= tv_maxclients_relayreserved.GetInt();
		numSlots = MAX( 0, numSlots );

		int numClients = GetNumClients();
		if ( numClients > numSlots )
			numSlots = numClients;

		float flDispatchWeight = tv_dispatchweight.GetFloat();
		if ( flDispatchWeight <= 1.01 )
			flDispatchWeight = 1.01;
		float myRatio = ((float)numClients/(float)numSlots) * flDispatchWeight;

		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("hltv_addr");

	if ( !pszRelayAddr )
		return false;
	

	ConMsg( "Redirecting spectator %s to GOTV relay %s\n", 
		pClient->GetNetChannel()->GetAddress(), 
		pszRelayAddr );

	// first tell that client that we are a SourceTV server,
	// otherwise it's might ignore the "connect" command
	CSVCMsg_ServerInfo_t serverInfo;
	FillServerInfo( serverInfo ); 
	serverInfo.set_is_redirecting_to_proxy_relay( true );
	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( "hltv_clients" ) );
	pBestProxy->SetUserCVar( "hltv_clients", va("%d", clients+1 ) );
	
	return true;
}

void CHLTVServer::ConnectRelay(const char *address)
{
	m_nExternalTotalViewers = 0;
	m_nExternalLinkedViewers = 0;

	if ( m_ClientState.IsConnected() )
	{
		// do not try to reconnect to old connection
		m_ClientState.m_Remote.RemoveAll();

		// disconnect first
		m_ClientState.Disconnect();

		Changelevel( true ); // inactivate clients
	}

	// connect to new server
	m_ClientState.Connect( address, address, "HLTVConnectRelay" );
}

void CHLTVServer::StartRelay()
{
	if ( !m_ClientState.IsConnected() && !IsPlayingBack() )
	{
		DevMsg("StartRelay: not connected.\n");
		Shutdown();
		return;
	}

	Clear();  // clear old settings & buffers

	if ( m_nRecvTables == 0 ) 
	{
		// must be done only once since Mod never changes
		InitClientRecvTables();
	}

	m_HLTVFrame.AllocBuffers();

	m_StringTables = &m_NetworkStringTables;
	
	SetMaxClients( tv_maxclients.GetInt() );

	m_bSignonState = true;

	m_flStartTime = net_time;

	m_State = ss_loading;

	m_nSpawnCount++;
}

int	CHLTVServer::GetHLTVSlot( void )
{
	return m_nPlayerSlot;
}

float CHLTVServer::GetOnlineTime( void )
{
	return MAX(0, net_time - m_flStartTime);
}

void CHLTVServer::GetLocalStats( int &proxies, int &slots, int &clients )
{
	int numSlots = GetMaxClients();
	if ( tv_maxclients_relayreserved.GetInt() > 0 )
		numSlots -= tv_maxclients_relayreserved.GetInt();
	numSlots = MAX( 0, numSlots );

	int numClients = GetNumClients();
	if ( numClients > numSlots )
		numSlots = numClients;

	proxies = GetNumProxies();
	clients = numClients;
	slots = numSlots;
}

void CHLTVServer::GetRelayStats( int &proxies, int &slots, int &clients )
{
	proxies = slots = clients = 0;

	for (int i=0 ; i < GetClientCount() ; i++ )
	{
		CBaseClient *client = m_Clients[ i ];

		if ( !client->IsConnected() || !client->IsHLTV() )
			continue;

		proxies += Q_atoi( client->GetUserSetting( "hltv_proxies" ) );
		slots += Q_atoi( client->GetUserSetting( "hltv_slots" ) );
		clients += Q_atoi( client->GetUserSetting( "hltv_clients" ) );
	}
}

void CHLTVServer::GetGlobalStats( int &proxies, int &slots, int &clients )
{
	// the master proxy is the only one that really has all data to generate
	// global stats
	if ( IsMasterProxy() )
	{
		GetRelayStats( m_nGlobalProxies, m_nGlobalSlots, m_nGlobalClients );

		int numSlots = GetMaxClients();
		if ( tv_maxclients_relayreserved.GetInt() > 0 )
			numSlots -= tv_maxclients_relayreserved.GetInt();
		numSlots = MAX( 0, numSlots );
		
		int numClients = GetNumClients();
		if ( !numClients && m_Broadcast.IsRecording() )
		{	// Always consider broadcast stream as a non-zero amount of clients
			numClients = 1;
		}

		if ( numClients > numSlots )
			numSlots = numClients;

		m_nGlobalSlots += numSlots;
		m_nGlobalClients += numClients;
	}

	// if this is a relay proxies, global data comes via the 
	// wire from the master proxy
	proxies = m_nGlobalProxies;
	slots = m_nGlobalSlots;
	clients = m_nGlobalClients;
}

void CHLTVServer::GetExternalStats( int &numExternalTotalViewers, int &numExternalLinkedViewers )
{
	numExternalTotalViewers = m_nExternalTotalViewers;
	numExternalLinkedViewers = m_nExternalLinkedViewers;
}

void CHLTVServer::UpdateHltvExternalViewers( uint32 numTotalViewers, uint32 numLinkedViewers )
{
	if ( !IsMasterProxy() )
		return;
	if ( !IsActive() )
		return;

	m_nExternalTotalViewers = numTotalViewers;
	m_nExternalLinkedViewers = numLinkedViewers;
}

const netadr_t *CHLTVServer::GetRelayAddress( void )
{
	if ( IsMasterProxy() )
	{
		return &net_local_adr; // TODO wrong port
	}
	else if ( m_ClientState.m_NetChannel )
	{
		const ns_address &adr = m_ClientState.m_NetChannel->GetRemoteAddress();
		if ( adr.IsType<netadr_t>() )
			return &adr.AsType<netadr_t>();
	}

	return NULL;
}

bool CHLTVServer::IsMasterProxy( void )
{
	return ( m_MasterClient != NULL );
}

bool CHLTVServer::IsTVRelay()
{
	return !IsMasterProxy();
}

bool CHLTVServer::IsDemoPlayback( void )
{
	return false;
}

void CHLTVServer::BroadcastLocalTitle( CHLTVClient *client ) 
{
	IGameEvent *event = g_GameEventManager.CreateEvent( "hltv_title", true );

	if ( !event )
		return;

	event->SetString( "text", tv_title.GetString() );

	CSVCMsg_GameEvent_t eventMsg;

	eventMsg.SetReliable( true );

	// create bit stream from KeyValues
	if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) )
	{
		DevMsg("CHLTVServer: 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->IsHLTV() )
				continue;

			client->SendNetMsg( eventMsg );
		}
	}

	g_GameEventManager.FreeEvent( event );
}

void CHLTVServer::BroadcastLocalChat( const char *pszChat, const char *pszGroup )
{
	IGameEvent *event = g_GameEventManager.CreateEvent( "hltv_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("CHLTVServer: failed to serialize chat '%s'.\n", event->GetName() );
		g_GameEventManager.FreeEvent( event );
		return;
	}

	for ( int i = 0; i < m_Clients.Count(); i++ )
	{
		CHLTVClient *cl = Client(i);

		if ( !cl->IsActive() || !cl->IsSpawned() || cl->IsHLTV() )
			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 CHLTVServer::BroadcastEventLocal( IGameEvent *event, bool bReliable )
{
	CSVCMsg_GameEvent_t eventMsg;

	eventMsg.SetReliable( bReliable );

	// create bit stream from KeyValues
	if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) )
	{
		DevMsg("CHLTVServer: failed to serialize local event '%s'.\n", event->GetName() );
		return;
	}

	for ( int i = 0; i < m_Clients.Count(); i++ )
	{
		CHLTVClient *cl = Client(i);

		if ( !cl->IsActive() || !cl->IsSpawned() || cl->IsHLTV() )
			continue;

		if ( !cl->SendNetMsg( eventMsg ) )
		{
			if ( eventMsg.IsReliable() )
			{
				DevMsg( "BroadcastMessage: Reliable broadcast message overflow for client %s", cl->GetClientName() );
			}
		}
	}

	if ( tv_debug.GetBool() )
		Msg("SourceTV broadcast local event: %s\n", event->GetName() );
}

void CHLTVServer::BroadcastEvent(IGameEvent *event)
{
	CSVCMsg_GameEvent_t eventMsg;

	// create bit stream from KeyValues
	if ( !g_GameEventManager.SerializeEvent( event, &eventMsg ) )
	{
		DevMsg("CHLTVServer: failed to serialize event '%s'.\n", event->GetName() );
		return;
	}

	BroadcastMessage( eventMsg, true, true );

	if ( m_DemoRecorder.IsRecording() || m_Broadcast.IsRecording() )
	{
		eventMsg.WriteToBuffer( m_DemoEventWriteBuffer );
	}

	if ( tv_debug.GetBool() )
		Msg("SourceTV broadcast event: %s\n", event->GetName() );
}
 
bool CHLTVServer::IsRecording()
{
	return m_DemoRecorder.IsRecording();
}

const char* CHLTVServer::GetRecordingDemoFilename()
{
	return m_DemoRecorder.GetDemoFilename();
}

void CHLTVServer::StartAutoRecording()
{
	return m_DemoRecorder.StartAutoRecording();
}

void CHLTVServer::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("CHLTVServer::FireGameEvent: failed to serialize event '%s'.\n", event->GetName() );
	}
}

int CHLTVServer::GetEventDebugID( void )
{
	return m_nDebugID;
}

//Whenever we're done recording a demo, go through all the remaining frames and write them too.
//This is done because now the demo recorded is recuring the CURRENT frame instead of the broadcast frame
void CHLTVServer::StopRecordingAndFreeFrames( bool bFreeFrames, const CGameInfo *pGameInfo)
{
	// We are only stopping demo recorder. Broadcast does not stop on changelevel, for example. If broadcast is activated, it stays activated until stopped.
	if( !m_CurrentFrame || !m_DemoRecorder.IsRecording() )
	{
		//we aren't recording, just clean up if requested
		if( bFreeFrames )
		{
			DeleteClientFrames( -1 );
			FreeAllDeltaFrames();
			m_CurrentFrame = NULL;
		}

		return;
	}

	int nStartingTick = m_CurrentFrame->tick_count;
	CHLTVFrame *pFrame = static_cast< CHLTVFrame *> (m_CurrentFrame->m_pNext );

	//clear our current frame since we are flushing all of our frames
	if( bFreeFrames )
		m_CurrentFrame = NULL;

	//flush any remaining current frames that we have
	while ( pFrame )
	{
		// restore string tables for this time
		int nFrameTick = pFrame->tick_count;
		RestoreTick( pFrame->tick_count );
		m_DemoRecorder.WriteFrame( pFrame );
		pFrame = static_cast< CHLTVFrame *> (pFrame->m_pNext );

		//and clean up the memory for this frame if we need to
		if( bFreeFrames )
			DeleteClientFrames( nFrameTick );
	}

	//now we need to handle the delta frames, freeing as we go to avoid a memory explosion
	while( m_pOldestDeltaFrame )
	{
		CHLTVFrame* pExpandedFrame = m_pOldestDeltaFrame->m_pClientFrame;
		int nExpandFrameTick = pExpandedFrame->tick_count;

		ExpandDeltaFramesToTick( nExpandFrameTick );
		RestoreTick( nExpandFrameTick );
		m_DemoRecorder.WriteFrame( pExpandedFrame );

		//and clean up the memory for this frame if we need to
		if( bFreeFrames )
			DeleteClientFrames( nExpandFrameTick );
	}

	// restore our string tables to what they were to begin with
	RestoreTick( nStartingTick );

	return m_DemoRecorder.StopRecording( pGameInfo );
}

bool CHLTVServer::ShouldUpdateMasterServer()
{
	// If the main game server is active, then we let it update Steam with the server info.
	return !sv.IsActive();
}

CBaseClient *CHLTVServer::CreateNewClient(int slot )
{
	return new CHLTVClient( slot, this );
}

void CHLTVServer::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 hltv needs to keep a list of changes for all table items
	m_StringTables->EnableRollback( true );

	for ( int i =0; i<numTables; i++)
	{
		// iterate through server tables
		CNetworkStringTable *serverTable = 
			(CNetworkStringTable*)m_Server->m_StringTables->GetTable( i );

		if ( !serverTable )
			continue;

		// get matching client table
		CNetworkStringTable *hltvTable = 
			(CNetworkStringTable*)m_StringTables->CreateStringTable(
				serverTable->GetTableName(),
				serverTable->GetMaxStrings(),
				serverTable->GetUserDataSize(),
				serverTable->GetUserDataSizeBits(),
				serverTable->IsUsingDictionary() ? NSF_DICTIONARY_ENABLED : NSF_NONE
				);

		if ( !hltvTable )
		{
			DevMsg("SV_InstallHLTVStringTableMirrors! Missing client table \"%s\".\n ", serverTable->GetTableName() );
			continue;
		}

		// make hltv table an exact copy of server table
		hltvTable->CopyStringTable( serverTable ); 

		// link hltv table to server table
		serverTable->SetMirrorTable( m_nInstanceIndex, hltvTable ); // there may be multiple mirror tables (up to the number of HLTV servers), it's easier to manage than removing the mirror tables from the correct places at the correct times
	}

	m_StringTables->AllowCreation( false );

#endif
}

void CHLTVServer::UninstallStringTables( void )
{
	if ( !m_Server )
		return;
	int numTables = m_Server->m_StringTables->GetNumTables();

	for ( int i = 0; i < numTables; i++ )
	{
		// iterate through server tables
		CNetworkStringTable *serverTable =
			( CNetworkStringTable* )m_Server->m_StringTables->GetTable( i );

		if ( !serverTable )
			continue;

		serverTable->SetMirrorTable( m_nInstanceIndex, NULL ); // alternatively, we could find serverTable again and remove mirror table by pointer. It would be a bit more fragile and slower.
	}
}

void CHLTVServer::RestoreTick( int tick )
{
#ifndef SHARED_NET_STRING_TABLES

	// only master proxy delays time
	if ( !IsMasterProxy() )
		return;

	int numTables = m_StringTables->GetNumTables();

	for ( int i =0; i<numTables; i++)
	{
			// iterate through server tables
		CNetworkStringTable *pTable = (CNetworkStringTable*) m_StringTables->GetTable( i );
		pTable->RestoreTick( tick );
	}

#endif
}

void CHLTVServer::UserInfoChanged( int nClientIndex )
{
	// don't change UserInfo table, it keeps the infos of the original players
}

bool CHLTVServer::GetClassBaseline( ServerClass *pClass, SerializedEntityHandle_t *pHandle)
{
	// if we are the master proxy the game server has our baseline data
	if ( m_Server )
	{
		return m_Server->GetClassBaseline( pClass, pHandle );
	}

	// otherwise we have it from the hltvclientstate
	return m_ClientState.GetClassBaseline( pClass->m_ClassID, pHandle );
}

void CHLTVServer::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;
		}
	}
}

/* CHLTVServer::GetOriginFromPackedEntity is such a bad, bad hack.

extern float DecodeFloat(SendProp const *pProp, bf_read *pIn);

Vector CHLTVServer::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;
} */

CHLTVEntityData *FindHLTVDataInSnapshot( 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_pHLTVEntityData[m];
		
		if ( iEntIndex > index )
		{
			if ( pSnapshot->m_pValidEntities[z] == iEntIndex )
				return &pSnapshot->m_pHLTVEntityData[z];

			if ( a == m )
				return NULL;

			a = m;
		}
		else
		{
			if ( pSnapshot->m_pValidEntities[a] == iEntIndex )
				return &pSnapshot->m_pHLTVEntityData[a];

			if ( z == m )
				return NULL;

			z = m;
		}
	}

	return NULL;
}

void CHLTVServer::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_pHLTVEntityData != NULL );

	int nDirectorEntity = m_Director->GetPVSEntity();
    	
	if ( pSnapshot && nDirectorEntity > 0 )
	{
		CHLTVEntityData *pHLTVData = FindHLTVDataInSnapshot( pSnapshot, nDirectorEntity );

		if ( pHLTVData )
		{
			m_vPVSOrigin.x = pHLTVData->origin[0];
			m_vPVSOrigin.y = pHLTVData->origin[1];
			m_vPVSOrigin.z = pHLTVData->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;
		}

		CHLTVEntityData *pHLTVData = FindHLTVDataInSnapshot( pSnapshot, entindex );

		if ( !pHLTVData )
			continue;

		unsigned int nNodeCluster = pHLTVData->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 );
	}
}

void CHLTVServer::SignonComplete()
{
	Assert ( !IsMasterProxy() );
	
	m_bSignonState = false;

	LinkInstanceBaselines();

	if ( tv_debug.GetBool() )
		Msg("GOTV signon complete.\n" );
}

CFrameSnapshot* CHLTVServer::CloneDeltaSnapshot( const CFrameSnapshot *pCopySnapshot )
{
	//and create a new snapshot for this to reference, of which will not have entity data
	CFrameSnapshot* pNewSnapshot = framesnapshotmanager->CreateEmptySnapshot(
#ifdef DEBUG_SNAPSHOT_REFERENCES
		"CHLTVServer::CloneDeltaSnapshot",
#endif
		pCopySnapshot->m_nTickCount, 0, knHLTVSnapshotSet );

	//copy over snapshot data...
	pNewSnapshot->m_iExplicitDeleteSlots = pCopySnapshot->m_iExplicitDeleteSlots;
	pNewSnapshot->m_nTickCount = pCopySnapshot->m_nTickCount;

	//note that we do not copy over the valid entities list. We only copy over info for valid entities, so it is already properly collapsed, and we can save memory by ignoring this
	pNewSnapshot->m_pValidEntities = NULL;
	pNewSnapshot->m_nValidEntities = 0;

	//we don't need to copy over the events. The HLTV frame will actually copy over all the bits from the frame for the temporary entities, so we do not need to serialize this
	pNewSnapshot->m_nTempEntities = 0;
	pNewSnapshot->m_pTempEntities = NULL;

	return pNewSnapshot;
}

//the bit buffer assumes that all buffers it reads/writes are 4 byte aligned, which the serialized entity enforces, so this function given a number of bits, will ensure that the proper size
//in bytes for the buffer is met
static int GetBitBufBytes( int nNumBits )
{
	return ( ( nNumBits + 31 ) / 32) * 4;
}

//given a tick that the time changed on, and the current value along with the previous properties, this will determine which properties
//have changed, and create a serialized entity handle that contains just the delta properties
static SerializedEntityHandle_t CreateDeltaProperties( int nTick, const PackedEntity* pCurrPacked, const PackedEntity *pDeltaBase )
{
	//the actual max properties is HUGE, and we only need deltas, so to avoid blowing up the stack, we use a smaller buffer size
	static const int knMaxChangedProps = 4 * 1024;
	uint16 nChangedPropIndices[ knMaxChangedProps ];

	//get our source serialized entity data
	const CSerializedEntity* pCurrProps = ( const CSerializedEntity* )pCurrPacked->GetPackedData();

	//if we have no delta base to encode from, we just want the entire structure
	if( !pDeltaBase )
	{
		CSerializedEntity *pNewSerialized = new CSerializedEntity( );
		pNewSerialized->Copy( *pCurrProps );
		return ( SerializedEntityHandle_t )pNewSerialized;
	}

	//we have a delta, so lets build only the properties that vary based upon the tick time
	const int nNumProps = pCurrProps->GetFieldCount();

	//first pass, determine all the memory that we'll need for everything
	const CChangeFrameList *pChangeList = pCurrPacked->GetChangeFrameList();

	int nNumChangedProps = 0;
	int nChangedPropDataBits = 0;

	for( int nCurrProp = 0; nCurrProp < nNumProps; ++nCurrProp )
	{
		CFieldPath PropIndex = pCurrProps->GetFieldPath( nCurrProp );

		if( pChangeList->DidPropChangeAfterTick( nTick, PropIndex ) )
		{
			//this property changed, so add it into our list
			AssertMsg( nNumChangedProps < knMaxChangedProps, "Error: Overflow in modified properties for delta compression. This limit should be increased" );
			nChangedPropIndices[ nNumChangedProps ] = nCurrProp;
			nNumChangedProps++;
			nChangedPropDataBits += pCurrProps->GetFieldDataSizeInBits( nCurrProp );
		}
	}

	//if we have no changed properties, excellent, we can just bail and not have to spend memory
	if( nNumChangedProps == 0 )
		return SERIALIZED_ENTITY_HANDLE_INVALID;

	//we have changed props, so go ahead and allocate a buffer to hold the memory that we are going to setup
	CSerializedEntity *pNewSerialized = new CSerializedEntity( );
	pNewSerialized->SetupPackMemory( nNumChangedProps, nChangedPropDataBits );

	//setup the readers and writers
	bf_read SrcPropData;
	pCurrProps->StartReading( SrcPropData );
	bf_write OutPropData;
	pNewSerialized->StartWriting( OutPropData );

	//and now run through and copy over the data that we need
	for( int nOutputProp = 0; nOutputProp < nNumChangedProps; ++nOutputProp )
	{
		int nDataOffset, nNextOffset;
		CFieldPath PropIndex;
		pCurrProps->GetField( nChangedPropIndices[ nOutputProp ], PropIndex, &nDataOffset, &nNextOffset );

		//record this information in our buffer
		pNewSerialized->SetFieldPath( nOutputProp, PropIndex );
		pNewSerialized->SetFieldDataBitOffset( nOutputProp, OutPropData.GetNumBitsWritten() );

		//copy over the contents that we care about (which are bit aligned)
		SrcPropData.Seek( nDataOffset );
		OutPropData.WriteBitsFromBuffer( &SrcPropData, nNextOffset - nDataOffset );
	}

	//make sure our size calculations line up
	Assert( ( uint32 )OutPropData.GetNumBitsWritten() == pNewSerialized->GetFieldDataBitCount() );

	//we have our final property set now
	return ( SerializedEntityHandle_t )pNewSerialized;
}

//given a current and previous packed data, this will determine if the entity data changed, and if so, will setup the new recipient list with the appropraite information
static CSendProxyRecipients* CopyRecipientList( const PackedEntity* pCurrFramePacked, const PackedEntity* pPrevFramePacked )
{
	if( ( pPrevFramePacked != NULL ) && pCurrFramePacked->CompareRecipients( CUtlMemory< CSendProxyRecipients >( pPrevFramePacked->GetRecipients(), pPrevFramePacked->GetNumRecipients() ) ) )
	{
		//they match, so we don't need a delta buffer
		return NULL;
	}

	//if we got down here there is a mismatch, so just copy the new list
	const int nCurrRecipients = pCurrFramePacked->GetNumRecipients();
	CSendProxyRecipients* pCopyDest = new CSendProxyRecipients [ nCurrRecipients ];
	const CSendProxyRecipients* pCopySrc = pCurrFramePacked->GetRecipients();

	for( int nCopyRecipient = 0; nCopyRecipient < nCurrRecipients; ++nCopyRecipient )
		pCopyDest[ nCopyRecipient ] = pCopySrc[ nCopyRecipient ];

	return pCopyDest;
}

void CHLTVServer::CreateDeltaFrameEntities( SHLTVDeltaFrame_t *pOutputEntities, const CFrameSnapshot *pCurrFrame, const CFrameSnapshot *pPrevFrame )
{
	//determine how many ints we need to store our bit list
	const uint32 nNumCopyInts = ( pCurrFrame->m_nNumEntities + 31 ) / 32;

	//allocate memory for us to actually store the objects
	pOutputEntities->m_nTotalEntities		= pCurrFrame->m_nNumEntities;
	pOutputEntities->m_nNumValidEntities	= pCurrFrame->m_nValidEntities;
	pOutputEntities->m_pEntities			= NULL;
	pOutputEntities->m_pCopyEntities		= new uint32 [ nNumCopyInts ];
	memset( pOutputEntities->m_pCopyEntities, 0, sizeof(uint32) * nNumCopyInts );

	//the index into our current previous frame so that we can find old versions of the object to delta against
	const uint16 *pPrevEntityIndex		= ( pPrevFrame ) ? pPrevFrame->m_pValidEntities : NULL;
	const uint16 *pPrevEndEntityIndex	= ( pPrevFrame ) ? pPrevEntityIndex + pPrevFrame->m_nValidEntities : NULL;

	//the tick that we want to compare changes against
	int nChangeTick = ( pPrevFrame ) ? pPrevFrame->m_nTickCount : -1;

	//the current tail of our linked list
	SHLTVDeltaEntity_t** pListTail = &pOutputEntities->m_pEntities;

	//don't iterate through the entities, but instead iterate through our valid entity list, which indexes into our entities so we can
	//skip invalid entities
	for( int nValidEntity = 0; nValidEntity < pCurrFrame->m_nValidEntities; ++nValidEntity )
	{
		const int nEntityIndex					= pCurrFrame->m_pValidEntities[ nValidEntity ];
		const CFrameSnapshotEntry *pSrcEntity	= pCurrFrame->m_pEntities + nEntityIndex;

		//see if we can find a previous entity in order to diff ourself against
		bool bReuseOriginal = false;
		const PackedEntity* pPrevFramePacked = NULL;
		for( ; pPrevEntityIndex != pPrevEndEntityIndex; ++pPrevEntityIndex )
		{
			//see if our entity is higher than our current one, if so, we need to stop searching and let our current frame list catch up
			if( *pPrevEntityIndex > nEntityIndex )
				break;

			//if the slot matches, then we may have a match
			if( *pPrevEntityIndex == nEntityIndex )
			{
				const CFrameSnapshotEntry *pPrevEntity = &pPrevFrame->m_pEntities[ *pPrevEntityIndex ];

				//we found a match. See if it is actually the same object
				if( pPrevEntity->m_nSerialNumber == pSrcEntity->m_nSerialNumber )
				{
					//same object, so we can reuse the data, but first see if it is identical
					if( pPrevEntity->m_pPackedData == pSrcEntity->m_pPackedData )
					{
						//it is identical, we can just reuse it
						bReuseOriginal = true;
					}
					else
					{
						//different, so cache the data
						pPrevFramePacked = framesnapshotmanager->GetPackedEntity( *( const_cast< CFrameSnapshot* >(pPrevFrame) ), nEntityIndex );
					}
				}

				break;
			}
		}

		//first off, see if this is an entity that hasn't changed at all
		if( bReuseOriginal )
		{
			//this is the same entity, so just copy it forward
			pOutputEntities->m_pCopyEntities[ nEntityIndex / 32 ] |= ( 1 << ( nEntityIndex % 32 ) );			
			//skip the normal handling
			continue;
		}

		//allocate our new entity and add it to our list
		SHLTVDeltaEntity_t *pOutEntity			= new SHLTVDeltaEntity_t;
		*pListTail = pOutEntity;
		pListTail = &pOutEntity->m_pNext;

		//copy over all the state we can from this entity
		pOutEntity->m_nSerialNumber = pSrcEntity->m_nSerialNumber;
		pOutEntity->m_pServerClass	= pSrcEntity->m_pClass;
		pOutEntity->m_nSourceIndex	= nEntityIndex;

		//handle the situation where there is no packed data (occurs occasionally)
		if( pSrcEntity->m_pPackedData == INVALID_PACKED_ENTITY_HANDLE )
		{
			pOutEntity->m_SerializedEntity = SHLTVDeltaEntity_t::knNoPackedData;
		}
		else
		{
			//along with the data from the packed portion of the entity
			const PackedEntity *pSrcPacked = framesnapshotmanager->GetPackedEntity( *( const_cast< CFrameSnapshot* >(pCurrFrame) ), nEntityIndex );

			//this is a new packed entity that we'll need to construct on the other side
			pOutEntity->m_nSnapshotCreationTick		= pSrcPacked->GetSnapshotCreationTick( );

			//build up the property list for this based upon how we want to encode it (absolute, relative, etc)
			pOutEntity->m_SerializedEntity = CreateDeltaProperties( nChangeTick, pSrcPacked, pPrevFramePacked );

			//update our recipient list
			pOutEntity->m_nNumRecipients = ( uint16 )pSrcPacked->GetNumRecipients();
			pOutEntity->m_pNewRecipients = CopyRecipientList( pSrcPacked, pPrevFramePacked );
		}
	}
}

void CHLTVServer::AddNewDeltaFrame( CClientFrame *pClientFrame )
{
	//see if this support is disabled
	if( !tv_enable_delta_frames.GetBool() 
#if HLTV_REPLAY_ENABLED
		|| spec_replay_enable.GetBool() // <sergiy> delta frames with small delay make no sense because we'll effectively only compress a second or two ( the min delay )of the packets. Enabling replay means the first 20 seconds of frames must be decompressed. Maybe we'll implement compression between 20 and 100 seconds for competitive sometimes, but for now it seems ok to leave frames uncompressed if we want replay
#endif
		)
	{
		//we aren't running delta frames, so make sure we decompress any we might currently have, and fall back to normal
		ExpandDeltaFramesToTick( -1 );
		AddNewFrame( pClientFrame );
		return;
	}

	//track the performance of this frame
	VPROF_BUDGET( "CHLTVServer::AddNewDeltaFrame", "HLTV" );
	Assert( pClientFrame->tick_count > m_nLastTick );

	//if we don't have any frames encoded, we will be doing an absolute encode, so we can just store the frame direct (saves a lot of time and allocations)
	if( m_pLastSourceSnapshot == NULL )
	{
		Assert( ( m_pLastTargetSnapshot == NULL ) && ( m_nFirstTick < 0 ) );

		//add the frame. This way it will be ready immediately, and we don't have to duplicate all of the setup work
		AddNewFrame( pClientFrame );

		//use this frame as our encoding relative frame, and our delta that we will build on later as well
		m_pLastSourceSnapshot = pClientFrame->GetSnapshot();
		m_pLastSourceSnapshot->AddReference();
		m_pLastTargetSnapshot = pClientFrame->GetSnapshot();
		m_pLastTargetSnapshot->AddReference();

		return;
	}

	//update internal state based upon the incoming frames (this should match AddNewFrame)
	m_nLastTick = pClientFrame->tick_count;
	m_HLTVFrame.SetSnapshot( pClientFrame->GetSnapshot() );
	m_HLTVFrame.tick_count = pClientFrame->tick_count;
	m_HLTVFrame.last_entity = pClientFrame->last_entity;
	m_HLTVFrame.transmit_entity = pClientFrame->transmit_entity;

	//first off allocate our holding frame and client information
	SHLTVDeltaFrame_t *pNewDeltaFrame = new SHLTVDeltaFrame_t;
	pNewDeltaFrame->m_pNewerDeltaFrame = NULL;
	pNewDeltaFrame->m_pRelativeFrame = NULL;

	//Uncomment these lines if you want to enable validation support
	{
		//pNewDeltaFrame->m_pSourceFrame = pClientFrame->GetSnapshot();
		//pNewDeltaFrame->m_pSourceFrame->AddReference();
	}

	//if we have a previously encoded frame, we want to use that as our relative baseline
	if( m_pLastTargetSnapshot )
	{
		pNewDeltaFrame->m_pRelativeFrame = m_pLastTargetSnapshot;
		pNewDeltaFrame->m_pRelativeFrame->AddReference();
	}

	//create our new frame and copy all the data over
	pNewDeltaFrame->m_pClientFrame = new CHLTVFrame( );
	pNewDeltaFrame->m_pClientFrame->CopyFrame( *pClientFrame );
	pNewDeltaFrame->m_pClientFrame->CopyHLTVData( m_HLTVFrame );

	//create a copy of the snapshot that we can work with
	CFrameSnapshot *pNewSnapshot = CloneDeltaSnapshot( pClientFrame->GetSnapshot() );

	//now we need to create our delta encoded objects
	CreateDeltaFrameEntities( pNewDeltaFrame, pClientFrame->GetSnapshot(), m_pLastSourceSnapshot );

	//transfer ownership of this snapshot over to the client frame (meaning we don't need our reference)
	pNewDeltaFrame->m_pClientFrame->SetSnapshot(pNewSnapshot);
	pNewSnapshot->ReleaseReference();

	//link ourself into the list and make sure the newest link matches
	if( m_pNewestDeltaFrame )
		m_pNewestDeltaFrame->m_pNewerDeltaFrame = pNewDeltaFrame;
	m_pNewestDeltaFrame = pNewDeltaFrame;
	//and if our list was empty, our new frame is now also the oldest
	if( !m_pOldestDeltaFrame )
		m_pOldestDeltaFrame = pNewDeltaFrame;

	// reset HLTV frame for recording next messages etc.
	m_HLTVFrame.Reset();
	m_HLTVFrame.SetSnapshot( NULL );

	//update our references to point to our latest snapshots for subsequent encodes/decodes
	if( m_pLastSourceSnapshot )
		m_pLastSourceSnapshot->ReleaseReference();
	if( m_pLastTargetSnapshot )
		m_pLastTargetSnapshot->ReleaseReference();

	m_pLastSourceSnapshot = pClientFrame->GetSnapshot();
	m_pLastSourceSnapshot->AddReference();
	m_pLastTargetSnapshot = pNewSnapshot;
	m_pLastTargetSnapshot->AddReference();
}

//given a baseline property list and a delta from that, this will expand the delta serialized entity to contain a full property set
static void BuildMergedPropertySet( CSerializedEntity* pDelta, const CSerializedEntity* pBase, CChangeFrameList* pChangeTimes, int nChangeTick )
{
	int nDataBlockSizeBits = pBase->GetFieldDataBitCount();
	const int nNumFields = pBase->GetFieldCount();

	//see if we can take an optimized path where we can memcpy over our baseline and just overlay
	bool bCanMemCpySrc = true;

	{
		int nOverrideIndex = 0;
		CFieldPath NextOverridePath = pDelta->GetFieldPath( 0 );

		for( int nCurrField = 0; nCurrField < nNumFields; ++nCurrField )
		{
			//see if this is overridden
			CFieldPath FieldPath= pBase->GetFieldPath( nCurrField );
			if( FieldPath == NextOverridePath )
			{
				//we have a property change that we are applying, so update the change tick time
				pChangeTimes->SetChangeTick( FieldPath, nChangeTick );

				//use our modified size, minus our base size to determine the change in size from this override
				int nBaseSize = pBase->GetFieldDataSizeInBits( nCurrField );
				int nModifiedSize = pDelta->GetFieldDataSizeInBits( nOverrideIndex );

				//see if this has changed the layout to the point where we have to re lay out the base fields
				if( nModifiedSize != nBaseSize )
				{
					bCanMemCpySrc = false;
					nDataBlockSizeBits += ( nModifiedSize - nBaseSize );
				}

				//and advance to our next override
				nOverrideIndex++;
				if( nOverrideIndex < pDelta->GetFieldCount( ) )
					NextOverridePath = pDelta->GetFieldPath( nOverrideIndex );
			}		
		}
	}

	//create a stack entity to take the new merged results
	CSerializedEntity Merged;
	Merged.SetupPackMemory( nNumFields, nDataBlockSizeBits );

	if(bCanMemCpySrc)
	{
		memcpy( Merged.GetFieldData(), pBase->GetFieldData(), Bits2Bytes( pBase->GetFieldDataBitCount() ) );
	}

	//now merge
	{
		//setup the readers and writers
		bf_read BaseData, ModifiedData;
		pBase->StartReading( BaseData);
		pDelta->StartReading( ModifiedData );
		bf_write OutPropData;
		Merged.StartWriting( OutPropData );

		int nOverrideIndex = 0;
		CFieldPath NextOverridePath = pDelta->GetFieldPath( 0 );

		for( int nCurrField = 0; nCurrField < nNumFields; ++nCurrField )
		{
			//see if this is overridden
			CFieldPath FieldPath = pBase->GetFieldPath( nCurrField );

			//update our storage info
			Merged.SetFieldPath( nCurrField, FieldPath );
			Merged.SetFieldDataBitOffset( nCurrField, OutPropData.GetNumBitsWritten() );

			if( FieldPath == NextOverridePath )
			{				
				int nModifiedSize = pDelta->GetFieldDataSizeInBits( nOverrideIndex );
				OutPropData.WriteBitsFromBuffer( &ModifiedData, nModifiedSize );	

				//and advance to our next override
				nOverrideIndex++;
				if( nOverrideIndex < pDelta->GetFieldCount( ) )
					NextOverridePath = pDelta->GetFieldPath( nOverrideIndex );
			}	
			else
			{
				//use the baseline value
				int nDataStart	= pBase->GetFieldDataBitOffset( nCurrField );
				int nDataEnd	= pBase->GetFieldDataBitEndOffset( nCurrField );

				if( !bCanMemCpySrc )
				{
					BaseData.Seek( nDataStart );
					OutPropData.WriteBitsFromBuffer( &BaseData, nDataEnd - nDataStart );
				}
				else
				{
					OutPropData.SeekToBit( nDataEnd );
				}
			}			
		}
	}

	//now we can discard our results of the delta, and just use that object with the contents of our merged
	Merged.Swap( *pDelta );
}

static void CompareArray( int nOldElements, const void* pOldMem, int nNewElements, const void* pNewMem, int nElementSize )
{
	//to avoid warnings when asserts aren't disabled
#ifdef DBGFLAG_ASSERT

	Assert( nOldElements == nNewElements );

	int nNumBytes = nOldElements * nElementSize;
	const uint8* pByteOld		= ( const uint8* )pOldMem;
	const uint8* pByteNew		= ( const uint8* )pNewMem;

	//per byte check so it is more apparent where things went wrong
	for( int nCurrByte = 0; nCurrByte < nNumBytes; ++nCurrByte )
	{
		Assert( pByteOld[ nCurrByte ] == pByteNew[ nCurrByte ] );
	}

#endif
}

//development utility to take two snapshots and compare them for equivalence. This is used to test whether or not the new snapshot matches the original one that was the basis for compression
static void CompareSnapshot( const CFrameSnapshot* pOldSnapshot, const CFrameSnapshot* pNewSnapshot, int nChangePropTick )
{
	//to avoid warnings when asserts aren't disabled
#ifdef DBGFLAG_ASSERT

	//first off compare the valid entity list
	CompareArray( pOldSnapshot->m_nValidEntities, pOldSnapshot->m_pValidEntities, pNewSnapshot->m_nValidEntities, pNewSnapshot->m_pValidEntities, sizeof( uint16 ) );
	CompareArray( pOldSnapshot->m_iExplicitDeleteSlots.Count(), pOldSnapshot->m_iExplicitDeleteSlots.Base(), pNewSnapshot->m_iExplicitDeleteSlots.Count(), pNewSnapshot->m_iExplicitDeleteSlots.Base(), sizeof( int ) );

	//now each element
	for( int nCurrEntity = 0; nCurrEntity < pOldSnapshot->m_nValidEntities; ++nCurrEntity )
	{
		int nEntityIndex = pOldSnapshot->m_pValidEntities[ nCurrEntity ];

		//get info about each entity and compare
		const CFrameSnapshotEntry* pOldEntity = &pOldSnapshot->m_pEntities[ nEntityIndex ];
		const CFrameSnapshotEntry* pNewEntity = &pNewSnapshot->m_pEntities[ nEntityIndex ];

		Assert( pOldEntity->m_nSerialNumber == pNewEntity->m_nSerialNumber );
		Assert( pOldEntity->m_pClass == pNewEntity->m_pClass );
		Assert( ( pOldEntity->m_pPackedData != INVALID_PACKED_ENTITY_HANDLE ) == ( pNewEntity->m_pPackedData != INVALID_PACKED_ENTITY_HANDLE ) );

		//now check the packed data if applicable
		if( pOldEntity->m_pPackedData )
		{
			const PackedEntity* pOldPacked = framesnapshotmanager->GetPackedEntity( *( const_cast< CFrameSnapshot* >(pOldSnapshot) ), nEntityIndex );
			const PackedEntity* pNewPacked = framesnapshotmanager->GetPackedEntity( *( const_cast< CFrameSnapshot* >(pNewSnapshot) ), nEntityIndex );

			Assert( pOldPacked->m_nEntityIndex == pNewPacked->m_nEntityIndex );
			Assert( pOldPacked->GetSnapshotCreationTick() == pNewPacked->GetSnapshotCreationTick() );
			Assert( pOldPacked->ShouldCheckCreationTick() == pNewPacked->ShouldCheckCreationTick() );
			Assert( pOldPacked->m_pServerClass == pNewPacked->m_pServerClass );
			Assert( pOldPacked->m_pClientClass == pNewPacked->m_pClientClass );

			//compare the recipients
			CompareArray( pOldPacked->GetNumRecipients(), pOldPacked->GetRecipients(), pNewPacked->GetNumRecipients(), pNewPacked->GetRecipients(), sizeof( CSendProxyRecipients ) );

			//compare the change list
			{
				int nNumProps = pOldPacked->GetChangeFrameList()->GetNumProps();
				for( int nCurrProp = 0; nCurrProp < nNumProps; ++nCurrProp )
				{
					//see if this is a property that should have changed this frame (we have to do this since we lose some precision on the change flags during reconstruction)
					if( pOldPacked->GetChangeFrameList()->GetPropTick( nCurrProp ) >= nChangePropTick )
					{
						Assert( pNewPacked->GetChangeFrameList()->GetPropTick( nCurrProp ) >= nChangePropTick );
					}
				}
			}

			//now compare properties
			Assert( ( pOldPacked->GetPackedData() == SERIALIZED_ENTITY_HANDLE_INVALID ) == ( pNewPacked->GetPackedData() == SERIALIZED_ENTITY_HANDLE_INVALID ) );
			if( pOldPacked->GetPackedData() != SERIALIZED_ENTITY_HANDLE_INVALID )
			{
				const CSerializedEntity* pOldProps = ( const CSerializedEntity* )pOldPacked->GetPackedData();
				const CSerializedEntity* pNewProps = ( const CSerializedEntity* )pNewPacked->GetPackedData();

				CompareArray( pOldProps->GetFieldCount(), pOldProps->GetFieldPaths(), pNewProps->GetFieldCount(), pNewProps->GetFieldPaths(), sizeof( short ) );
				CompareArray( pOldProps->GetFieldCount(), pOldProps->GetFieldDataBitOffsets(), pNewProps->GetFieldCount(), pNewProps->GetFieldDataBitOffsets(), sizeof( int ) );
				CompareArray( pOldProps->GetFieldDataBitCount() / 8, pOldProps->GetFieldData(), pNewProps->GetFieldDataBitCount() / 8, pNewProps->GetFieldData(), sizeof( uint8 ) );
			}
		}
	}
#endif
}


size_t CHLTVServer::SHLTVDeltaFrame_t::GetMemSize()const
{
	uint nSize = sizeof( *this );
	if ( CFrameSnapshot *pSnapshot = m_pClientFrame->GetSnapshot() )
	{
		nSize += pSnapshot->GetMemSize();
	}
	return nSize;
}

size_t CFrameSnapshot::GetMemSize()const
{
	size_t nSize = sizeof( *this );
	nSize += m_nNumEntities * sizeof( CFrameSnapshotEntry ) + m_nValidEntities * sizeof( *m_pValidEntities );
	return nSize;
}

void CHLTVServer::ExpandDeltaFrameToFullFrame( SHLTVDeltaFrame_t *pDeltaFrame )
{
	//track the performance of this frame
	VPROF_BUDGET( "CHLTVServer::ExpandDeltaFrameToFullFrame", "HLTV" );

	CFrameSnapshot *pSnapshot = pDeltaFrame->m_pClientFrame->GetSnapshot();

	//we need to construct our full entity list in our snapshot
	pSnapshot->m_pEntities		= new CFrameSnapshotEntry[ pDeltaFrame->m_nTotalEntities ];
	pSnapshot->m_nNumEntities	= pDeltaFrame->m_nTotalEntities;

	//and create our valid entity list, which is just a one to one index map
	pSnapshot->m_pValidEntities = new uint16 [ pDeltaFrame->m_nNumValidEntities ];
	pSnapshot->m_nValidEntities = pDeltaFrame->m_nNumValidEntities;

	//the index into our current previous frame so that we can find old versions of the object to delta against
	const CFrameSnapshot* pPrevFrame	= pDeltaFrame->m_pRelativeFrame;
	const uint32 nPrevFrameEntities		= ( pPrevFrame ) ? pPrevFrame->m_nNumEntities : 0;

	//the time tick that we should use for all of our change flags. Since the HLTV server can skip frames, be conservative in our change
	//tick settings and use the frame after our last frame if we have one (effectively collapsing change times backwards), and if not, just our current tick count
	const int nChangePropTick = ( pPrevFrame ) ? pPrevFrame->m_nTickCount + 1 : pSnapshot->m_nTickCount;

	//the bit list that indicates which entities to just copy forward
	const uint32* RESTRICT pCopyEntities		= pDeltaFrame->m_pCopyEntities;
	const uint32 nTotalEntities					= pDeltaFrame->m_nTotalEntities;

	SHLTVDeltaEntity_t *pCurrDeltaEntity	= pDeltaFrame->m_pEntities;
	uint16* RESTRICT pCurrOutValidEntity	= pSnapshot->m_pValidEntities;

	//run through each of our valid entities
	for( uint32 nCurrEntity = 0; nCurrEntity < nTotalEntities; ++nCurrEntity )
	{
		CFrameSnapshotEntry *pCurrEntity	= pSnapshot->m_pEntities + nCurrEntity;

		//see if we just need to copy this forward
		if( pCopyEntities[ nCurrEntity / 32 ] & ( 1 << ( nCurrEntity % 32 ) ) )
		{
			const CFrameSnapshotEntry *pPrevEntity = &pPrevFrame->m_pEntities[ nCurrEntity ];

			//all we need to do is copy the previous to the current
			pCurrEntity->m_nSerialNumber	= pPrevEntity->m_nSerialNumber;
			pCurrEntity->m_pClass			= pPrevEntity->m_pClass;
			pCurrEntity->m_pPackedData		= pPrevEntity->m_pPackedData;

			//and make sure to reference our packed data so it won't go away on us
			if( pCurrEntity->m_pPackedData != INVALID_PACKED_ENTITY_HANDLE )
			{
				PackedEntity* pPacked = framesnapshotmanager->GetPackedEntity( pCurrEntity->m_pPackedData );
				pPacked->m_ReferenceCount++;
			}

			//and add this entity to the valid entity list
			*pCurrOutValidEntity = ( uint16 )nCurrEntity;
			pCurrOutValidEntity++;			
		}
		//otherwise, see if it is our delta entity that we encoded
		else if( pCurrDeltaEntity && ( nCurrEntity == pCurrDeltaEntity->m_nSourceIndex ) )
		{
			//we have matched this delta entity, so move onto the next
			SHLTVDeltaEntity_t* pDeltaEntity = pCurrDeltaEntity;
			pCurrDeltaEntity = pCurrDeltaEntity->m_pNext;

			//setup our valid list to index into this slot
			*pCurrOutValidEntity = ( uint16 )nCurrEntity;
			pCurrOutValidEntity++;

			//copy over the raw data
			pCurrEntity->m_nSerialNumber	= pDeltaEntity->m_nSerialNumber;
			pCurrEntity->m_pClass			= pDeltaEntity->m_pServerClass;
			pCurrEntity->m_pPackedData		= INVALID_PACKED_ENTITY_HANDLE;

			//see if there is no packed data associated with this class
			if( pDeltaEntity->m_SerializedEntity == SHLTVDeltaEntity_t::knNoPackedData )
				continue;

			//see if we can find a previous entity in order to diff ourself against
			PackedEntityHandle_t PrevPackedHandle = INVALID_PACKED_ENTITY_HANDLE;
			PackedEntity *pPrevPacked = NULL;

			if( nCurrEntity < nPrevFrameEntities )
			{
				const CFrameSnapshotEntry *pPrevEntity = &pPrevFrame->m_pEntities[ nCurrEntity ];
				if( ( pPrevEntity->m_nSerialNumber == pDeltaEntity->m_nSerialNumber ) &&  ( pPrevEntity->m_pClass == pDeltaEntity->m_pServerClass ) )
				{
					PrevPackedHandle	= pPrevEntity->m_pPackedData;
					if( PrevPackedHandle != INVALID_PACKED_ENTITY_HANDLE )
						pPrevPacked	= framesnapshotmanager->GetPackedEntity( PrevPackedHandle );
				}
			}

			//now the packed entity contents
			PackedEntity* pNewPacked = framesnapshotmanager->CreateLocalPackedEntity( pSnapshot, pDeltaEntity->m_nSourceIndex );

			pNewPacked->SetServerAndClientClass( pDeltaEntity->m_pServerClass, NULL );
			pNewPacked->SetSnapshotCreationTick( pDeltaEntity->m_nSnapshotCreationTick );		

			//update our entities (which we either have stored, or we need to take from the previous frame)
			if( pDeltaEntity->m_pNewRecipients )
			{
				pNewPacked->SetRecipients( CUtlMemory< CSendProxyRecipients >( pDeltaEntity->m_pNewRecipients, pDeltaEntity->m_nNumRecipients ) );
			}
			else if( pDeltaEntity->m_nNumRecipients > 0 )
			{
				//sanity check that they didn't change, and that we have valid frame of reference
				Assert( pPrevPacked && ( pPrevPacked->GetNumRecipients() == pDeltaEntity->m_nNumRecipients ) );
				pNewPacked->SetRecipients( CUtlMemory< CSendProxyRecipients >( pPrevPacked->GetRecipients(), pPrevPacked->GetNumRecipients() ) );
			}

			//and handle expanding out our serialized values. Either we can have a new object (just steal the properties), no changes (copy the original properties) or a diff
			//(merge the properties)
			if( !pPrevPacked )
			{
				//creation, so just use ours
				pNewPacked->SetPackedData( pDeltaEntity->m_SerializedEntity );
				pDeltaEntity->m_SerializedEntity = SERIALIZED_ENTITY_HANDLE_INVALID;
				//setup a change list for all of our possible properties that is set to our creation time
				CChangeFrameList* pChangeList = new CChangeFrameList( SendTable_GetNumFlatProps( pDeltaEntity->m_pServerClass->m_pTable ), pDeltaEntity->m_nSnapshotCreationTick );
				pNewPacked->SetChangeFrameList( pChangeList );
			}
			else
			{
				const CSerializedEntity* pPrevProps = ( const CSerializedEntity* )pPrevPacked->GetPackedData();

				//copy over our base change list so we can update the times that the properties changed
				CChangeFrameList* pChangeList = new CChangeFrameList( *pPrevPacked->GetChangeFrameList() );
				pNewPacked->SetChangeFrameList( pChangeList );

				//if we don't have a serialized entity, we can just copy our previous (much faster)
				if(pDeltaEntity->m_SerializedEntity == SERIALIZED_ENTITY_HANDLE_INVALID)
				{			
					CSerializedEntity* pNewProps = new CSerializedEntity( );
					pNewProps->Copy( *pPrevProps );
					pNewPacked->SetPackedData( ( SerializedEntityHandle_t )pNewProps );
				}
				else
				{
					//we have to merge our new values onto our old ones
					CSerializedEntity* pDeltaProps = ( CSerializedEntity* )pDeltaEntity->m_SerializedEntity;
					BuildMergedPropertySet( pDeltaProps, pPrevProps, pChangeList, nChangePropTick );
					//transfer ownership of our properties over to this object
					pNewPacked->SetPackedData( ( SerializedEntityHandle_t ) pDeltaProps );
					pDeltaEntity->m_SerializedEntity = SERIALIZED_ENTITY_HANDLE_INVALID;
				}			
			}
		}
		else
		{
			//we don't have this object on this frame, so clear it out
			pCurrEntity->m_nSerialNumber	= -1;
			pCurrEntity->m_pClass			= NULL;
			pCurrEntity->m_pPackedData		= INVALID_PACKED_ENTITY_HANDLE;
		}
	}	

	//Sanity check our expansion
	if( pDeltaFrame->m_pSourceFrame )
		CompareSnapshot( pDeltaFrame->m_pSourceFrame, pDeltaFrame->m_pClientFrame->GetSnapshot(), nChangePropTick );
}

void CHLTVServer::ExpandDeltaFramesToTick( int nTick )
{
	//just expand and add all frames until we find one that is of a later tick
	while ( m_pOldestDeltaFrame )
	{
		SHLTVDeltaFrame_t *pFrame = m_pOldestDeltaFrame;

		//see if our oldest is still too new to decompress (-1 means decompress them all)
		if( ( nTick != -1 ) && ( pFrame->m_pClientFrame->tick_count > nTick ) )
			break;

		//expand the frame
		ExpandDeltaFrameToFullFrame( pFrame );

		//now add this into our frame list
		AddClientFrame( pFrame->m_pClientFrame );

		//give up ownership of it since someone else is now holding onto it
		pFrame->m_pClientFrame = NULL;

		//remove this frame from our list
		m_pOldestDeltaFrame = m_pOldestDeltaFrame->m_pNewerDeltaFrame;
		if( m_pOldestDeltaFrame == NULL )
			m_pNewestDeltaFrame = NULL;

		//and nuke the memory
		delete pFrame;
	}
}

void CHLTVServer::FreeAllDeltaFrames( )
{
	while( m_pOldestDeltaFrame )
	{
		//advance to the next list entry
		SHLTVDeltaFrame_t* pCurrFrame = m_pOldestDeltaFrame;
		m_pOldestDeltaFrame = pCurrFrame->m_pNewerDeltaFrame;

		//free everything about this frame
		delete pCurrFrame;
	}

	//and make sure to completely reset our list
	m_pNewestDeltaFrame = NULL;
}


CClientFrame *CHLTVServer::AddNewFrame( CClientFrame *clientFrame )
{
	VPROF_BUDGET( "CHLTVServer::AddNewFrame", "HLTV" );

	Assert ( clientFrame );
	Assert( clientFrame->tick_count > m_nLastTick );

	m_nLastTick = clientFrame->tick_count;

	m_HLTVFrame.SetSnapshot( clientFrame->GetSnapshot() );
	m_HLTVFrame.tick_count = clientFrame->tick_count;	
	m_HLTVFrame.last_entity = clientFrame->last_entity;
	m_HLTVFrame.transmit_entity = clientFrame->transmit_entity;

	// remember tick of first valid frame
	if ( m_nFirstTick < 0 )
	{
		m_nFirstTick = clientFrame->tick_count;
		m_nTickCount = m_nFirstTick;
		
		if ( !IsMasterProxy() )
		{
			Assert ( m_State == ss_loading );
			m_State = ss_active; // we are now ready to go

			ReconnectClients();
			
			ConMsg("GOTV relay active (%d)\n", GetInstanceIndex() ); // there should only be one relay
			
			Steam3Server().Activate();
			Steam3Server().SendUpdatedServerDetails();

			if ( serverGameDLL )
			{
				serverGameDLL->GameServerSteamAPIActivated( true );
			}
		}
		else
		{
			ConMsg("GOTV[%d] broadcast active.\n", GetInstanceIndex() );
		}
	}
	
	CHLTVFrame *hltvFrame = new CHLTVFrame;

	// copy tickcount & entities from client frame
	hltvFrame->CopyFrame( *clientFrame );

	//copy rest (messages, tempents) from current HLTV frame
	hltvFrame->CopyHLTVData( m_HLTVFrame );
	
	// add frame to HLTV server
	int nClientFrameCount = AddClientFrame( hltvFrame );

	// Only keep the number of packets required to satisfy tv_delay at our tv snapshot rate
	static ConVarRef tv_delay( "tv_delay" );

	float flTvDelayToKeep  = tv_delay.GetFloat();
	if ( spec_replay_enable.GetBool() )
		flTvDelayToKeep = Max( flTvDelayToKeep, spec_replay_message_time.GetFloat() + spec_replay_leadup_time.GetFloat() );

	extern ConVar tv_snapshotrate;
	int numFramesToKeep = 2 * ( ( 1 + Max( 1.0f, flTvDelayToKeep ) ) * int( m_flSnapshotRate ) );
	if ( numFramesToKeep < MAX_CLIENT_FRAMES )
		numFramesToKeep = MAX_CLIENT_FRAMES;
	while ( nClientFrameCount > numFramesToKeep )
	{
		RemoveOldestFrame();
		-- nClientFrameCount;
	}

	// reset HLTV frame for recording next messages etc.
	m_HLTVFrame.Reset();
	m_HLTVFrame.SetSnapshot( NULL );

	return hltvFrame;
}



// Different HLTV servers may have e.g. different snapshot rates. 
// This is a chance for HLTV server to patch up some convars for its clients (like the tv_snapshotrate)
void CHLTVServer::FixupConvars( CNETMsg_SetConVar_t &convars )
{
	if ( GetSnapshotRate() != tv_snapshotrate.GetFloat() ) 
	{
		char rate[ 32 ];
		V_snprintf( rate, sizeof( rate ), "%g", GetSnapshotRate() );
		bool bReplaced = false;
		for ( int i = 0; i < convars.convars().cvars_size(); ++i )
		{
			if ( convars.convars().cvars( i ).name() == "tv_snapshotrate" )
			{
				convars.mutable_convars()->mutable_cvars( i )->set_value( rate );
				bReplaced = true;
				break;
			}
		}
		if ( !bReplaced )
		{
			CMsg_CVars_CVar *pCVar = convars.mutable_convars()->add_cvars();
			pCVar->set_name( "tv_snapshotrate" );
			pCVar->set_value( rate );
		}
	}
}

void CHLTVServer::SendClientMessages( bool bSendSnapshots )
{
	// build individual updates
	for ( int i=0; i< m_Clients.Count(); i++ )
	{
		CHLTVClient* 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 CHLTVServer::SendClientMessages( CHLTVClient *client )
{
	// Update Host client send state...
	if ( !client->ShouldSendMessages() )
	{
		return false;
	}

	// 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;
	return true;
}



void CHLTVServer::UpdateStats( void )
{
	if ( m_fNextSendUpdateTime > net_time )
		return;

	m_fNextSendUpdateTime = net_time + 8.0f;
	
	// fire game event for everyone
	IGameEvent *event = NULL; 

	if ( !IsMasterProxy() && !m_ClientState.IsConnected() )
	{
		// we are disconnected from SourceTV server
		event = g_GameEventManager.CreateEvent( "hltv_message", true );

		if ( !event )
			return;

		event->SetString( "text", "#GOTV_Reconnecting" );
	}
	else 
	{
		int proxies = 0, slots = 0, clients = 0;
		
		for ( CActiveHltvServerIterator hltv; hltv; hltv.Next() )
		{
			int nLocalProxyCount, nLocalSlotCount, nLocalClientCount;
			hltv->GetGlobalStats( nLocalProxyCount,nLocalSlotCount,nLocalClientCount );
			proxies += nLocalProxyCount;
			slots += nLocalSlotCount;
			clients += nLocalClientCount;
		}

		event = g_GameEventManager.CreateEvent( "hltv_status", true );

		if ( !event )
			return;

//
//		There's no reason to ever record IP addresses in GOTV demo
//
// 		char address[32];
// 
// 		if ( IsMasterProxy() || tv_overridemaster.GetBool() )
// 		{
// 			// broadcast own address
// 			Q_snprintf( address, sizeof(address), "%s:%u", net_local_adr.ToString(true), GetUDPPort() );
// 		}
// 		else
// 		{
// 			// forward address
// 			Q_snprintf( address, sizeof(address), "%s", m_RootServer.ToString() );
// 		}
// 
// 		event->SetString( "master", address );
		event->SetInt( "clients", clients );
		event->SetInt( "slots", slots);
		event->SetInt( "proxies", proxies );

		int numExternalTotalViewers, numExternalLinkedViewers;
		GetExternalStats( numExternalTotalViewers, numExternalLinkedViewers );
		event->SetInt( "externaltotal", numExternalTotalViewers );
		event->SetInt( "externallinked", numExternalLinkedViewers );
	}

	if ( IsMasterProxy() )
	{
		// as a master fire event for every one
		g_GameEventManager.FireEvent( event );
	}
	else
	{
		// as a relay proxy just broadcast event
		BroadcastEvent( event );
	}

}

bool CHLTVServer::NETMsg_PlayerAvatarData( const CNETMsg_PlayerAvatarData& msg )
{
	PlayerAvatarDataMap_t::IndexType_t idxData = m_mapPlayerAvatarData.Find( msg.accountid() );
	if ( idxData != m_mapPlayerAvatarData.InvalidIndex() )
	{
		delete m_mapPlayerAvatarData.Element( idxData );
		m_mapPlayerAvatarData.RemoveAt( idxData );
	}

	CNETMsg_PlayerAvatarData_t *pHtlvDataCopy = new CNETMsg_PlayerAvatarData_t;
	pHtlvDataCopy->CopyFrom( msg );
	m_mapPlayerAvatarData.Insert( pHtlvDataCopy->accountid(), pHtlvDataCopy );

	// Enqueue this message for all fully connected clients immediately
	for ( int iClient = 0; iClient < GetClientCount(); ++iClient )
	{
		CBaseClient *pClient = dynamic_cast< CBaseClient * >( GetClient( iClient ) );
		if ( !pClient->IsActive() )
			continue;

		if ( INetChannel *pNetChannel = pClient->GetNetChannel() )
		{
			pNetChannel->EnqueueVeryLargeAsyncTransfer( *pHtlvDataCopy );
		}
	}

	if ( m_DemoRecorder.IsRecording() )
	{
		m_DemoRecorder.RecordPlayerAvatar( pHtlvDataCopy );
	}

	return true;
}

bool CHLTVServer::SendNetMsg( INetMessage &msg, bool bForceReliable, bool bVoice )
{
	//
	// When sending messages to HLTV client we encrypt some messages with encryption key
	//
	if ( serverGameDLL &&
		( *tv_encryptdata_key.GetString() || *tv_encryptdata_key_pub.GetString() ) &&
		( msg.GetType() != svc_EncryptedData ) )
	{
		EncryptedMessageKeyType_t eKeyType = serverGameDLL->GetMessageEncryptionKey( &msg );
		char const *szEncryptionKey = "";
		switch ( eKeyType )
		{
		case kEncryptedMessageKeyType_Private:
			szEncryptionKey = tv_encryptdata_key.GetString();
			break;
		case kEncryptedMessageKeyType_Public:
			szEncryptionKey = tv_encryptdata_key_pub.GetString();
			break;
		}
		if ( szEncryptionKey && *szEncryptionKey )
		{
			CSVCMsg_EncryptedData_t encryptedMessage;
			if ( !CmdEncryptedDataMessageCodec::SVCMsg_EncryptedData_EncryptMessage( encryptedMessage, &msg, szEncryptionKey ) )
				return false;
			encryptedMessage.set_key_type( eKeyType );
			return SendNetMsg( encryptedMessage, true, false ); // recurse and send the generated messages as reliable
		}
	}

	//
	// Special message handling for avatar data
	//
	if ( msg.GetType() == net_PlayerAvatarData )
	{
		CNETMsg_PlayerAvatarData const *pPlayerAvatarData = dynamic_cast< CNETMsg_PlayerAvatarData * >( &msg );
		if ( !pPlayerAvatarData )
			return false;

		return NETMsg_PlayerAvatarData( *pPlayerAvatarData );
	}

	//
	// Send the actual outgoing message
	//
	if ( m_bSignonState	)
	{
		return msg.WriteToBuffer( m_Signon );
	}

	int buffer = HLTV_BUFFER_UNRELIABLE;	// default destination

	if ( msg.IsReliable() )
	{
		buffer = HLTV_BUFFER_RELIABLE;
	}
	else if ( msg.GetType() == svc_Sounds )
	{
		buffer = HLTV_BUFFER_SOUNDS;
	}
	else if ( msg.GetType() == svc_VoiceData )
	{
		buffer = HLTV_BUFFER_VOICE;
	}
	else if ( msg.GetType() == svc_TempEntities )
	{
		buffer = HLTV_BUFFER_TEMPENTS;
	}

	// anything else goes to the unreliable bin
	return msg.WriteToBuffer( m_HLTVFrame.m_Messages[buffer] );
}

bf_write *CHLTVServer::GetBuffer( int nBuffer )
{
	if ( nBuffer < 0 || nBuffer >= HLTV_BUFFER_MAX )
		return NULL;

	return &m_HLTVFrame.m_Messages[nBuffer];
}

IServer *CHLTVServer::GetBaseServer()
{
	return (IServer*)this;
}

IHLTVDirector *CHLTVServer::GetDirector()
{
	return m_Director;
}

CClientFrame *CHLTVServer::GetDeltaFrame( int nTick )
{
	if ( !tv_deltacache.GetBool() )
		return GetClientFrame( nTick ); //expensive

	AUTO_LOCK_FM( m_FrameCacheMutex ); // we need to lock frame cache because we're potentially modifying it from multiple sendPacket threads
	// 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();

	CFrameCacheEntry_s &entry = m_FrameCache[i];

	entry.nTick = nTick;
	entry.pFrame = GetClientFrame( nTick ); //expensive

	return entry.pFrame;
}


CClientFrame *CHLTVServer::ExpandAndGetClientFrame( int nTick, bool bExact )
{
	ExpandDeltaFramesToTick( nTick );
	return GetClientFrame( nTick, bExact );
}


void CHLTVServer::RunFrame()
{
	VPROF_BUDGET( "CHLTVServer::RunFrame", "HLTV" );

	// update network time etc
	NET_RunFrame( Plat_FloatTime() );

	if ( m_ClientState.m_nSignonState > SIGNONSTATE_NONE )
	{
		// process data from net socket
		NET_ProcessSocket( m_ClientState.m_Socket, &m_ClientState );

		m_ClientState.RunFrame();
		
		m_ClientState.SendPacket();
	}

	// check if HLTV server if active
	if ( !IsActive() )
		return;

	if ( host_frametime > 0 )
	{
		m_flFPS = m_flFPS * 0.99f + 0.01f/host_frametime;
	}

	if ( IsPlayingBack() )
		return;

	// 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();

	UpdateStats();

	SendClientMessages( true );

	// Update the Steam server if we're running a relay.
	if ( !sv.IsActive() )
		Steam3Server().RunFrame();
	
	UpdateMasterServer();
}

void CHLTVServer::UpdateTick( void )
{
	VPROF_BUDGET( "CHLTVServer::UpdateTick", "HLTV" );

	if ( m_nFirstTick < 0 )
	{
		m_nTickCount = 0;
		m_CurrentFrame = NULL;
		return;
	}

	// set tick time to last frame added
	int nNewTick = m_nLastTick;

	if ( IsMasterProxy() )
	{
		// get tick from director, he decides delay etc
		nNewTick = Max( m_nFirstTick, m_Director->GetDirectorTick() );
#if HLTV_REPLAY_ENABLED
		if ( spec_replay_enable.GetBool() )
		{
			nNewTick = Max< int >( nNewTick, m_nLastTick - ( spec_replay_message_time.GetFloat() + spec_replay_leadup_time.GetFloat() ) / m_flTickInterval );
		}
#endif
	}

	//handle expanding any delta frames we have accumulated up to this point
	ExpandDeltaFramesToTick( nNewTick );

	// the the closest available frame
	CHLTVFrame *newFrame = (CHLTVFrame*) 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;
	
	if ( IsMasterProxy() )
	{
		// now do master proxy stuff

		// restore string tables for this time
		RestoreTick( m_nTickCount );

		// remove entities out of current PVS
		if ( tv_transmitall.GetBool() == false )
		{
			EntityPVSCheck( m_CurrentFrame );	
		}

		if ( ( m_DemoRecorder.IsRecording() || m_Broadcast.IsRecording() ) && m_CurrentFrame )
		{
			if ( m_DemoRecorder.IsRecording() )
				m_DemoRecorder.WriteFrame( m_CurrentFrame, &m_DemoEventWriteBuffer );
			if ( m_Broadcast.IsRecording() )
				m_Broadcast.WriteFrame( m_CurrentFrame, &m_DemoEventWriteBuffer );
			m_DemoEventWriteBuffer.Reset();
		}
	}
	else
	{
		// delta entity cache works only for relay proxies
		m_DeltaCache.SetTick( m_CurrentFrame->tick_count, m_CurrentFrame->last_entity+1 );
	}

	int removeTick = m_nTickCount - tv_window_size.GetFloat() / m_flTickInterval; // keep 16 seconds buffer

	if ( removeTick > 0 )
	{
		DeleteClientFrames( removeTick );
	}

	m_FrameCache.RemoveAll();
}

const char *CHLTVServer::GetName( void ) const
{
	return tv_name.GetString();
}

void CHLTVServer::FillServerInfo(CSVCMsg_ServerInfo &serverinfo)
{
	CBaseServer::FillServerInfo( serverinfo );

	serverinfo.set_player_slot( m_nPlayerSlot ); // all spectators think they're the HLTV client
	serverinfo.set_max_clients( m_nGameServerMaxClients );
}

void CHLTVServer::Clear( void )
{
	CBaseServer::Clear();

	m_Director = NULL;
	m_MasterClient = NULL;
	m_ClientState.Clear();
	m_Server = NULL;
	m_nFirstTick = -1;
	m_nLastTick = 0;
	m_nTickCount = 0;
	m_nPlayerSlot = 0;
	m_flStartTime = 0.0f;
	m_nViewEntity = 1;
	m_nGameServerMaxClients = 0;
	m_fNextSendUpdateTime = 0.0f;

	Changelevel( false );
}

void CHLTVServer::Init(bool bIsDedicated)
{
	CBaseServer::Init( bIsDedicated );

	m_Socket = NS_HLTV + m_nInstanceIndex; 
	COMPILE_TIME_ASSERT(NS_HLTV1 == NS_HLTV + 1 );
	
	// check if only master proxy is allowed, no broadcasting
	if ( CommandLine()->FindParm("-tvmasteronly") )
	{
		m_bMasterOnlyMode = true;
	}
}

void CHLTVServer::Changelevel( bool bInactivateClients )
{
	m_Broadcast.StopRecording();// We can't broadcast after level change, because the broadcast manifest (which includes map name) is immutable during broadcast.
	StopRecordingAndFreeFrames( true );

	if ( bInactivateClients )
	{
		InactivateClients();
	}

	m_CurrentFrame = NULL;

	m_HLTVFrame.FreeBuffers();
	m_vPVSOrigin.Init();

	DeleteClientFrames( -1 );

	m_DeltaCache.Flush();
	m_FrameCache.RemoveAll();


	//free any frames that we may have had outstanding
	FreeAllDeltaFrames();

	//release any snapshots that we were referencing for delta frame construction
	if( m_pLastSourceSnapshot )
	{
		m_pLastSourceSnapshot->ReleaseReference();
		m_pLastSourceSnapshot = NULL;
	}
	if( m_pLastTargetSnapshot )
	{
		m_pLastTargetSnapshot->ReleaseReference();
		m_pLastTargetSnapshot = NULL;
	}

	// Free all avatar data
	m_mapPlayerAvatarData.PurgeAndDeleteElements();
}

void CHLTVServer::GetNetStats( float &avgIn, float &avgOut )
{
	CBaseServer::GetNetStats( avgIn, avgOut	);

	if ( m_ClientState.IsActive() )
	{
		avgIn += m_ClientState.m_NetChannel->GetAvgData(FLOW_INCOMING);
		avgOut += m_ClientState.m_NetChannel->GetAvgData(FLOW_OUTGOING);
	}
}

void CHLTVServer::Shutdown( void )
{
	m_nExternalTotalViewers = 0;
	m_nExternalLinkedViewers = 0;

	//stop any recording, and free our client frame list
	m_Broadcast.StopRecording();
	StopRecordingAndFreeFrames( true );
	UninstallStringTables();

	if ( IsMasterProxy() )
	{
		if ( m_MasterClient )
			m_MasterClient->Disconnect( "GOTV stop." );

		if ( m_Director )
			m_Director->RemoveHLTVServer( this );
	}
	else
	{
		// do not try to reconnect to old connection
		m_ClientState.m_Remote.RemoveAll();

		m_ClientState.Disconnect();
	}

	g_GameEventManager.RemoveListener( this );

	CBaseServer::Shutdown();
}

CDemoFile *CHLTVServer::GetDemoFile()
{
	return &m_DemoFile;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CHLTVServer::IsPlayingBack( void )const
{
	return m_bPlayingBack;
}

bool CHLTVServer::IsPlaybackPaused()const
{
	return m_bPlaybackPaused;	
}

float CHLTVServer::GetPlaybackTimeScale()
{
	return m_flPlaybackRateModifier;
}

void CHLTVServer::SetPlaybackTimeScale(float timescale)
{
	m_flPlaybackRateModifier = timescale;
}

void CHLTVServer::ResyncDemoClock()
{
	m_nStartTick = host_tickcount;
}

int CHLTVServer::GetPlaybackStartTick( void )
{
	return m_nStartTick;
}

int	CHLTVServer::GetPlaybackTick( void )
{
	return host_tickcount - m_nStartTick;
}


bool CHLTVServer::StartPlayback( const char *filename, bool bAsTimeDemo, CDemoPlaybackParameters_t const *pPlaybackParameters, int nStartingTick )
{
	Clear();

	if ( !m_DemoFile.Open( filename, true )  )
	{
		return false;
	}

	// Read in the m_DemoHeader
	demoheader_t *dh = m_DemoFile.ReadDemoHeader( pPlaybackParameters );

	if ( !dh )
	{
		ConMsg( "Failed to read demo header.\n" );
		m_DemoFile.Close();
		return false;
	}
	
	// create a fake channel with a NULL address (no encryption)
	m_ClientState.m_NetChannel = NET_CreateNetChannel( NS_CLIENT, NULL, "DEMO", &m_ClientState, NULL, false );

	if ( !m_ClientState.m_NetChannel )
	{
		ConMsg( "CDemo::Play: failed to create demo net channel\n" );
		m_DemoFile.Close();
		return false;
	}
	
	m_ClientState.m_NetChannel->SetTimeout( -1.0f );	// never timeout


	// Now read in the directory structure.

	m_bPlayingBack = true;

	ConMsg( "Reading complete demo file at once...\n");

	double start = Plat_FloatTime();

	ReadCompleteDemoFile();

	double diff; diff = Plat_FloatTime() - start;
	ConMsg( "Reading time :%.4f\n", diff );

	NET_RemoveNetChannel( m_ClientState.m_NetChannel, true );
	m_ClientState.m_NetChannel = NULL;

	return true;
}

void CHLTVServer::ReadCompleteDemoFile()
{
	int			tick = 0;
	byte		cmd = dem_signon;
	char		buffer[NET_MAX_PAYLOAD];
	netpacket_t	demoPacket;

	// setup demo packet data buffer
	Q_memset( &demoPacket, 0, sizeof(demoPacket) );
	demoPacket.from.SetAddrType( NSAT_NETADR );
	demoPacket.from.AsType<netadr_t>().SetType( NA_LOOPBACK);
	
	while ( true )
	{
		int nPlayerSlot = 0;
		m_DemoFile.ReadCmdHeader( cmd, tick, nPlayerSlot );

		// COMMAND HANDLERS
		switch ( cmd )
		{
		case dem_synctick:
			ResyncDemoClock();
			break;
		case dem_stop:
			// MOTODO we finished reading the file
			return ;
		case dem_consolecmd:
			{
#ifndef DEDICATED
				ACTIVE_SPLITSCREEN_PLAYER_GUARD( nPlayerSlot );
#endif
				CNETMsg_StringCmd_t cmdmsg( m_DemoFile.ReadConsoleCommand() );
				m_ClientState.NETMsg_StringCmd( cmdmsg );
			}
			break;
		case dem_datatables:
			{
				ALIGN4 char data[64*1024] ALIGN4_POST;
				bf_read buf( "dem_datatables", data, sizeof(data) );
				
				m_DemoFile.ReadNetworkDataTables( &buf );
				buf.Seek( 0 );

				// support for older engine demos
				if ( !DataTable_LoadDataTablesFromBuffer( &buf, m_DemoFile.m_DemoHeader.demoprotocol ) )
				{
					Host_Error( "Error parsing network data tables during demo playback." );
				}
			}
			break;
		case dem_stringtables:
			{
				void *data = malloc( 512*1024 ); // X360TBD: How much memory is really needed here?
				bf_read buf( "dem_stringtables", data, 512*1024 );

				m_DemoFile.ReadStringTables( &buf );
				buf.Seek( 0 );

				if ( !networkStringTableContainerClient->ReadStringTables( buf ) )
				{
					Host_Error( "Error parsing string tables during demo playback." );
				}

				free( data );
			}
			break;
		case dem_usercmd:
			{
#ifndef DEDICATED
				ACTIVE_SPLITSCREEN_PLAYER_GUARD( nPlayerSlot );
#endif
				char buffer[256];
				int  length = sizeof(buffer);
				m_DemoFile.ReadUserCmd( buffer, length );
				// MOTODO HLTV must store user commands too
			}
			break;
		case dem_signon:
		case dem_packet:
			{
				int inseq, outseqack = 0;

				m_DemoFile.ReadCmdInfo( m_LastCmdInfo );	// MOTODO must be stored somewhere
				m_DemoFile.ReadSequenceInfo( inseq, outseqack );

				int length = m_DemoFile.ReadRawData( buffer, sizeof(buffer) );

				if ( length > 0 )
				{
					// succsessfully read new demopacket
					demoPacket.received = realtime;
					demoPacket.size = length;
					demoPacket.message.StartReading( buffer,  length );

					m_ClientState.m_NetChannel->ProcessPacket( &demoPacket, false );
				}
			}
	
			break;
		}
	}
}

#define DEBUG_GOTV_RELAY_LOCAL 0
#if DEBUG_GOTV_RELAY_LOCAL
ConVar debug_gotv_relay_whitelist_ports( "debug_gotv_relay_whitelist_ports", "[27005][27006][27007]" ); // run 3 game servers first
#endif
int	CHLTVServer::GetChallengeType ( const ns_address &adr )
{
	if ( serverGameDLL && serverGameDLL->IsValveDS() )
	{
#if DEBUG_GOTV_RELAY_LOCAL
		if ( strstr( debug_gotv_relay_whitelist_ports.GetString(), CFmtStr( "[%u]", adr.GetPort() ) ) )
			return PROTOCOL_HASHEDCDKEY; // When debugging on local machine only make exception for relay proxies, clients actually auth via SteamID
#else
		extern bool IsHltvRelayProxyWhitelisted( ns_address const &adr );
		if ( IsHltvRelayProxyWhitelisted( adr ) )
			return PROTOCOL_HASHEDCDKEY; // HLTV makes an exception for the requesting relay proxy address
#endif

		return CBaseServer::GetChallengeType( adr );
	}

	return PROTOCOL_HASHEDCDKEY; // HLTV doesn't need Steam authentication
}

static bool Helper_HLTV_VerifyOfficialPassword( const char *szPassword )
{
	if ( !szPassword || !szPassword[0] )
		return false;
	if ( Q_strlen( szPassword ) != 32 )
		return false;
	char chSignHash[16] = {0};
	Q_snprintf( chSignHash, ARRAYSIZE( chSignHash ), "%08lX", CRC32_ProcessSingleBuffer( szPassword, 24 ) );
	return ( 0 == Q_strncmp( chSignHash, szPassword + 24, 8 ) );
}

static char const *Helper_HLTV_GenerateUniquePassword()
{
	return "HLTV Official Password Must Be Encrypted";
}

#if 0
CON_COMMAND( debug_make_hltv_encrypted_password, "" )
{
	char const *szPasswordProvidedByClient = args.Arg( 1 );
	if ( !szPasswordProvidedByClient || !*szPasswordProvidedByClient || ( Q_strlen( szPasswordProvidedByClient ) != 32 ) )
	{
		Warning( "Bad password!\n" );
		return;
	}

	char chClientHash[64]={0};
	Q_snprintf( chClientHash, ARRAYSIZE( chClientHash ), "%08X%08X%08X",
		CRC32_ProcessSingleBuffer( szPasswordProvidedByClient, 32 ),
		CRC32_ProcessSingleBuffer( szPasswordProvidedByClient + 10, 22 ),
		CRC32_ProcessSingleBuffer( szPasswordProvidedByClient + 20, 12 ) );
	Q_snprintf( chClientHash + 24, ARRAYSIZE( chClientHash ) - 24, "%08X",
		CRC32_ProcessSingleBuffer( chClientHash, 24 ) );

	Msg( "{%s}->{%s}\n", szPasswordProvidedByClient, chClientHash );
}
#endif

bool CHLTVServer::CheckHltvPasswordMatch( const char *szPasswordProvidedByClient, const char *szServerRequiredPassword, CSteamID steamidClient )
{
	// Official servers must have a special encrypted password
	if ( serverGameDLL && serverGameDLL->IsValveDS() )
	{
		if ( !Helper_HLTV_VerifyOfficialPassword( szServerRequiredPassword ) )
		{
			ExecuteNTimes( 3, Warning( "WARNING: %s (%s)\n", Helper_HLTV_GenerateUniquePassword(), szServerRequiredPassword ? szServerRequiredPassword : "none" ) );
			return false; // without the encrypted password clients cannot connect
		}

		if ( !szPasswordProvidedByClient || !szPasswordProvidedByClient[0] )
			return false;	// server requires a password, but client didn't provide a password

		// Enforce client password length to be 32 characters
		if ( Q_strlen( szPasswordProvidedByClient ) == 32 )
		{
			// Compute a client password hash
			char chClientHash[64]={0};
			Q_snprintf( chClientHash, ARRAYSIZE( chClientHash ), "%08lX%08lX%08lX",
				CRC32_ProcessSingleBuffer( szPasswordProvidedByClient, 32 ),
				CRC32_ProcessSingleBuffer( szPasswordProvidedByClient + 10, 22 ),
				CRC32_ProcessSingleBuffer( szPasswordProvidedByClient + 20, 12 ) );
			if ( !Q_strncmp( chClientHash, szServerRequiredPassword, 24 ) )
				return true;
		}
	}
	else
	{
		if ( !szServerRequiredPassword || !szServerRequiredPassword[0] || !Q_stricmp( szServerRequiredPassword, "none" ) )
			return true;	// server doesn't require a password, allow client
		if ( !szPasswordProvidedByClient || !szPasswordProvidedByClient[0] )
			return false;	// server requires a password, but client didn't provide a password
		if ( !Q_strcmp( szPasswordProvidedByClient, szServerRequiredPassword ) )
			return true;	// compare passwords
	}

	//
	// Check if client is connecting via watchable reservation
	//
	if ( tv_advertise_watchable.GetBool() && sv.IsReserved() && sv.GetReservationCookie() &&
		szPasswordProvidedByClient && ( Q_strlen( szPasswordProvidedByClient ) == 64 ) )
	{
		// Decode client TV watchable password ascii
		unsigned char chEncryptedPassword[ 32 + 1 ] = {0};
		for ( int k = 0; k < 32; ++ k )
		{
			char chScan[5] = { '0', 'x', szPasswordProvidedByClient[2*k], szPasswordProvidedByClient[2*k+1], 0 };
			uint32 uiByte = 0;
			sscanf( chScan, "0x%02X", &uiByte );
			chEncryptedPassword[k] = uiByte;
		}

		// Decrypt the encoded password
		IceKey iceKey( 2 );
		if ( iceKey.keySize() == 16 )
		{
			iceKey.set( ( unsigned char * ) CFmtStr( "%016llX", sv.GetReservationCookie() ).Access() );
			char chDecryptedPassword[ 32 + 1 ] = {0};
			for ( int k = 0; k < 32; k += iceKey.blockSize() )
			{
				iceKey.decrypt( chEncryptedPassword + k, ( unsigned char * ) chDecryptedPassword + k );
			}
			if ( !Q_strcmp( chDecryptedPassword, CFmtStr( "WATCH100%08X%016llX", steamidClient.GetAccountID(), sv.GetReservationCookie() ).Access() ) )
				return true;
		}
	}

	return false;
}

const char *CHLTVServer::GetPassword() const
{
	const char *password = tv_password.GetString();

	// Official servers must have a special encrypted password
	if ( serverGameDLL && serverGameDLL->IsValveDS() && !Helper_HLTV_VerifyOfficialPassword( password ) )
		return Helper_HLTV_GenerateUniquePassword();

	// if password is empty or "none", return NULL
	if ( !password[0] || !Q_stricmp(password, "none" ) )
	{
		return NULL;
	}

	return password;
}

const char *CHLTVServer::GetHltvRelayPassword() const
{
	static ConVarRef tv_relaypassword( "tv_relaypassword" );
	const char *password = tv_relaypassword.GetString();

	if ( serverGameDLL && serverGameDLL->IsValveDS() && !Helper_HLTV_VerifyOfficialPassword( password ) )
		return Helper_HLTV_GenerateUniquePassword();

	// if password is empty or "none", return NULL
	if ( !password[0] || !Q_stricmp(password, "none" ) )
	{
		return NULL;
	}

	return password;
}

IClient *CHLTVServer::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 = (CHLTVClient*)CBaseServer::ConnectClient( 
		adr, protocol, challenge,authProtocol, name, password, hashedCDkey, cdKeyLen, splitScreenClients, isClientLowViolence, clientPlatform,
		pbEncryptionKey, nEncryptionKeyIndex );

	if ( client )
	{
		// remember password
		CHLTVClient *pHltvClient = (CHLTVClient*)client;
		Q_strncpy( pHltvClient->m_szPassword, password, sizeof(pHltvClient->m_szPassword) );
	}

	return client;
}

bool CHLTVServer::GetRedirectAddressForConnectClient( const ns_address &adr, CUtlVector< CCLCMsg_SplitPlayerConnect_t* > & splitScreenClients, ns_address *pNetAdrRedirect )
{
	bool bConnectingClientIsTvRelay = false;

	if ( splitScreenClients.Count() )
	{
		const CMsg_CVars& convars = splitScreenClients[0]->convars();
		for ( int i = 0; i< convars.cvars_size(); ++i )
		{
			const char *cvname = NetMsgGetCVarUsingDictionary( convars.cvars(i) );
			const char *value = convars.cvars(i).value().c_str();
				
			if ( stricmp( cvname, "tv_relay" ) )
				continue;

			bConnectingClientIsTvRelay = ( value[0] == '1' );
			break;
		}
	}

	if ( bConnectingClientIsTvRelay )
		return false;

	// This is a human spectator, check if we should dispatch them down the chain
	//
	// The section below is largely a copy of DispatchToRelay function
	//

	if ( tv_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->IsHLTV() )
			continue;

		int slots = Q_atoi( pProxy->GetUserSetting( "hltv_slots" ) );
		int clients = Q_atoi( pProxy->GetUserSetting( "hltv_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 ( tv_dispatchmode.GetInt() == DISPATCH_MODE_ALWAYS )
		{
			// we are in always forward mode, drop client if we can't forward it
			pNetAdrRedirect->Clear();
			RejectConnection( adr, "No GOTV relay available" );
			return true;
		}
		else
		{
			// just let client connect to this proxy
			return false;
		}
	}

	// check if client should stay on this relay server unless we are the master,
	// masters always prefer to send clients to relays
	if ( (tv_dispatchmode.GetInt() == DISPATCH_MODE_AUTO) && (GetMaxClients() > 0) )
	{
		// ratio = clients/slots. give relay proxies 25% bonus
		int numSlots = GetMaxClients();
		if ( tv_maxclients_relayreserved.GetInt() > 0 )
			numSlots -= tv_maxclients_relayreserved.GetInt();
		numSlots = MAX( 0, numSlots );

		int numClients = GetNumClients();
		if ( numClients > numSlots )
			numSlots = numClients;

		float flDispatchWeight = tv_dispatchweight.GetFloat();
		if ( flDispatchWeight <= 1.01 )
			flDispatchWeight = 1.01;
		float myRatio = ((float)numClients/(float)numSlots) * flDispatchWeight;

		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
	}

	CFmtStr fmtAdditionalInfo;
	const char *pszRelayAddr = pBestProxy->GetUserSetting( "hltv_addr" );
	if ( !pszRelayAddr )
		return false;

	// If the client is attempting a connection over SDR and the relay downstream allows
	// connection over SDR, then redirect to SDR port instead
	switch ( adr.GetAddressType() )
	{
	case NSAT_PROXIED_CLIENT:
		if ( const char *pszRelaySdrAddr = pBestProxy->GetUserSetting("hltv_sdr") )
		{
			if ( *pszRelaySdrAddr )
			{
				ns_address nsadrsdr;
				if ( nsadrsdr.SetFromString( pszRelaySdrAddr ) && ( nsadrsdr.GetAddressType() == NSAT_PROXIED_GAMESERVER ) )
				{
					// Ensure that client gets a ticket for the new SDR address
					// and that the game server allows redirect
					if ( serverGameDLL->IsValveDS() && serverGameDLL->OnEngineClientProxiedRedirect(
						adr.m_steamID.GetSteamID().ConvertToUint64(), pszRelaySdrAddr, pszRelayAddr ) )
					{
						//
						// Build a P2P HLTV channel SDR address for client redirect
						//
						fmtAdditionalInfo.AppendFormat( " @ %s SDR:%d", pszRelayAddr, nsadrsdr.m_steamID.GetSteamChannel() );
						nsadrsdr.m_steamID.SetSteamChannel( STEAM_P2P_HLTV );
						ns_address_render nsadrRendered( nsadrsdr );
						char *pchStackCopy = ( char * ) stackalloc( 1 + V_strlen( nsadrRendered.String() ) );
						V_strcpy( pchStackCopy, nsadrRendered.String() );
						pszRelayAddr = pchStackCopy;
					}
				}
			}
		}
		break;
	}
	
	ConMsg( "Redirecting spectator connect packet from %s to GOTV relay %s%s\n",
		ns_address_render( adr ).String(), 
		pszRelayAddr, fmtAdditionalInfo.Access() );

	// tell the client to connect to this new address
	pNetAdrRedirect->SetFromString( pszRelayAddr );
    		
 	// increase this proxies client number in advance so this proxy isn't used again next time
	int clients = Q_atoi( pBestProxy->GetUserSetting( "hltv_clients" ) );
	pBestProxy->SetUserCVar( "hltv_clients", va("%d", clients+1 ) );
	
	return true;
}

CON_COMMAND( tv_status, "Show GOTV server status." ) 
{
	int		slots, proxies,	clients;
	float	in, out;
	char	gd[MAX_OSPATH];

	Q_FileBase( com_gamedir, gd, sizeof( gd ) );

	for ( CActiveHltvServerSelector hltv( args ); hltv; hltv.Next() )
	{
		hltv->GetNetStats( in, out );

		in /= 1024; // as KB
		out /= 1024;

		ConMsg( "--- GOTV[%u] Status ---\n", hltv.GetIndex() );
		ConMsg( "Online %s, FPS %.1f, Version %i (%s)\n",
			COM_FormatSeconds( hltv->GetOnlineTime() ), hltv->m_flFPS, build_number(),
#if defined( _WIN32 )
			"Win32"
#else
			"Linux"
#endif
			);

		if ( hltv->IsDemoPlayback() )
		{
			ConMsg( "Playing Demo File \"%s\"\n", "TODO demo file name" );
		}
		else if ( hltv->IsMasterProxy() )
		{
			ConMsg( "Master \"%s\", delay %.0f, rate %.1f\n", hltv->GetName(), hltv->GetDirector()->GetDelay(), hltv->GetSnapshotRate() );
		}
		else // if ( m_Server->IsRelayProxy() )
		{
			if ( hltv->GetRelayAddress() )
			{
				ConMsg( "Relay \"%s\", connect to %s\n", hltv->GetName(), hltv->GetRelayAddress()->ToString() );
			}
			else
			{
				ConMsg( "Relay \"%s\", not connect.\n", hltv->GetName() );
			}
		}

		ConMsg( "Game Time %s, Mod \"%s\", Map \"%s\", Players %i\n", COM_FormatSeconds( hltv->GetTime() ),
			gd, hltv->GetMapName(), hltv->GetNumPlayers() );

		ConMsg( "Local IP %s:%i, KB/sec In %.1f, Out %.1f\n",
			net_local_adr.ToString( true ), hltv->GetUDPPort(), in, out );

		hltv->GetLocalStats( proxies, slots, clients );

		ConMsg( "Local Slots %i, Spectators %i, Proxies %i\n",
			slots, clients - proxies, proxies );

		hltv->GetGlobalStats( proxies, slots, clients );

		ConMsg( "Total Slots %i, Spectators %i, Proxies %i\n",
			slots, clients - proxies, proxies );

		hltv->GetExternalStats( slots, clients );
		if ( slots > 0 )
		{
			if ( clients > 0 )
				ConMsg( "Streaming spectators %i, linked to Steam %i\n", slots, clients );
			else
				ConMsg( "Streaming spectators %i\n", slots );
		}

		if ( hltv->m_DemoRecorder.IsRecording() )
		{
			ConMsg( "Recording to \"%s\", length %s.\n", hltv->m_DemoRecorder.GetDemoFilename(),
				COM_FormatSeconds( host_state.interval_per_tick * hltv->m_DemoRecorder.GetRecordingTick() ) );
		}

		if ( hltv->m_Broadcast.IsRecording() )
		{
			ConMsg( "Broadcasting\n" );
		}

		ConMsg( "\n" );

		extern ConVar host_name;
		ConMsg( "hostname: %s\n", host_name.GetString() );
		// the header for the status rows
		ConMsg( "# userid name uniqueid connected ping loss state rate adr\n" );
		for ( int j = 0; j < hltv->GetClientCount(); j++ )
		{
			IClient	*client = hltv->GetClient( j );
			if ( !client || !client->IsConnected() )
				continue; // not connected yet, maybe challenging

			extern void Host_Status_PrintClient( IClient *client, bool bShowAddress, void( *print ) ( const char *fmt, ... ) );
			Host_Status_PrintClient( client, true, ConMsg );
		}
	}
	ConMsg( "#end\n" );
}

CON_COMMAND( sv_getinfo, "Show user info of a connected client" )
{
	if ( args.ArgC() < 4 )
	{
		ConMsg( "Usage:  userinfo_show [sv|tv0|tv1] [id] [var]\n" );
		return;
	}

	CBaseServer *psv = &sv;
	if ( char const *szTvN = StringAfterPrefix( args.Arg( 1 ), "tv" ) )
	{
		int nTV = V_atoi( szTvN );
		nTV = clamp( nTV, 0, HLTV_SERVER_MAX_COUNT - 1 );
		psv = g_pHltvServer[ nTV ];
		if ( !psv )
		{
			ConMsg( "TV%d not active\n", nTV );
			return;
		}
	}
	else if ( !psv )
	{
		ConMsg( "Main server not active\n" );
		return;
	}

	int nClientID = V_atoi( args.Arg( 2 ) );
	if ( nClientID < 0 || nClientID >= psv->GetClientCount() )
	{
		ConMsg( "Found %d clients on server\n", psv->GetClientCount() );
		return;
	}

	IClient *pClient = psv->GetClient( nClientID );
	if ( !pClient || !pClient->IsConnected() )
	{
		ConMsg( "Client #%d is %s\n", nClientID, pClient ? "not connected" : "null" );
		return;
	}

	const char *pszVar = args.Arg( 3 );
	const char *pszValue = pClient->GetUserSetting( pszVar );
	ConMsg( "Client #%d '%s'<%s> '%s'='%s'\n", nClientID, pClient->GetClientName(), pClient->GetNetworkIDString(), pszVar, pszValue );
}

CON_COMMAND( tv_relay, "Connect to GOTV server and relay broadcast." )
{
	if ( args.ArgC() < 2 )
	{
		ConMsg( "Usage:  tv_relay <ip:port> [-instance <inst>]\n" );
		return;
	}

	const char *address = args.ArgS();

	// If it's not a single player connection to "localhost", initialize networking & stop listenserver
	if ( StringHasPrefixCaseSensitive( address, "localhost" ) )
	{
		ConMsg( "GOTV can't connect to localhost.\n" );
		return;
	}

	int nHltvIndex = clamp( args.FindArgInt( "-instance", 0 ), 0, HLTV_SERVER_MAX_COUNT - 1 );
 	CHLTVServer * & hltv = g_pHltvServer[ nHltvIndex ];

	if ( !hltv )
	{
		hltv = new CHLTVServer( nHltvIndex, ( nHltvIndex ? tv_snapshotrate1.GetFloat() : tv_snapshotrate.GetFloat() ) );
		hltv->Init( NET_IsDedicated() );
	}

	if ( hltv->m_bMasterOnlyMode )
	{
		ConMsg("GOTV[%d] in Master-Only mode.\n", nHltvIndex );
		return;
	}

	// If the main server instance is running then we want to re-use it's
	// logged on anonymous SteamID
	if ( sv.IsDedicated() && sv.IsActive() )
		sv.FlagForSteamIDReuseAfterShutdown();

	// shutdown anything else
	Host_Disconnect( false );

	// start networking
	NET_Init( NET_IsDedicated() );
	NET_SetMultiplayer( true );	

	hltv->ConnectRelay( address );
}

CON_COMMAND( tv_stop, "Stops the GOTV broadcast [-instance <inst> ]" )
{
	for ( CActiveHltvServerSelector hltv( args ); hltv; hltv.Next() )
	{
		int nClients = hltv->GetNumClients();

		hltv->Shutdown();

		ConMsg( "GOTV[%u] stopped, %i clients disconnected.\n", hltv.GetIndex(), nClients );
	}
}

CON_COMMAND( tv_retry, "Reconnects the GOTV relay proxy " )
{
	for ( CActiveHltvServerSelector hltv( args ); hltv; hltv.Next() )
	{
		if ( hltv->m_bMasterOnlyMode )
		{
			ConMsg( "GOTV[%u] in Master-Only mode.\n", hltv.GetIndex() );
			return;
		}

		if ( !hltv->m_ClientState.m_Remote.Count() )
		{
			ConMsg( "Can't retry, no previous GOTV[%u] connection\n", hltv.GetIndex() );
			return;
		}

		ConMsg( "Commencing GOTV[%u] connection retry to %s\n", hltv.GetIndex(), hltv->m_ClientState.m_Remote.Get( 0 ).m_szRetryAddress.String() );
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), va( "tv_relay %s\n", hltv->m_ClientState.m_Remote.Get( 0 ).m_szRetryAddress.String() ) );
	}
}



CON_COMMAND( tv_record, "Starts GOTV demo recording [-instance <inst> ]" )
{
	if ( args.ArgC() < 2 )
	{
		ConMsg( "Usage:  tv_record  <filename> [-instance <inst> ]\n" );
		return;
	}

	int nHltvInstance = clamp( args.FindArgInt( "-instance", 0 ), 0, HLTV_SERVER_MAX_COUNT );
	CHLTVServer * hltv = g_pHltvServer[ nHltvInstance ];
	if ( hltv && hltv->IsActive() )
	{
		if ( !hltv->IsMasterProxy() )
		{
			ConMsg( "GOTV[%u]: Only GOTV Master can record demos instantly.\n", nHltvInstance );
			return;
		}

		if ( hltv->m_DemoRecorder.IsRecording() )
		{
			ConMsg( "GOTV[%u] already recording to %s.\n", nHltvInstance, hltv->m_DemoRecorder.GetDemoFilename() );
			return;
		}

		// check path first
		if ( !COM_IsValidPath( args[ 1 ] ) )
		{
			ConMsg( "record %s: invalid path.\n", args[ 1 ] );
			return;
		}

		char name[ MAX_OSPATH ];

		Q_strncpy( name, args[ 1 ], sizeof( name ) );

		// add .dem if not already set by user
		Q_DefaultExtension( name, ".dem", sizeof( name ) );

		bool bConflict = false;
		for ( CHltvServerIterator other; other; other.Next() )
		{
			CHLTVServer *pOtherHltvServer = other;
			if ( pOtherHltvServer != hltv && pOtherHltvServer->IsRecording() && !V_stricmp( pOtherHltvServer->GetRecordingDemoFilename(), name ) )
			{
				Warning( "Cannot record on GOTV[%d]: another GOTV[%d] is currently recording into that file\n", nHltvInstance, pOtherHltvServer->GetInstanceIndex() );
				bConflict = true;
			}
		}

		if ( !bConflict )
		{
			hltv->m_DemoRecorder.StartRecording( name, false );
		}
	}
	else
	{
		ConMsg( "GOTV[%d] is not active\n", nHltvInstance );
	}
}


// tv_broadcast change callback
void OnTvBroadcast( )
{
	for ( CActiveHltvServerIterator hltv; hltv; hltv.Next() )
	{
		if ( GetIndexedConVar( tv_broadcast, hltv.GetIndex() ).GetBool() )
		{
			if ( hltv->IsTVRelay() )
			{
				Warning( "GOTV[%d] is a relay.", hltv.GetIndex() );
			}
			else
			{
				if ( !hltv->m_Broadcast.IsRecording() )
				{
					hltv->StartBroadcast();
					ConMsg( "Broadcast on GOTV[%d] started\n", hltv.GetIndex() );
				}
				else
				{
					ConMsg( "Broadcast on GOTV[%d] is already active\n", hltv.GetIndex() );
				}
			}
		}
		else
		{
			if ( hltv->m_Broadcast.IsRecording() )
			{
				hltv->m_Broadcast.StopRecording();
				ConMsg( "Broadcast on GOTV[%d] stopped\n", hltv.GetIndex() );
			}
			else
			{
				ConMsg( "Broadcast on GOTV[%d] is not active\n", hltv.GetIndex() );
			}
		}
	}
}
void OnTvBroadcast( IConVar *var, const char *pOldValue, float flOldValue ) { OnTvBroadcast(); }


CON_COMMAND( tv_broadcast_status, "Print out broadcast status" )
{
	int nActiveServers = 0, nBroadcastingServers = 0;
	for ( CActiveHltvServerIterator hltv; hltv; hltv.Next() )
	{
		nActiveServers++;
		if ( hltv->m_Broadcast.IsRecording() )
		{
			nBroadcastingServers++;
			Msg( "GOTV[%d] is broadcasting to %s: ", hltv.GetIndex(), hltv->m_Broadcast.GetUrl() );
			hltv->m_Broadcast.DumpStats();
		}
	}
	if ( !nBroadcastingServers )
	{
		// print something
		if ( nActiveServers )
			Msg( "GOTV is not broadcasting\n" );
		else
			Msg( "GOTV is not active\n" );
	}
}

// tv_stopbroadcast is effectively accomplished by tv_broadcast 0

CON_COMMAND( tv_stoprecord, "Stops GOTV demo recording [-instance <inst> ]" )
{
	for ( CActiveHltvServerSelector hltv( args ); hltv; hltv.Next() )
	{
		//this is painful, but we need to expand all of the delta frames before we stop recording. That means this console command will cause a big spike in memory
		hltv->StopRecording();
	}
}



CON_COMMAND( tv_clients, "Shows list of connected GOTV clients [-instance <inst> ]" )
{
	for ( CActiveHltvServerSelector hltv( args ); hltv; hltv.Next() )
	{
		int nCount = 0;
		ConMsg( "GOTV[%u]\n", hltv.GetIndex() );

		for ( int i = 0; i < hltv->GetClientCount(); i++ )
		{
			CHLTVClient *client = hltv->Client( i );
			INetChannel *netchan = client->GetNetChannel();

			if ( !netchan )
				continue;

			bool bClientIsHLTV = client->IsHLTV();
			char const *szClientHLTVRedirect = bClientIsHLTV ? client->GetUserSetting( "hltv_addr" ) : NULL;

			ConMsg( "ID: %i, \"%s\"%s, Time %s, %s%s%s, In %.1f, Out %.1f.\n",
				client->GetUserID(),
				client->GetClientName(),
				bClientIsHLTV ? " (Relay)" : "",
				COM_FormatSeconds( netchan->GetTimeConnected() ),
				netchan->GetAddress(),
				bClientIsHLTV ? ( szClientHLTVRedirect ? " redirecting to " : " BAD REDIRECT ADDR" ) : "",
				( bClientIsHLTV && szClientHLTVRedirect ) ? szClientHLTVRedirect : "",
				netchan->GetAvgData( FLOW_INCOMING ) / 1024,
				netchan->GetAvgData( FLOW_OUTGOING ) / 1024 );

			nCount++;
		}

		ConMsg( "--- Total %i connected clients ---\n", nCount );
	}
}




CON_COMMAND( tv_msg, "Send a screen message to all clients [-instance <inst> ]" )
{
	for ( CActiveHltvServerSelector hltv( args ); hltv; hltv.Next() )
	{
		IGameEvent *msg = g_GameEventManager.CreateEvent( "hltv_message", true );

		if ( msg )
		{
			msg->SetString( "text", args.ArgS() );
			hltv->BroadcastEventLocal( msg, false );
			g_GameEventManager.FreeEvent( msg );
		}
	}
}


CActiveHltvServerSelector::CActiveHltvServerSelector( const CCommand &args )
{
	const char *pInstance = args.FindArg( "-instance" );
	m_nIndex = HLTV_SERVER_MAX_COUNT; // by default, iterator is empty/invalid
	m_nMask = 0;

	if ( ( pInstance && !V_stricmp( pInstance, "all" ) ) || args.FindArg( "-all" ) )
	{
		// iterate all active instances
		m_nMask = ( 1 << HLTV_SERVER_MAX_COUNT ) - 1;
		m_nIndex = -1;
		Next();
		if ( m_nIndex >= HLTV_SERVER_MAX_COUNT )
		{
			ConMsg( "No active GOTV instances at this time.\n" );
		}
	}
	else
	{
		int nInstance = pInstance ? V_atoi( pInstance ) : 0; // the default is GOTV[0]
		if ( nInstance >= HLTV_SERVER_MAX_COUNT )
		{
			ConMsg( "GOTV[%d] index out of range.\n", nInstance );
		}
		else if ( g_pHltvServer[ nInstance ] && g_pHltvServer[ nInstance ]->IsActive() )
		{
			m_nMask = 1 << nInstance;
			m_nIndex = nInstance; // valid GOTV instance found
		}
		else
		{
			ConMsg( "GOTV[%d] not active.\n", nInstance );
		}
	}
}






CON_COMMAND( tv_mem, "hltv memory statistics" )
{
	bool bActive = false;
	for ( CActiveHltvServerIterator hltv; hltv; hltv.Next() )
	{
		hltv->DumpMem();
		bActive = true;
	}
	if ( !bActive )
		Msg( "No active GOTV servers found\n" );
}

void CHLTVServer::DumpMem()
{
	Msg( "GOTV[%d] memory consumption:", m_nInstanceIndex );
	uint nHltvFrameSize = 0, nHltvFrameCount = 0;
	for ( CHLTVFrame *pFrame = m_CurrentFrame; pFrame; pFrame = static_cast< CHLTVFrame * > ( pFrame->m_pNext ) )
	{
		nHltvFrameSize += pFrame->GetMemSize();
		nHltvFrameCount++;
	}
	Msg( "%4u  Hltv Frames: %10s\n", nHltvFrameCount, V_pretifynum( nHltvFrameSize ) );

	uint nDeltaFrameCount = 0, nDeltaFrameSize = 0;
	for ( SHLTVDeltaFrame_t *pFrame = m_pOldestDeltaFrame; pFrame; pFrame = pFrame->m_pNewerDeltaFrame )
	{
		nDeltaFrameSize += pFrame->GetMemSize();
		nDeltaFrameCount++;
	}
	Msg( "%4u Delta Frames: %10s\n", nDeltaFrameCount, V_pretifynum( nDeltaFrameSize ) );
	// dump packed entity sizes from framesnapshotmanager?
}

#ifndef DEDICATED
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void EditDemo_f( const CCommand &args )
{
	if ( args.ArgC() < 2 )
	{
		Msg ("editdemo <demoname> [-instance <inst>]: edits a demo\n");
		return;
	}

	CActiveHltvServerSelector hltv( args );
	if ( hltv )
	{
		// set current demo player to client demo player
		demoplayer = hltv;

		//
		// open the demo file
		//
		char name[ MAX_OSPATH ];

		Q_strncpy( name, args[ 1 ], sizeof( name ) );

		Q_DefaultExtension( name, ".dem", sizeof( name ) );

		hltv->m_ClientState.m_bSaveMemory = true;

		hltv->StartPlayback( name, false, NULL, -1 );
	}
}

CON_COMMAND_AUTOCOMPLETEFILE( editdemo, EditDemo_f, "Edit a recorded demo file (.dem ).", NULL, dem );
#endif