csgo/cstrike15_src/engine/dt_send_eng.cpp

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include <tier0/dbg.h>
#include <tier0/vprof.h>
#include <tier0/icommandline.h>
#include <commonmacros.h>
#include <checksum_crc.h>

#include "dt_send_eng.h"
#include "dt_encode.h"
#include "dt_instrumentation_server.h"
#include "dt_stack.h"
#include "common.h"
#include "packed_entity.h"
#include "serializedentity.h"
#include "edict.h"
#include "netmessages.h"
#include <algorithm>

// Define this to get a report on which props are being sent frequently and
// have high-numbered indices. Marking these with SPROP_CHANGES_OFTEN can
// improve CPU and network efficiency.
//#define PROP_SKIPPED_REPORT
#ifdef PROP_SKIPPED_REPORT
#include <map>
#include <string>
#endif

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

extern int host_framecount;
CRC32_t SendTable_ComputeCRC();

#define CRC_SEND_TABLE_VERBOSE 0

#if CRC_SEND_TABLE_VERBOSE
#define CRCMSG DevMsg
#else
#define CRCMSG (void)
#endif
#define CRCMEMx( var, nByte ) ( unsigned int )( ( reinterpret_cast< unsigned char * >( &var ) )[nByte] )
#define CRCMEM4( var ) CRCMEMx( var, 0 ), CRCMEMx( var, 1 ), CRCMEMx( var, 2 ), CRCMEMx( var, 3 )
#define CRCFMT4 "%02X%02X%02X%02X"

class CSendTablePrecalc;
class CSendNode;

// This stack doesn't actually call any proxies. It uses the CSendProxyRecipients to tell
// what can be sent to the specified client.
class CPropCullStack : public CDatatableStack
{
public:
						CPropCullStack( 
							CSendTablePrecalc *pPrecalc, 
							int iClient, 
							const CSendProxyRecipients *pOldStateProxies,
							const int nOldStateProxies, 
							const CSendProxyRecipients *pNewStateProxies,
							const int nNewStateProxies
							) :
							
							CDatatableStack( pPrecalc, (unsigned char*)1, -1 ),
							m_pOldStateProxies( pOldStateProxies ),
							m_nOldStateProxies( nOldStateProxies ),
							m_pNewStateProxies( pNewStateProxies ),
							m_nNewStateProxies( nNewStateProxies )
						{
							m_pPrecalc = pPrecalc;
							m_iClient = iClient;
						}

	inline unsigned char*	CallPropProxy( CSendNode *pNode, int iProp, unsigned char *pStructBase )
	{
		if ( pNode->GetDataTableProxyIndex() == DATATABLE_PROXY_INDEX_NOPROXY )
		{
			return (unsigned char*)1;
		}
		else
		{
			Assert( pNode->GetDataTableProxyIndex() < m_nNewStateProxies );
			bool bCur = m_pNewStateProxies[ pNode->GetDataTableProxyIndex() ].m_Bits.Get( m_iClient ) != 0;

			if ( m_pOldStateProxies )
			{
				Assert( pNode->GetDataTableProxyIndex() < m_nOldStateProxies );
				bool bPrev = m_pOldStateProxies[ pNode->GetDataTableProxyIndex() ].m_Bits.Get( m_iClient ) != 0;
				if ( bPrev != bCur )
				{
					if ( bPrev )
					{
						// Old state had the data and the new state doesn't.
						return 0;
					}
					else
					{
						// Add ALL properties under this proxy because the previous state didn't have any of them.
						for ( int i=0; i < pNode->m_nRecursiveProps; i++ )
						{
							if ( m_nNewProxyProps < ARRAYSIZE( m_NewProxyProps ) )
							{
								m_NewProxyProps[m_nNewProxyProps] = pNode->m_iFirstRecursiveProp + i;
							}
							else
							{
								Error( "CPropCullStack::CallPropProxy - overflowed m_nNewProxyProps" );
							}

							++m_nNewProxyProps;
						}

						// Tell the outer loop that writes to m_pOutProps not to write anything from this
						// proxy since we just did.
						return 0;
					}
				}
			}

			return (unsigned char*)bCur;
		}
	}

	virtual void RecurseAndCallProxies( CSendNode *pNode, unsigned char *pStructBase )
	{
		// Remember where the game code pointed us for this datatable's data so 
		m_pProxies[ pNode->GetRecursiveProxyIndex() ] = pStructBase;

		for ( int iChild=0; iChild < pNode->GetNumChildren(); iChild++ )
		{
			CSendNode *pCurChild = pNode->GetChild( iChild );
			
			unsigned char *pNewStructBase = NULL;
			if ( pStructBase )
			{
				pNewStructBase = CallPropProxy( pCurChild, pCurChild->m_iDatatableProp, pStructBase );
			}

			RecurseAndCallProxies( pCurChild, pNewStructBase );
		}
	}

	// Replay: when client is in replay, we substitute the client index and cull props as if they were being sent to a regular HLTV client
	void CullPropsFromProxies( const CalcDeltaResultsList_t &startProps, CalcDeltaResultsList_t &outProps )
	{
		m_pOutProps = &outProps;
		m_nNewProxyProps = 0;

		Init( false, false );

		// This list will have any newly available props written into it. Write a sentinel at the end.
		m_NewProxyProps[m_nNewProxyProps] = PROP_SENTINEL;
		int *pCurNewProxyProp = m_NewProxyProps;

		for ( int i=0; i < startProps.Count(); i++ )
		{
			int iProp = startProps[i];

			// Fill in the gaps with any properties that are newly enabled by the proxies.
			while ( *pCurNewProxyProp < iProp )
			{
				m_pOutProps->AddToTail( *pCurNewProxyProp );
				++pCurNewProxyProp;
			}

			// Now write this property's index if the proxies are allowing this property to be written.
			if ( IsPropProxyValid( iProp ) )
			{
				m_pOutProps->AddToTail( iProp );

				// avoid that we add it twice.
				if ( *pCurNewProxyProp == iProp )
					++pCurNewProxyProp;
			}
		}

		// add any remaining new proxy props
		while ( *pCurNewProxyProp < PROP_SENTINEL )
		{
			m_pOutProps->AddToTail( *pCurNewProxyProp );
			++pCurNewProxyProp;
		}
	}

	int GetNumOutProps()
	{
		return m_pOutProps->Count();
	}


private:
	CSendTablePrecalc		*m_pPrecalc;
	int						m_iClient;	// Which client it's encoding out for.
	const CSendProxyRecipients	*m_pOldStateProxies;
	const int					m_nOldStateProxies;
	
	const CSendProxyRecipients	*m_pNewStateProxies;
	const int					m_nNewStateProxies;

	// The output property list.
	CalcDeltaResultsList_t *m_pOutProps;

	int m_NewProxyProps[MAX_DATATABLE_PROPS+1];
	int m_nNewProxyProps;
};



// ----------------------------------------------------------------------------- //
// CDeltaCalculator encapsulates part of the functionality for calculating deltas between entity states.
//
// To use it, initialize it with the from and to states, then walk through the 'to' properties using
// SeekToNextToProp(). 
//
// At each 'to' prop, either call SkipToProp or CalcDelta
// ----------------------------------------------------------------------------- //
class CDeltaCalculator
{
public:

						CDeltaCalculator(
							CSendTablePrecalc *pPrecalc,
							const void *pFromState,
							const int nFromBits,
							const void *pToState,
							const int nToBits,
							int *pDeltaProps,
							int nMaxDeltaProps,
							const int objectID );
						
						~CDeltaCalculator();

	// Returns the next prop index in the 'to' buffer. Returns PROP_SENTINEL if there are no more.
	// If a valid property index is returned, you MUST call PropSkip() or PropCalcDelta() after calling this.
	int					SeekToNextProp();	

	// Ignore the current 'to' prop.
	void				PropSkip();

	// Seek the 'from' buffer up to the current property, determine if there is a delta, and
	// write the delta (and the property data) into the buffer if there is a delta.
	void				PropCalcDelta();

	// check if current propert is non zero, if so put it into delta indices list
	void				PropCalcNonZero();

	// Returns the number of deltas detected throughout the 
	int					GetNumDeltasDetected();
		

private:
	CSendTablePrecalc	*m_pPrecalc;

	bf_read				m_bfFromState;
	bf_read				m_bfToState;
	
	CDeltaBitsReader	m_FromBitsReader;
	CDeltaBitsReader	m_ToBitsReader;

	int					m_ObjectID;
	
	// Current property indices.
	int					m_iFromProp;
	int					m_iToProp;

	// Bit position into m_bfToState where the current prop (m_iToProp) starts.
	int					m_iToStateStart;

	// Output..
	int					*m_pDeltaProps;
	int					m_nMaxDeltaProps;
	int					m_nDeltaProps;
};


CDeltaCalculator::CDeltaCalculator(
	CSendTablePrecalc *pPrecalc,
	const void *pFromState,
	const int nFromBits,
	const void *pToState,
	const int nToBits,
	int *pDeltaProps,
	int nMaxDeltaProps,
	const int objectID ) 
	
	: m_bfFromState( "CDeltaCalculator->m_bfFromState", pFromState, Bits2Bytes( nFromBits ), nFromBits ),
	m_FromBitsReader( &m_bfFromState ),
	m_bfToState( "CDeltaCalculator->m_bfToState", pToState, Bits2Bytes( nToBits ), nToBits ),
	m_ToBitsReader( &m_bfToState )
{
	m_pPrecalc = pPrecalc;
	m_ObjectID = objectID;

	m_pDeltaProps = pDeltaProps;
	m_nMaxDeltaProps = nMaxDeltaProps;
	m_nDeltaProps = 0;
	
	// Walk through each property in the to state, looking for ones in the from 
	// state that are missing or that are different.
	if ( pFromState)
	{
		m_iFromProp = NextProp( &m_FromBitsReader );
	}
	else
	{
		m_iFromProp = PROP_SENTINEL;
	}
	
	m_iToProp = -1;
}


CDeltaCalculator::~CDeltaCalculator()
{
	// Make sure we didn't overflow.
	ErrorIfNot( 
		m_nDeltaProps <= m_nMaxDeltaProps, 
		( "SendTable_CalcDelta: overflowed props %d max %d on datatable '%s'.", m_nDeltaProps, m_nMaxDeltaProps, m_pPrecalc->GetSendTable()->GetName() ) 
		);

	ErrorIfNot( 
		!m_bfFromState.IsOverflowed(), 
		( "SendTable_CalcDelta: m_bfFromState overflowed %d max %d on datatable '%s'.", m_nDeltaProps, m_nMaxDeltaProps, m_pPrecalc->GetSendTable()->GetName() ) 
		);

	ErrorIfNot( 
		!m_bfToState.IsOverflowed(), 
		( "SendTable_CalcDelta: m_bfToState overflowed %d max %d on datatable '%s'.", m_nDeltaProps, m_nMaxDeltaProps, m_pPrecalc->GetSendTable()->GetName() ) 
		);

	// We may not have read to the end of our input bits, but we don't care.
	m_FromBitsReader.ForceFinished();
	m_ToBitsReader.ForceFinished();
}


inline int CDeltaCalculator::SeekToNextProp()
{
	m_iToProp = NextProp( &m_ToBitsReader );
	return m_iToProp;
}
		

inline void CDeltaCalculator::PropSkip()
{
	Assert( m_iToProp != -1 );
	SkipPropData( &m_bfToState, m_pPrecalc->GetProp( m_iToProp ) );
}

void CDeltaCalculator::PropCalcNonZero()
{
	const SendProp *pProp = m_pPrecalc->GetProp( m_iToProp );

	if ( !g_PropTypeFns[pProp->m_Type].IsEncodedZero( pProp, &m_bfToState ) )
	{
		// add non-zero property to index list
		if ( m_nDeltaProps < m_nMaxDeltaProps )
		{
			m_pDeltaProps[m_nDeltaProps] = m_iToProp;
		}
		++m_nDeltaProps;
	}
}

void CDeltaCalculator::PropCalcDelta()
{
	// Skip any properties in the from state that aren't in the to state.
	while ( m_iFromProp < m_iToProp )
	{
		SkipPropData( &m_bfFromState, m_pPrecalc->GetProp( m_iFromProp ) );
		m_iFromProp = NextProp( &m_FromBitsReader );
	}

	const SendProp *pProp = m_pPrecalc->GetProp( m_iToProp );

	int bChange = true;

	if ( m_iFromProp == m_iToProp )
	{
		// The property is in both states, so compare them and write the index 
		// if the states are different.
		bChange = g_PropTypeFns[pProp->m_Type].CompareDeltas( pProp, &m_bfFromState, &m_bfToState );
		
		// Seek to the next properties.
		m_iFromProp = NextProp( &m_FromBitsReader );
	}
	else
	{
		// Only the 'to' state has this property, so just skip its data and register a change.
		SkipPropData( &m_bfToState, pProp );
	}

	if ( bChange )
	{
		// Write the property index.
		if ( m_nDeltaProps < m_nMaxDeltaProps )
		{
			m_pDeltaProps[m_nDeltaProps] = m_iToProp;
			m_nDeltaProps++;
		}
	}
}


inline int CDeltaCalculator::GetNumDeltasDetected()
{
	return m_nDeltaProps;
}


// Returns true if bits are the same
static bool CompareBits( bf_read &from, bf_read &to, int numbits )
{
	unsigned int temp1, temp2;

	int remaining = numbits;
	while ( remaining > 0 )
	{
		int count = MIN( remaining, sizeof( unsigned int ) << 3 );
		temp1 = from.ReadUBitLong( count );
		temp2 = to.ReadUBitLong( count );
		if ( temp1 != temp2 )
			return false;
		remaining -= count;
	}

	return true;
}

// ----------------------------------------------------------------------------- //
// CEncodeInfo
// Used by SendTable_Encode.
// ----------------------------------------------------------------------------- //
class CEncodeInfo : public CServerDatatableStack
{
public:
	CEncodeInfo( CSendTablePrecalc *pPrecalc, unsigned char *pStructBase, int objectID ) :
	  CServerDatatableStack( pPrecalc, pStructBase, objectID )
	  {
	  }

public:

	CSerializedEntity *m_pEntity;

	bf_write	*m_pOut;
};


// ------------------------------------------------------------------------ //
// Globals.
// ------------------------------------------------------------------------ //

CUtlVector< SendTable* > g_SendTables;
#if CRC_SEND_TABLE_VERBOSE
CUtlVector< SendTable* > g_SendTablesReferenced;
#endif
CRC32_t	g_SendTableCRC = 0;



// ------------------------------------------------------------------------ //
// SendTable functions.
// ------------------------------------------------------------------------ //

bool s_debug_info_shown = false;
int  s_debug_bits_start = 0;


static inline void ShowEncodeDeltaWatchInfo( 
	const SendTable *pTable,
	const SendProp *pProp, 
	bf_read &buffer,
	const int objectID,
	const int index )
{
	if ( !ShouldWatchThisProp( pTable, objectID, pProp->GetName()) )
		return;
	
	static int lastframe = -1;
	if ( host_framecount != lastframe )
	{
		lastframe = host_framecount;
		ConDMsg( "E: delta entity: %i %s\n", objectID, pTable->GetName() );
	}

	// work on copy of bitbuffer
	bf_read copy = buffer;

	s_debug_info_shown = true;

	DecodeInfo info;
	info.m_pStruct = NULL;
	info.m_pData = NULL;
	info.m_pRecvProp = NULL;
	info.m_pProp = pProp;
	info.m_pIn = &copy;
	info.m_ObjectID = objectID;
	info.m_Value.m_Type = (SendPropType)pProp->m_Type;
	
	int startBit = copy.GetNumBitsRead();

	g_PropTypeFns[pProp->m_Type].Decode( &info );

	int bits = copy.GetNumBitsRead() - startBit;

	const char *type = g_PropTypeFns[pProp->m_Type].GetTypeNameString();
	const char *value = info.m_Value.ToString();

	ConDMsg( "+ %s %s, %s, index %i, bits %i, value %s\n", pTable->GetName(), pProp->GetName(), type, index, bits, value );
}



static inline void SendTable_EncodeProp( CEncodeInfo *pInfo, unsigned long iProp )
{
	// Write the index.
	// Encode it.
	const int iStartPos = pInfo->m_pOut->GetNumBitsWritten();

	pInfo->m_pEntity->AddPathAndOffset( iProp, iStartPos );

	const SendProp *pProp = pInfo->GetCurProp();

	// Call their proxy to get the property's value.
	DVariant var;

	pProp->GetProxyFn()( 
		pProp,
		pInfo->GetCurStructBase(), 
		pInfo->GetCurStructBase() + pProp->GetOffset(), 
		&var, 
		0, // iElement
		pInfo->GetObjectID()
		);

	g_PropTypeFns[pProp->m_Type].Encode( 
		pInfo->GetCurStructBase(), 
		&var, 
		pProp, 
		pInfo->m_pOut, 
		pInfo->GetObjectID()
		); 
}


static bool SendTable_IsPropZero( CEncodeInfo *pInfo, unsigned long iProp )
{
	const SendProp *pProp = pInfo->GetCurProp();

	// Call their proxy to get the property's value.
	DVariant var;
	
	pProp->GetProxyFn()( 
		pProp,
		pInfo->GetCurStructBase(), 
		pInfo->GetCurStructBase() + pProp->GetOffset(), 
		&var, 
		0, // iElement
		pInfo->GetObjectID()
		);

	return g_PropTypeFns[pProp->m_Type].IsZero( pInfo->GetCurStructBase(), &var, pProp );
}


int SendTable_CullPropsFromProxies( 
	const SendTable *pTable,
	
	const CalcDeltaResultsList_t &startProps,

	const int iClient,
	
	const CSendProxyRecipients *pOldStateProxies,
	const int nOldStateProxies, 
	
	const CSendProxyRecipients *pNewStateProxies,
	const int nNewStateProxies,
	
	CalcDeltaResultsList_t &outProps
	)
{
	Assert( !( nNewStateProxies && !pNewStateProxies ) );
	CPropCullStack stack( pTable->m_pPrecalc, iClient, pOldStateProxies, nOldStateProxies, pNewStateProxies, nNewStateProxies );
	
	stack.CullPropsFromProxies( startProps, outProps );

	ErrorIfNot( stack.GetNumOutProps() <= MAX_DATATABLE_PROPS, ("CullPropsFromProxies: overflow in '%s'.", pTable->GetName()) );
	return stack.GetNumOutProps();
}


// compares properties and writes delta properties, it ignores reciepients
int SendTable_WriteAllDeltaProps(
	const SendTable *pTable,					
	SerializedEntityHandle_t fromEntity, // Can be invalid
	SerializedEntityHandle_t toEntity,
	const int nObjectID,
	bf_write *pBufOut )
{
	CalcDeltaResultsList_t deltaProps;

	SendTable_CalcDelta( pTable, fromEntity, toEntity, nObjectID, deltaProps );

	// Write all properties.
	SendTable_WritePropList( 
		pTable,
		toEntity,
		pBufOut,				// output buffer
		nObjectID,
		&deltaProps );

	return deltaProps.Count();
}


bool SendTable_Encode(
	const SendTable *pTable,
	SerializedEntityHandle_t handle,
	const void *pStruct, 
	int objectID,
	CUtlMemory<CSendProxyRecipients> *pRecipients
	)
{
	CSerializedEntity *pEntity = reinterpret_cast< CSerializedEntity * >( handle );
	Assert( pEntity );
	pEntity->Clear();

	CSendTablePrecalc *pPrecalc = pTable->m_pPrecalc;
	ErrorIfNot( pPrecalc, ("SendTable_Encode: Missing m_pPrecalc for SendTable %s.", pTable->m_pNetTableName) );
	if ( pRecipients )
	{
		ErrorIfNot(	pRecipients->NumAllocated() >= pPrecalc->GetNumDataTableProxies(), ("SendTable_Encode: pRecipients array too small.") );
	}

	VPROF( "SendTable_Encode" );

	uint8 packedData[MAX_PACKEDENTITY_DATA];
	bf_write writeBuf( "CFlattenedSerializer::Encode writeBuf", packedData, sizeof( packedData ) );


	CServerDTITimer timer( pTable, SERVERDTI_ENCODE );

	// Setup all the info we'll be walking the tree with.
	CEncodeInfo info( pPrecalc, (unsigned char*)pStruct, objectID );

	info.m_pOut = &writeBuf;
	info.m_pEntity = pEntity;
	info.m_pRecipients = pRecipients;	// optional buffer to store the bits for which clients get what data.

	info.Init( false, false );

	const int iNumProps = pPrecalc->GetNumProps();

	//reserve memory for our path and offset information in our entity to avoid a lot of needless resizes
	info.m_pEntity->ReservePathAndOffsetMemory( iNumProps );

	for ( int iProp=0; iProp < iNumProps; iProp++ )
	{
		// skip if we don't have a valid prop proxy
		if ( !info.IsPropProxyValid( iProp ) )
			continue;

		info.SeekToProp( iProp );
		SendTable_EncodeProp( &info, iProp );
	}

	pEntity->PackWithFieldData( writeBuf.GetBasePointer(), writeBuf.GetNumBitsWritten() );

	return !writeBuf.IsOverflowed();
}

#ifdef PROP_SKIPPED_REPORT
static int s_skippedProps;
static int s_frameCount;

std::map<std::string, int> s_highProps;

const int kFrameReportInterval = 128;
const int kMinPropOffset = 200;
const int kReportLength = 10;
const bool bReportDetails = true;

void PrintPropSkippedReport()
{
	++s_frameCount;
	if ( s_frameCount < kFrameReportInterval )
		return;

	Msg( "%5d skipped props per frame\n", s_skippedProps / s_frameCount );
	s_frameCount = 0;
	s_skippedProps = 0;

	// Copy the data from s_highProps to a vector so that we can sort it by frequency.
	std::vector<std::pair<int, std::string>> sorted;
	for( auto data : s_highProps )
		sorted.push_back(std::pair<int, std::string>( data.second, data.first));
	std::sort( sorted.begin(), sorted.end() );
	std::reverse( sorted.begin(), sorted.end() );

	if ( bReportDetails )
	{
		for ( int i = 0; i < kReportLength && i < (int)sorted.size(); ++i )
		{
			Msg("      Sent %4d times, %s\n", sorted[i].first, sorted[i].second.c_str());
		}
	}

	s_highProps.clear();
}
#else
void PrintPropSkippedReport()
{
}
#endif

template< bool bDebugWatch >
void SendTable_WritePropList_Guts(
	const SendTable *pTable,
	SerializedEntityHandle_t toEntity,
	bf_write *pOut,
	const int objectID,
	CalcDeltaResultsList_t *pVecChanges // NULL == Send ALL! 
	)
{
	CSerializedEntity *pToEntity = (CSerializedEntity *)toEntity;
	if ( !pToEntity )
		return;

	CDeltaBitsWriter deltaBitsWriter( pOut );

	uint8 packedData[MAX_PACKEDENTITY_DATA];
	bf_write fieldDataBuf( "CFlattenedSerializer::WriteFieldList fieldDataBuf", packedData, sizeof( packedData ) );

	CSendTablePrecalc *pPrecalc = pTable->m_pPrecalc;

	if ( !pVecChanges || pVecChanges->Count() > 0 )
	{
		CSerializedEntityFieldIterator iterator( pToEntity );
		iterator.First();

		bf_read inputFieldData;
		inputFieldData.SetDebugName( "CFlattenedSerializer::WriteFieldList" );
		pToEntity->StartReading( inputFieldData );

		// Ok, they want to specify a small list of properties to check.
		CFieldPath toField = iterator.GetField();
		int i = 0;
		while ( !pVecChanges || i < pVecChanges->Count() )
		{
			if ( pVecChanges && toField < pVecChanges->Element( i ) )
			{
				// Keep nFieldIndex, nFieldCount, fieldPaths, and nextElement as local variables
				// instead of members of iterator to improve code-gen. Otherwise VC++ or gcc
				// will refetch some of them on each iteration.
				int nFieldIndex = iterator.GetIndex();
				int nFieldCount = pToEntity->GetFieldCount();
				const short* fieldPaths = pToEntity->GetFieldPaths();
				int nextElement = pVecChanges->Element(i);
				while ( toField < nextElement )
				{
#ifdef PROP_SKIPPED_REPORT
					++s_skippedProps;
#endif
					++nFieldIndex;
					if ( nFieldIndex >= nFieldCount )
						break;
					toField = fieldPaths[ nFieldIndex ];
				}
				// Update the state of iterator for the new index
				toField = iterator.SetIndex( nFieldIndex );
			}

			if ( toField == PROP_SENTINEL )
			{
				break;
			}
			else if ( !pVecChanges ||
				toField == pVecChanges->Element( i ) )
			{
				// See how many bits the data for this property takes up.
				int nTotalBits = iterator.GetLength();
				Assert( nTotalBits > 0 );
				inputFieldData.Seek( iterator.GetOffset() );

#ifdef PROP_SKIPPED_REPORT
					if ( toField > kMinPropOffset && pVecChanges && pVecChanges->Count() < 20 )
					{
						const SendProp *pProp = pPrecalc->GetProp( toField );
						char buffer[1000];
						V_sprintf_safe( buffer, "%s, field %d", pProp->GetName(), toField );
						s_highProps[ buffer ] += 1;
					}
#endif

				if ( bDebugWatch )
				{
					const SendProp *pProp = pPrecalc->GetProp( toField );
					Assert( pProp );
					ShowEncodeDeltaWatchInfo( pTable, pProp, inputFieldData, objectID, toField );
				}

				fieldDataBuf.WriteBitsFromBuffer( &inputFieldData, nTotalBits );

				TRACE_PACKET( ( "    Send Field (%s) = %d (%d bytes)\n", pPrecalc->GetProp( toField )->GetName(), nTotalBits, Bits2Bytes( nTotalBits ) ) );

				// Write the data into the output.
				deltaBitsWriter.WritePropIndex( toField );

				toField = iterator.Next();
			}

			++i;
		}
	}

	deltaBitsWriter.Finish();

	// Now append the field data to the stream of paths
	pOut->WriteBits( packedData, fieldDataBuf.GetNumBitsWritten() );
}

void SendTable_WritePropList(
	const SendTable *pTable,
	SerializedEntityHandle_t toEntity,
	bf_write *pOut,
	const int objectID,
	CalcDeltaResultsList_t *pVecChanges // NULL == Send ALL! 
	)
{
	bool bDebugWatch = Sendprop_UsingDebugWatch();
	if ( bDebugWatch )
	{
		s_debug_info_shown = false;
		s_debug_bits_start = pOut->GetNumBitsWritten();

		SendTable_WritePropList_Guts< true >( pTable, toEntity, pOut, objectID, pVecChanges );

		if ( s_debug_info_shown )
		{
			int  bits = pOut->GetNumBitsWritten() - s_debug_bits_start;
			ConDMsg( "= %i bits (%i bytes)\n", bits, Bits2Bytes(bits) );
		}
	}
	else
	{
		SendTable_WritePropList_Guts< false >( pTable, toEntity, pOut, objectID, pVecChanges );
	}
}


//given two data pointers and a bit range, this will determine if there is any difference between the bits. Note that this assumes that these can be interpreted as valid uint32's for speed
static inline bool DoesBitRangeMatch( const uint32* RESTRICT pOld, const uint32* RESTRICT pNew, uint32 nStartBit, uint32 nEndBit )
{
	//determine the starting index
	const uint32 nStartIndex	= nStartBit / 32;
	const uint32 nEndIndex		= ( nEndBit + 31 ) / 32;

	//determine bit overlaps
	const uint32 nStartIgnoreBits = nStartBit % 32;
	const uint32 nEndIgnoreBits   = nEndIndex * 32 - nEndBit;

	//now run through until we find a diff
	const uint32* pCurrOld = pOld + nStartIndex;
	const uint32* pCurrNew = pNew + nStartIndex;
	const uint32* pEndNew  = pNew + nEndIndex; 

	for(; pCurrNew != pEndNew; ++pCurrNew, ++pCurrOld )
	{
#if defined (_PS3) || defined (_X360)
        uint32 nDiff = DWordSwap((*pCurrNew ^ *pCurrOld));
#else
        uint32 nDiff = (*pCurrNew ^ *pCurrOld);
#endif
		if( nDiff )
		{
			//we have a diff, handle masking our range
			uint32 nDeltaStart = ( pCurrNew - pNew ) * 32;
			uint32 nDeltaEnd   = nDeltaStart + 32;

			if( nDeltaStart < nStartBit )
				nDiff &= ( 0xFFFFFFFF << nStartIgnoreBits );
			if( nEndBit < nDeltaEnd )
				nDiff &= ( 0xFFFFFFFF >> nEndIgnoreBits );

			if( nDiff )
				return false;
		}
	}

	//no difference
	return true;
}

//given a serialized entity and a property field, this will attempt to find the property field within that entity using the fact that field = index in nearly all cases. This will account for minor adjustments. If the
//serialized entities ever become sparse though, this should likely be replaced with a sorted iteration over the field, rather than this sparse lookup, but for now this is significantly faster. This will return -1 if
//the field is not in the entity
static inline int32 GetFieldIndex( const short* RESTRICT pFieldStart, const short* RESTRICT pFieldEnd, short nDesiredField )
{
	//determine our starting pointer (likely to be the field itself)
	const short* pCurr = MIN( pFieldEnd - 1, pFieldStart + nDesiredField );
	
	//check for a direct hit (most common case)
	if( *pCurr == nDesiredField )
		return (pCurr - pFieldStart);

	//determine the direction that we need to head
	if( *pCurr < nDesiredField )
	{
		//advance forward looking for a match (or when our numbers become larger than our target)
		for( pCurr++; ( pCurr < pFieldEnd ) && ( *pCurr <= nDesiredField ) ; pCurr++ )
		{
			if( *pCurr == nDesiredField )
				return (pCurr - pFieldStart);
		}
	}
	else
	{
		//move backwards (or when our numbers become smaller than our target)
		for( pCurr--; ( pCurr >= pFieldStart ) && ( *pCurr >= nDesiredField ) ; pCurr-- )
		{
			if( *pCurr == nDesiredField )
				return (pCurr - pFieldStart);
		}
	}

	//no match, hit the end of the list
	return -1;
}

//given an entity that has had a partial change, this will take the previous data block, and splice in the new values, setting new change fields to the specified tick for ones that have actually changed. This will
//return false if a delta table is not applicable and instead a full pack needs to be done
SerializedEntityHandle_t SendTable_BuildDeltaProperties( edict_t *pEdict, int nObjectID, const SendTable* pTable, SerializedEntityHandle_t oldProps, CalcDeltaResultsList_t &deltaProps, CUtlMemory<CSendProxyRecipients> *pRecipients, bool& bCanReuseOldData )
{
	const CSerializedEntity* RESTRICT pOldProps = ( const CSerializedEntity* )oldProps;
	
	//assume that we can't reuse the old frame for now
	bCanReuseOldData = false;

	// Setup all the info we'll be walking the tree with.
	CServerDatatableStack info( pTable->m_pPrecalc, (unsigned char*)pEdict->GetUnknown(), nObjectID );
	info.m_pRecipients = pRecipients;	// optional buffer to store the bits for which clients get what data.
	info.Init( false, false );

	//get the change list associated with this object
	const CEdictChangeInfo * RESTRICT pCI = &g_pSharedChangeInfo->m_ChangeInfos[ pEdict->GetChangeInfo() ];

	//cache our indices for our fields
	const uint32 nOldProps = pOldProps->GetFieldCount();
	const short* RESTRICT pFieldListStart	= pOldProps->GetFieldPaths();
	const short* RESTRICT pFieldListEnd		= pFieldListStart + nOldProps;
	
	//now copy over the old property block into our new buffer
	uint8 packedData[MAX_PACKEDENTITY_DATA];
	memcpy( packedData, pOldProps->GetFieldData(), Bits2Bytes( pOldProps->GetFieldDataBitCount() ) );
	bf_write fieldDataBuf( "BuildDeltaProperties fieldDataBuf", packedData, sizeof( packedData ) );

	//we now need to build a list of the properties that have changed, converting them over to indices, and sorting them
	for( uint32 nCurrOffset = 0; nCurrOffset < (uint32)pCI->m_nChangeOffsets; ++nCurrOffset )
	{
		int propOffsets[MAX_PROP_INDEX_OFFSETS];
		int numPropsMatchingIndex = pTable->m_pPrecalc->GetPropertyIndexFromOffset( pCI->m_ChangeOffsets[ nCurrOffset ], propOffsets );

		if ( !numPropsMatchingIndex )
		{
			continue;
		}

		for ( int propOffsetIndex = 0; propOffsetIndex < numPropsMatchingIndex; ++propOffsetIndex )
		{
			int nPropField = propOffsets[propOffsetIndex];

			//we can safely skip any properties that are not considered valid by the proxy
			if( !info.IsPropProxyValid( nPropField ) )
				continue;

			//we now need to map this property field to an index in our serialized entity
			int nFieldIndex = GetFieldIndex( pFieldListStart, pFieldListEnd, ( short )nPropField );
			//if we didn't find a match here, we have a problem of mismatch between the blocks and we need to fall back to the slow route
			if( nFieldIndex == -1 )
				return SERIALIZED_ENTITY_HANDLE_INVALID;

			//we have a match, so we need to splice this new property onto our original property
			const uint32 nPropBitStart = pOldProps->GetFieldDataBitOffset( nFieldIndex );
			const uint32 nPropBitEnd   = pOldProps->GetFieldDataBitEndOffset( nFieldIndex );
			fieldDataBuf.SeekToBit( nPropBitStart );
			info.SeekToProp( nPropField );

			const SendProp* RESTRICT pProp = pTable->m_pPrecalc->GetProp( nPropField );

			// Call their proxy to get the property's value.
			DVariant var;
			pProp->GetProxyFn()( 
				pProp, info.GetCurStructBase(), info.GetCurStructBase() + pProp->GetOffset(), 
				&var, 0, info.GetObjectID()	);

			//now write it out
			g_PropTypeFns[pProp->m_Type].Encode( 
				info.GetCurStructBase(), &var, pProp, 
				&fieldDataBuf, info.GetObjectID()	); 

			//handle if the property changed in size (does this happen? If so, we just need to fall back to the slow, slow route, and should return NULL)
			if( nPropBitEnd != ( uint32 )fieldDataBuf.GetNumBitsWritten() )
				return SERIALIZED_ENTITY_HANDLE_INVALID;

			//we now need to compare if we actually changed values between these bits
			if( !DoesBitRangeMatch( ( const uint32* )pOldProps->GetFieldData(), ( const uint32* )packedData, nPropBitStart, nPropBitEnd ) )
				deltaProps.AddToTail( nPropField );
		}
	}

	//if we have no changes, we can just reuse the old one, don't bother making a copy
	if( deltaProps.Count() == 0 )
	{
		bCanReuseOldData = true;
		return SERIALIZED_ENTITY_HANDLE_INVALID;
	}

	//at this point, we have all of our new data. So setup our new serialized version to return
	CSerializedEntity* RESTRICT pNewProps = (CSerializedEntity*)g_pSerializedEntities->AllocateSerializedEntity(__FILE__, __LINE__);
	pNewProps->SetupPackMemory( nOldProps, pOldProps->GetFieldDataBitCount() );

	//and blit on over
	memcpy( pNewProps->GetFieldPaths(), pOldProps->GetFieldPaths(), sizeof( uint16 ) * nOldProps );
	memcpy( pNewProps->GetFieldDataBitOffsets(), pOldProps->GetFieldDataBitOffsets(), sizeof( uint32 ) * nOldProps );
	memcpy( pNewProps->GetFieldData(), packedData, Bits2Bytes( pNewProps->GetFieldDataBitCount() ) );

	return ( SerializedEntityHandle_t )pNewProps;
}

static void BuildNonZeroDelta( const SendTable *pTable,
								const CSerializedEntity *pToEntity,
								const int objectID,
								CalcDeltaResultsList_t &deltaProps )
{
	//setup a reader for this data
	bf_read ToBits;
	pToEntity->StartReading( ToBits );

	//just run through each source property, and for each one that is non-zero, add it to the delta props
	const uint32 nNumProps = (uint32)pToEntity->GetFieldCount();
	for( uint32 nCurrProp = 0; nCurrProp < nNumProps; ++nCurrProp )
	{
		CFieldPath nPath = pToEntity->GetFieldPath( nCurrProp );
		ToBits.Seek(pToEntity->GetFieldDataBitOffset( nCurrProp ) );

		const SendProp *pProp = pTable->m_pPrecalc->GetProp( nPath );
		if ( !g_PropTypeFns[pProp->m_Type].IsEncodedZero( pProp, &ToBits ) )
		{
			// add non-zero property to index list
			deltaProps.AddToTail( nPath );
		}
	}
}

//given data, this will continue to advance the pointers so long as from = to, and will update the necessary values
static FORCEINLINE void AdvanceToNextChange( const uint32* RESTRICT pFrom, const uint32* RESTRICT pTo, uint32 nMaxInts, uint32* RESTRICT pnIntOffset, uint32* RESTRICT pnDataDiff, uint32* RESTRICT pnDataStartBit )
{
	const uint32* RESTRICT pEndFrom	= pFrom + nMaxInts;
	const uint32* RESTRICT pCurrFrom = pFrom + *pnIntOffset;
	const uint32* RESTRICT pCurrTo	= pTo + *pnIntOffset;

	for( ; pCurrFrom != pEndFrom; ++pCurrFrom, ++pCurrTo )
	{
		if( *pCurrFrom != *pCurrTo )
		{
#if defined(_PS3) || defined(_X360)
			*pnDataDiff = DWordSwap((*pCurrFrom ^ *pCurrTo));
#else
            *pnDataDiff = *pCurrFrom ^ *pCurrTo;
#endif
			break;
		}
	}

	*pnIntOffset	= ( pCurrFrom - pFrom );
	*pnDataStartBit = ( pCurrFrom - pFrom ) * 32;
}

//given a starting bit index, the dirty bit window, and the range that the property covers, this will determine if this property overlaps the dirty bit
static FORCEINLINE bool DoesPropertyOverlapDirtyBit( uint32 nDataStartBit, uint32 nFieldStartBit, uint32 nFieldEndBit, uint32 nDataDiff )
{
	//Note, we assume that any properties that share this integer with us have been tested prior, and as a result, also cleared out the data diff
	//when they checked so we do not need to mask off the lower bound
	Assert( nFieldEndBit > nDataStartBit );
	Assert( nDataStartBit + 32 > nFieldStartBit );

	//see if this integer spans the boundary where we end, if so, we need to only check the area that we cover
	uint32 nDataEndBit = nDataStartBit + 32;
	if( nFieldEndBit < nDataEndBit )
	{
		uint32 nEndBits = ( nDataEndBit - nFieldEndBit );
		Assert( nEndBits < 32 );
		uint32 nEndMask = ( 0xFFFFFFFF >> nEndBits );
		nDataDiff &= nEndMask;
	}

	return ( nDataDiff != 0 );
}

//this is a fast path that will handle scanning through the properties, identifying differences in the values. This will build a list of properties that
//have differing values, and if it encounters a misalignment between the two property lists (like a property added, removed, or changed in size) it will
//stop processing and return the property index it had to stop on so that the slower unaligned path can be used from that point on
static inline uint32 FastPathCalcDelta( const CSerializedEntity *pFromEntity, const CSerializedEntity *pToEntity, CalcDeltaResultsList_t &deltaProps )
{
	//cache common data
	const uint32 nFromFieldCount	= pFromEntity->GetFieldCount();
	const uint32 nToFieldCount		= pToEntity->GetFieldCount();

	const uint32* RESTRICT pFromData = (const uint32*)pFromEntity->GetFieldData();
	const uint32* RESTRICT pToData	= (const uint32*)pToEntity->GetFieldData();

	//determine how many integers we have in our buffer
	const uint32 nEndDataInts = ( MIN( pToEntity->GetFieldDataBitCount(), pFromEntity->GetFieldDataBitCount() ) + 31 ) / 32;

	//scan through our data to find the first area where we detect a change
	uint32 nIntOffset = 0;
	uint32 nDataDiff = 0;
	uint32 nDataStartBit = 0;
	AdvanceToNextChange( pFromData, pToData, nEndDataInts, &nIntOffset, &nDataDiff, &nDataStartBit );

	//handle a special case where all the data was the same
	if( ( nIntOffset == nEndDataInts ) && ( nFromFieldCount == nToFieldCount ) && ( pToEntity->GetFieldDataBitCount() == pFromEntity->GetFieldDataBitCount() ) )
	{
		//odds are very good that we have the same property layout, so just do an entire comparison of the values
		if( ( V_memcmp( pFromEntity->GetFieldDataBitOffsets(), pToEntity->GetFieldDataBitOffsets(), nFromFieldCount * sizeof( uint32 ) ) == 0 ) && 
			( V_memcmp( pFromEntity->GetFieldPaths(), pToEntity->GetFieldPaths(), nFromFieldCount * sizeof( short ) ) == 0 ) )
		{
			return nFromFieldCount;
		}
		//the field layout wasn't the same. VERY rare, fall through and let the function below catch where
	}

	//determine how many overlapping fields we can test against
	uint32 nMinFieldOverlap = MIN( nFromFieldCount, nToFieldCount );
	if( nMinFieldOverlap == 0 )
		return 0;

	//pointers to each of the data blocks we are reading from
	const short* RESTRICT pFromPath		= pFromEntity->GetFieldPaths();
	const short* RESTRICT pToPath		= pToEntity->GetFieldPaths();
	//since we want the END of the properties for most operations
	const uint32* RESTRICT pFromStartOffset	= pFromEntity->GetFieldDataBitOffsets();
	const uint32* RESTRICT pFromEndOffset	= pFromEntity->GetFieldDataBitOffsets() + 1;
	const uint32* RESTRICT pToEndOffset		= pToEntity->GetFieldDataBitOffsets() + 1;


	//run through all the properties...except the last one. The reason for this is because we don't want to have to range check on all of our property bit offsets
	uint32 nLastField = nMinFieldOverlap - 1;
	for(uint32 nCurrField = 0 ; nCurrField < nLastField; ++nCurrField )
	{
		//extract information about our fields to make sure that they match
		const CFieldPath nFromPath	= pFromPath[ nCurrField ];
		const CFieldPath nToPath	= pToPath[ nCurrField ];
		const uint32 nFromEnd		= pFromEndOffset[ nCurrField ];
		const uint32 nToEnd			= pToEndOffset[ nCurrField ];
		
		//we can do the fast path so long as the field indices match (no dropped properties) and the offsets are the same (which creates unaligned properties)
		if( ( nFromPath != nToPath ) || ( nFromEnd != nToEnd ) ) 
			return nCurrField;

		//see if we have completely clear data already (we have clear data already past where we end)
		if( nDataStartBit >= nFromEnd )
			continue;

		//we can now tell if we have a dirty prop
		if( DoesPropertyOverlapDirtyBit( nDataStartBit, pFromStartOffset[ nCurrField ], nFromEnd, nDataDiff ) )
			deltaProps.AddToTail( nFromPath );
				
		//and handle reading to the next diff which is either at the end of our property, or the next integer if we have no more dirty bits in this one
		uint32 nPropEndInt = nFromEnd / 32;
		if( nPropEndInt > nIntOffset )
		{
			//we have advanced past our previous buffer, so scan to our next change
			nIntOffset = nPropEndInt;
			AdvanceToNextChange( pFromData, pToData, nEndDataInts, &nIntOffset, &nDataDiff, &nDataStartBit );
		}
		
		//the property may have dirty data in its last section, so see if we overlap, if so, clear our portion, and see if we need to continue the scan
		if( nIntOffset == nPropEndInt )
		{
			//clear any portion of this integer that we overlap with
			uint32 nOverlapBits = nFromEnd - nDataStartBit;
			Assert( nOverlapBits < 32 );
			uint32 nKeepMask	= 0xFFFFFFFFF << nOverlapBits;
			nDataDiff &= nKeepMask;

			//and if we have no more dirty data in the integer, we need to scan to the next change
			if( nDataDiff == 0 )
			{
				nIntOffset++;
				AdvanceToNextChange( pFromData, pToData, nEndDataInts, &nIntOffset, &nDataDiff, &nDataStartBit );
			}		
		}
	}

	//and test our last one
	{
		//extract information about our fields to make sure that they match
		const CFieldPath nFromPath	= pFromPath[ nLastField ];
		const CFieldPath nToPath	= pToPath[ nLastField ];
		const uint32 nFromEnd		= pFromEntity->GetFieldDataBitCount();
		const uint32 nToEnd			= pToEntity->GetFieldDataBitCount();

		//we can do the fast path so long as the field indices match (no dropped properties) and the offsets are the same (which creates unaligned properties)
		if( ( nFromPath != nToPath ) || ( nFromEnd != nToEnd ) ) 
			return nLastField;

		//see if we have completely clear data already (we have clear data already past where we end)
		if( nDataStartBit < nFromEnd )
		{
			//we can now tell if we have a dirty prop
			if( DoesPropertyOverlapDirtyBit( nDataStartBit, pFromStartOffset[ nLastField ], nFromEnd, nDataDiff ) )
				deltaProps.AddToTail( nFromPath );
		}
	}

	//let the caller know how many properties we took care of
	return nMinFieldOverlap;
}

//this will handle further delta detection on the properties using a much slower approach to handle misalignments
static void SlowPathCompareProps( const CSerializedEntity *pFromEntity, const CSerializedEntity *pToEntity, uint32 nStartField, CalcDeltaResultsList_t &deltaProps )
{
	//run through each of our target properties that we have left
	const uint32 nNumToFields	= ( uint32 )pToEntity->GetFieldCount();
	const uint32 nNumFromFields = ( uint32 )pFromEntity->GetFieldCount();
	
	uint32 nCurrFromField = nStartField;

	bf_read ToData, FromData;
	pToEntity->StartReading( ToData );
	pFromEntity->StartReading( FromData );

	for( uint32 nCurrToField = nStartField; nCurrToField < nNumToFields; ++nCurrToField )
	{
		//get our path for our target property
		const CFieldPath nToPath = pToEntity->GetFieldPath( nCurrToField );

		//find a possible match in our from path
		for( ; ( nCurrFromField < nNumFromFields ) && ( pFromEntity->GetFieldPath( nCurrFromField ) < nToPath ) ;  nCurrFromField++ )
		{
		}

		//handle the case where this is a new property
		if( ( nCurrFromField < nNumFromFields ) && ( pFromEntity->GetFieldPath( nCurrFromField ) == nToPath ) )
		{
			//position our buffers to the start of each property
			uint32 nToDataStartBit		= pToEntity->GetFieldDataBitOffset( nCurrToField );
			uint32 nFromDataStartBit	= pFromEntity->GetFieldDataBitOffset( nCurrFromField );
			uint32 nToDataSize			= pToEntity->GetFieldDataBitEndOffset( nCurrToField ) - nToDataStartBit;
			uint32 nFromDataSize		= pFromEntity->GetFieldDataBitEndOffset( nCurrFromField ) - nFromDataStartBit;

			ToData.Seek( nToDataStartBit );
			FromData.Seek( nFromDataStartBit );
						
			if( ( nToDataSize != nFromDataSize ) || !CompareBits( FromData, ToData, nToDataSize ) )
			{
				deltaProps.AddToTail( nToPath );
			}
		}
		else
		{
			//this is a new property that we need to encode
			deltaProps.AddToTail( nToPath );
		}
	}
}

void SendTable_CalcDelta(
	const SendTable *pTable,
	SerializedEntityHandle_t fromEntity, // can be null
	SerializedEntityHandle_t toEntity,
	const int objectID,
	CalcDeltaResultsList_t &deltaProps )
{
	const CSerializedEntity *pFromEntity = (CSerializedEntity *)fromEntity;
	const CSerializedEntity *pToEntity = (CSerializedEntity *)toEntity;

	//if we don't have a from entity, the problem domain is to just go through the current entity and build a change list of which properties are non-zero
	if( pFromEntity == NULL )
	{
		BuildNonZeroDelta( pTable, pToEntity, objectID, deltaProps );
		return;
	}

	//fast path compare as many properties as we can, this handles the vast majority of properties which only have value changes
	uint32 nFastPathProps = FastPathCalcDelta( pFromEntity, pToEntity, deltaProps );

	//see if we have any properties not yet checked, meaning we had differences in the property layout
	if( nFastPathProps < ( uint32 )pToEntity->GetFieldCount() )
	{	
		//now we need to fall back to the slow path for the remaining un-aligned data, this will either have zero iterations (made it all the way through with fast properties),
		//or will cover all the properties after a divergence
		SlowPathCompareProps( pFromEntity, pToEntity, nFastPathProps, deltaProps );
	}
}

bool SendTable_WriteInfos( const SendTable *pTable, bf_write& bfWrite, bool bNeedsDecoder, bool bIsEnd )
{
	CSVCMsg_SendTable_t msg;

	if( !pTable || bIsEnd )
	{
		// Write the end bit to signal no more send tables
		Assert( !pTable && bIsEnd );
		msg.set_is_end( true );
		return msg.WriteToBuffer( bfWrite );
	}

	if ( bNeedsDecoder ) // only set if true, let the default false
	{
		msg.set_needs_decoder( bNeedsDecoder );
	}

	msg.set_net_table_name( pTable->GetName() );

	// Send each property.
	for ( int iProp=0; iProp < pTable->m_nProps; iProp++ )
	{
		const SendProp *pProp = &pTable->m_pProps[iProp];
		CSVCMsg_SendTable::sendprop_t *pSendProp = msg.add_props();

		pSendProp->set_type( pProp->m_Type );
		pSendProp->set_var_name( pProp->GetName() );
		// we now have some flags that aren't networked so strip them off
		unsigned int networkFlags = pProp->GetFlags() & ((1<<SPROP_NUMFLAGBITS_NETWORKED)-1);
		pSendProp->set_flags( networkFlags );
		pSendProp->set_priority( pProp->GetPriority() );

		if( pProp->m_Type == DPT_DataTable )
		{
			// Just write the name and it will be able to reuse the table with a matching name.
			pSendProp->set_dt_name( pProp->GetDataTable()->m_pNetTableName );
		}
		else if ( pProp->IsExcludeProp() )
		{
			pSendProp->set_dt_name( pProp->GetExcludeDTName() );
		}
		else if ( pProp->GetType() == DPT_Array )
		{
			pSendProp->set_num_elements( pProp->GetNumElements() );
		}
		else
		{			
			pSendProp->set_low_value( pProp->m_fLowValue );
			pSendProp->set_high_value( pProp->m_fHighValue );
			pSendProp->set_num_bits( pProp->m_nBits );
		}
	}

	return msg.WriteToBuffer( bfWrite );
}

// Spits out warnings for invalid properties and forces property values to
// be in valid ranges for the encoders and decoders.
static void SendTable_Validate( CSendTablePrecalc *pPrecalc )
{
	SendTable *pTable = pPrecalc->m_pSendTable;
	for( int i=0; i < pTable->m_nProps; i++ )
	{
		SendProp *pProp = &pTable->m_pProps[i];
		
		if ( pProp->GetArrayProp() )
		{
			if ( pProp->GetArrayProp()->GetType() == DPT_DataTable )
			{
				Error( "Invalid property: %s/%s (array of datatables) [on prop %d of %d (%s)].", pTable->m_pNetTableName, pProp->GetName(), i, pTable->m_nProps, pProp->GetArrayProp()->GetName() );
			}
		}
		else
		{
			ErrorIfNot( pProp->GetNumElements() == 1, ("Prop %s/%s has an invalid element count for a non-array.", pTable->m_pNetTableName, pProp->GetName()) );
		}
			
		// Check for 1-bit signed properties (their value doesn't get down to the client).
		if ( pProp->m_nBits == 1 && !(pProp->GetFlags() & SPROP_UNSIGNED) )
		{
			DataTable_Warning("SendTable prop %s::%s is a 1-bit signed property. Use SPROP_UNSIGNED or the client will never receive a value.\n", pTable->m_pNetTableName, pProp->GetName());
		}
	}

	for ( int i = 0; i < pPrecalc->GetNumProps(); ++i )
	{
		const SendProp *pProp = pPrecalc->GetProp( i );
		if ( pProp->GetFlags() & SPROP_ENCODED_AGAINST_TICKCOUNT )
		{
			pTable->SetHasPropsEncodedAgainstTickcount( true );
			break;
		}
	}
}


static void SendTable_CalcNextVectorElems( SendTable *pTable )
{
	for ( int i=0; i < pTable->GetNumProps(); i++ )
	{
		SendProp *pProp = pTable->GetProp( i );
		
		if ( pProp->GetType() == DPT_DataTable )
		{
			SendTable_CalcNextVectorElems( pProp->GetDataTable() );
		}
		else if ( pProp->GetOffset() < 0 )
		{
			pProp->SetOffset( -pProp->GetOffset() );
			pProp->SetFlags( pProp->GetFlags() | SPROP_IS_A_VECTOR_ELEM );
		}
	}
}

// This helps us figure out which properties can use the super-optimized mode
// where they are tracked in a list when they change. If their m_pProxies pointers
// are set to 1, then it means that this property is gotten to by means of SendProxy_DataTableToDataTable.
// If it's set to 0, then we can't directly take the property's offset.
class CPropOffsetStack : public CDatatableStack
{
public:
	CPropOffsetStack( CSendTablePrecalc *pPrecalc ) :
		CDatatableStack( pPrecalc, NULL, -1 )
	{
		m_pPropMapStackPrecalc = pPrecalc;
	}

	inline unsigned char*	CallPropProxy( CSendNode *pNode, int iProp, unsigned char *pStructBase )
	{
		const SendProp *pProp = m_pPropMapStackPrecalc->GetDatatableProp( iProp );
		return pStructBase + pProp->GetOffset();


	}

	virtual void RecurseAndCallProxies( CSendNode *pNode, unsigned char *pStructBase )
	{
		// Remember where the game code pointed us for this datatable's data so 
		m_pProxies[ pNode->GetRecursiveProxyIndex() ] = pStructBase;

		for ( int iChild=0; iChild < pNode->GetNumChildren(); iChild++ )
		{
			CSendNode *pCurChild = pNode->GetChild( iChild );
			
			unsigned char *pNewStructBase = CallPropProxy( pCurChild, pCurChild->m_iDatatableProp, pStructBase );

			RecurseAndCallProxies( pCurChild, pNewStructBase );
		}
	}

public:
	CSendTablePrecalc *m_pPropMapStackPrecalc;
};

static void BuildPropOffsetToIndexMap( CSendTablePrecalc *pPrecalc )
{
	CPropOffsetStack pmStack( pPrecalc );
	pmStack.Init( false, false );

	const int nNumProps = pPrecalc->m_Props.Count();
	
	pPrecalc->m_PropOffsetToIndex.SetSize( nNumProps );

	for ( int i=0; i < nNumProps; i++ )
	{
		pmStack.SeekToProp( i );

		const SendProp *pProp = pPrecalc->m_Props[i];
		int offset = size_cast<int>( pProp->GetOffset() + (intp)pmStack.GetCurStructBase() );

		pPrecalc->m_PropOffsetToIndex[ i ].m_nIndex		= i;
		pPrecalc->m_PropOffsetToIndex[ i ].m_nOffset	= offset;
	}

	//now sort our list to ensure it is efficient for lookup
	std::sort( pPrecalc->m_PropOffsetToIndex.Base(), pPrecalc->m_PropOffsetToIndex.Base() + pPrecalc->m_PropOffsetToIndex.Count() );
}

static bool SendTable_InitTable( SendTable *pTable )
{
	if( pTable->m_pPrecalc )
		return true;
	
	// Create the CSendTablePrecalc.	
	CSendTablePrecalc *pPrecalc = new CSendTablePrecalc;
	pTable->m_pPrecalc = pPrecalc;

	pPrecalc->m_pSendTable = pTable;
	pTable->m_pPrecalc = pPrecalc;

	SendTable_CalcNextVectorElems( pTable );

	// Bind the instrumentation if -dti was specified.
	pPrecalc->m_pDTITable = ServerDTI_HookTable( pTable );

	// Setup its flat property array.
	if ( !pPrecalc->SetupFlatPropertyArray() )
		return false;

	BuildPropOffsetToIndexMap( pPrecalc );

	SendTable_Validate( pPrecalc );
	return true;
}


static void SendTable_TermTable( SendTable *pTable )
{
	if( !pTable->m_pPrecalc )
		return;

	delete pTable->m_pPrecalc;
	Assert( !pTable->m_pPrecalc ); // Make sure it unbound itself.
}


int SendTable_GetNumFlatProps( const SendTable *pSendTable )
{
	const CSendTablePrecalc *pPrecalc = pSendTable->m_pPrecalc;
	ErrorIfNot( pPrecalc,
		("SendTable_GetNumFlatProps: missing pPrecalc.")
	);
	return pPrecalc->GetNumProps();
}

CRC32_t SendTable_CRCTable( CRC32_t &crc, SendTable *pTable )
{
	CRC32_ProcessBuffer( &crc, (void *)pTable->m_pNetTableName, Q_strlen( pTable->m_pNetTableName) );
	CRCMSG( "Table: %s\n", pTable->m_pNetTableName );

	int nProps = LittleLong( pTable->m_nProps );
	CRC32_ProcessBuffer( &crc, (void *)&nProps, sizeof( pTable->m_nProps ) );
	CRCMSG( "  nProps: " CRCFMT4 "\n", CRCMEM4( nProps ) );

	// Send each property.
	for ( int iProp=0; iProp < pTable->m_nProps; iProp++ )
	{
		const SendProp *pProp = &pTable->m_pProps[iProp];

		int type = LittleLong( pProp->m_Type );
		CRC32_ProcessBuffer( &crc, (void *)&type, sizeof( type ) );
		CRC32_ProcessBuffer( &crc, (void *)pProp->GetName() , Q_strlen( pProp->GetName() ) );

		int flags = LittleLong( pProp->GetFlags() );
		CRC32_ProcessBuffer( &crc, (void *)&flags, sizeof( flags ) );

		CRCMSG( "  %d. %s : type = " CRCFMT4 ", flags = " CRCFMT4 ", bits = %d\n",
			iProp, pProp->GetName(),
			CRCMEM4( type ), CRCMEM4( flags ), pProp->m_nBits );

		if( pProp->m_Type == DPT_DataTable )
		{
			CRC32_ProcessBuffer( &crc, (void *)pProp->GetDataTable()->m_pNetTableName, Q_strlen( pProp->GetDataTable()->m_pNetTableName ) );
			CRCMSG( "      DPT_DataTable: %s\n", pProp->GetDataTable()->m_pNetTableName );
			
			if ( SendProp *pArrayPropInside = pProp->GetArrayProp() )
			{
				int arPropType = pArrayPropInside->m_Type;
				int arPropFlags = pArrayPropInside->GetFlags();
				int arElementsCount = pProp->GetDataTable()->m_nProps;
				CRC32_ProcessBuffer( &crc, (void *)&arPropType, sizeof( arPropType ) );
				CRC32_ProcessBuffer( &crc, (void *)&arPropFlags, sizeof( arPropFlags ) );
				CRCMSG( "      ArrayPropData: type = " CRCFMT4 ", flags = " CRCFMT4 ", bits = %d, size = %d\n",
					CRCMEM4( arPropType ), CRCMEM4( arPropFlags ), pArrayPropInside->m_nBits, arElementsCount );
			}
			#if CRC_SEND_TABLE_VERBOSE
			else if ( StringHasPrefixCaseSensitive( pProp->GetDataTable()->m_pNetTableName, "_ST_" ) )
			{
				SendProp *pArrayPropInside = pProp->GetDataTable()->GetProp( 1 );
				int arPropType = pArrayPropInside->m_Type;
				int arPropFlags = pArrayPropInside->GetFlags();
				int arElementsCount = pProp->GetDataTable()->m_nProps - 1; // first is length proxy
				CRC32_ProcessBuffer( &crc, ( void * ) &arPropType, sizeof( arPropType ) );
				CRC32_ProcessBuffer( &crc, ( void * ) &arPropFlags, sizeof( arPropFlags ) );
				CRCMSG( "      UtlVectorData: type = " CRCFMT4 ", flags = " CRCFMT4 ", bits = %d, size = %d\n",
					CRCMEM4( arPropType ), CRCMEM4( arPropFlags ), pArrayPropInside->m_nBits, arElementsCount );
			}
			else
			{
				SendTable *pSendTableReferenced = pProp->GetDataTable();
				if ( ( g_SendTables.Find( pSendTableReferenced ) == g_SendTables.InvalidIndex() )
					&& ( g_SendTablesReferenced.Find( pSendTableReferenced ) == g_SendTablesReferenced.InvalidIndex() ) )
					g_SendTablesReferenced.AddToTail( pSendTableReferenced );
			}
			#endif
		}
		else
		{
			if ( pProp->IsExcludeProp() )
			{
				CRC32_ProcessBuffer( &crc, (void *)pProp->GetExcludeDTName(), Q_strlen( pProp->GetExcludeDTName() ) );
				CRCMSG( "      ExcludeProp: %s\n", pProp->GetExcludeDTName() );
			}
			else if ( pProp->GetType() == DPT_Array )
			{
				int numelements = LittleLong( pProp->GetNumElements() );
				CRC32_ProcessBuffer( &crc, (void *)&numelements, sizeof( numelements ) );
				CRCMSG( "      DPT_Array: " CRCFMT4 "\n", CRCMEM4( numelements ) );
			}
			else
			{	
				float lowvalue;
				LittleFloat( &lowvalue, &pProp->m_fLowValue );
				CRC32_ProcessBuffer( &crc, (void *)&lowvalue, sizeof( lowvalue ) );

				float highvalue;
				LittleFloat( &highvalue, &pProp->m_fHighValue );
				CRC32_ProcessBuffer( &crc, (void *)&highvalue, sizeof( highvalue ) );

				int	bits = LittleLong( pProp->m_nBits );
				CRC32_ProcessBuffer( &crc, (void *)&bits, sizeof( bits ) );

				CRCMSG( "      DPT: lv " CRCFMT4 ", hv " CRCFMT4 ", bits " CRCFMT4 "\n",
					CRCMEM4( lowvalue ), CRCMEM4( highvalue ), CRCMEM4( bits ) );
			}
		}
	}

	return crc;
}

void SendTable_PrintStats( void )
{
	int numTables = 0;
	int numFloats = 0;
	int numStrings = 0;
	int numArrays = 0;
	int numInts = 0;
	int numVecs = 0;
	int numVecXYs = 0;
	int numSubTables = 0;
	int numSendProps = 0;
	int numFlatProps = 0;
	int numExcludeProps = 0;

	for ( int i=0; i < g_SendTables.Count(); i++ )
	{
		SendTable *st =  g_SendTables[i];
		
		numTables++;
		numSendProps += st->GetNumProps();
		numFlatProps += st->m_pPrecalc->GetNumProps();

		for ( int j=0; j < st->GetNumProps(); j++ )
		{
			SendProp* sp = st->GetProp( j );

			if ( sp->IsExcludeProp() )
			{
				numExcludeProps++;
				continue; // no real sendprops
			}

			if ( sp->IsInsideArray() )
				continue;

			switch( sp->GetType() )
			{
				case DPT_Int	: numInts++; break;
				case DPT_Float	: numFloats++; break;
				case DPT_Vector : numVecs++; break;
				case DPT_VectorXY : numVecXYs++; break;
				case DPT_String : numStrings++; break;
				case DPT_Array	: numArrays++; break;
				case DPT_DataTable : numSubTables++; break;
			}
		}
	}

	Msg("Total Send Table stats\n");
	Msg("Send Tables   : %i\n", numTables );
	Msg("Send Props    : %i\n", numSendProps );
	Msg("Flat Props    : %i\n", numFlatProps );
	Msg("Int Props     : %i\n", numInts );
	Msg("Float Props   : %i\n", numFloats );
	Msg("Vector Props  : %i\n", numVecs );
	Msg("VectorXY Props: %i\n", numVecXYs );
	Msg("String Props  : %i\n", numStrings );
	Msg("Array Props   : %i\n", numArrays );
	Msg("Table Props   : %i\n", numSubTables );
	Msg("Exclu Props   : %i\n", numExcludeProps );
}



bool SendTable_Init( SendTable **pTables, int nTables )
{
	ErrorIfNot( g_SendTables.Count() == 0,
		("SendTable_Init: called twice.")
	);

	bool bFullSendTableInfo = false;
	if ( !IsRetail() )
	{
		bFullSendTableInfo = ( CommandLine()->FindParm("-dtix" ) != 0 );
	}

	// Initialize them all.
	for ( int i=0; i < nTables; i++ )
	{
		if ( !SendTable_InitTable( pTables[i] ) )
			return false;

		if ( bFullSendTableInfo && pTables[i] )
			Msg( "SendTable[%03d] = %s\n", i, pTables[i]->GetName() );
	}

	// Store off the SendTable list.
	g_SendTables.CopyArray( pTables, nTables );

	g_SendTableCRC = SendTable_ComputeCRC( );

	if ( CommandLine()->FindParm("-dti" ) )
	{
		SendTable_PrintStats();
	}

	return true;	
}
void SendTable_Term()
{
	// Term all the SendTables.
	for ( int i=0; i < g_SendTables.Count(); i++ )
		SendTable_TermTable( g_SendTables[i] );

	// Clear the list of SendTables.
	g_SendTables.Purge();
	g_SendTableCRC = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Computes the crc for all sendtables for the data sent in the class/table definitions
// Output : CRC32_t
//-----------------------------------------------------------------------------
CRC32_t SendTable_ComputeCRC()
{
	CRCMSG( "-----------------------------------------------------\n" );
	CRCMSG( "----------------SendTable_ComputeCRC-----------------\n" );
	CRCMSG( "-----------------------------------------------------\n" );

	CRC32_t result;
	CRC32_Init( &result );

	// walk the tables and checksum them
	int c = g_SendTables.Count();
	for ( int i = 0 ; i < c; i++ )
	{
		SendTable *st = g_SendTables[ i ];
		result = SendTable_CRCTable( result, st );
	}

#if CRC_SEND_TABLE_VERBOSE
	for ( int i = 0; i < g_SendTablesReferenced.Count(); i++ )
	{
		SendTable *st = g_SendTablesReferenced[ i ];
		result = SendTable_CRCTable( result, st );
	}
#endif

	CRC32_Final( &result );
	
	CRCMSG( "-----------------------------------------------------\n" );
	CRCMSG( "-------------------CRC=%08X----------------------\n", result );
	CRCMSG( "-----------------------------------------------------\n" );

	return result;
}

SendTable *SendTabe_GetTable(int index)
{
	return  g_SendTables[index];
}

int	SendTable_GetNum()
{
	return g_SendTables.Count();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : CRC32_t
//-----------------------------------------------------------------------------
CRC32_t SendTable_GetCRC()
{
	return g_SendTableCRC;
}


//-----------------------------------------------------------------------------
// Purpose: check integrity of an unpacked entity send table
//-----------------------------------------------------------------------------
bool SendTable_CheckIntegrity( SendTable *pTable, const void *pData, const int nDataBits )
{
#ifdef _DEBUG
	if ( pData == NULL && nDataBits == 0 )
		return true;

	bf_read bfRead(	"SendTable_CheckIntegrity", pData, Bits2Bytes(nDataBits), nDataBits );
	CDeltaBitsReader bitsReader( &bfRead );

	int iProp = PROP_SENTINEL;
	int iLastProp = -1;
	int nMaxProps = pTable->m_pPrecalc->GetNumProps();
	int nPropCount = 0;

	Assert( nMaxProps > 0 && nMaxProps < MAX_DATATABLE_PROPS );

	while( -1 != (iProp = bitsReader.ReadNextPropIndex()) )
	{
		Assert( (iProp>=0) && (iProp<nMaxProps) );

		// must be larger
		Assert( iProp > iLastProp );

		const SendProp *pProp = pTable->m_pPrecalc->GetProp( iProp );

		Assert( pProp );

		// ok check that SkipProp & IsEncodedZero read the same bit length
		int iStartBit = bfRead.GetNumBitsRead();
		g_PropTypeFns[ pProp->GetType() ].SkipProp( pProp, &bfRead );
		int nLength = bfRead.GetNumBitsRead() - iStartBit;

		Assert( nLength > 0 ); // a prop must have some bits

		bfRead.Seek( iStartBit ); // read it again

		g_PropTypeFns[ pProp->GetType() ].IsEncodedZero( pProp, &bfRead );

		Assert( nLength == (bfRead.GetNumBitsRead() - iStartBit) ); 

		nPropCount++;
		iLastProp = iProp;
	}

	Assert( nPropCount <= nMaxProps );
	Assert( bfRead.GetNumBytesLeft() < 4 ); 
	Assert( !bfRead.IsOverflowed() );

#endif

	return true;
}