RecvProp RecvPropQuaternion(
char *pVarName,
int offset,
int sizeofVar, // Handled by RECVINFO macro, but set to SIZEOF_IGNORE if you don't want to bother.
int flags,
RecvVarProxyFn varProxy
)
{
RecvProp ret;
#ifdef _DEBUG
if ( varProxy == RecvProxy_QuaternionToQuaternion )
{
Assert( sizeofVar == sizeof( Quaternion ) );
}
#endif
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_Quaternion;
ret.m_Flags = flags;
ret.SetProxyFn( varProxy );
return ret;
}
RecvProp RecvPropFloat(
char *pVarName,
int offset,
int sizeofVar,
int flags,
RecvVarProxyFn varProxy
)
{
RecvProp ret;
#ifdef _DEBUG
if ( varProxy == RecvProxy_FloatToFloat )
{
Assert( sizeofVar == 0 || sizeofVar == 4 );
}
#endif
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_Float;
ret.m_Flags = flags;
ret.SetProxyFn( varProxy );
return ret;
}
RecvProp RecvPropVector(
char *pVarName,
int offset,
int sizeofVar,
int flags,
RecvVarProxyFn varProxy
)
{
RecvProp ret;
#ifdef _DEBUG
if ( varProxy == RecvProxy_VectorToVector )
{
Assert( sizeofVar == sizeof( Vector ) );
}
#endif
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_Vector;
ret.m_Flags = flags;
ret.SetProxyFn( varProxy );
return ret;
}
void RecurseClientTable( RecvTable *pTable, int &spacing )
{
RecvTable *pRecvTable = pTable;
if (pRecvTable == NULL){
spacing--;
return;
}
char TableName[128];
int size = sizeof(TableName);
memset( TableName, 0, size );
for (int i = 0; i < spacing; i++)
V_strcat( TableName, " |", size );
V_strcat( TableName, pRecvTable->GetName(), size );
Msg( "%s\n", TableName );
spacing++;
int num = pRecvTable->GetNumProps();
for (int i = 0; i < num; i++)
{
RecvProp *pProp = pRecvTable->GetProp(i);
memset( TableName, 0, sizeof(TableName) );
for (int j = 0; j < spacing; j++)
V_strcat( TableName, " |", size );
V_strcat( TableName, pProp->GetName(), size );
Msg( "%s\n", TableName );
RecurseClientTable( pProp->GetDataTable(), ++spacing );
}
spacing-=2;
}
RecvProp InternalRecvPropArray(
const int elementCount,
const int elementStride,
char *pName,
ArrayLengthRecvProxyFn proxy
)
{
RecvProp ret;
ret.InitArray( elementCount, elementStride );
ret.m_pVarName = pName;
ret.SetArrayLengthProxy( proxy );
return ret;
}
bool Entities::RetrieveClassPropOffset(std::string className, std::vector<std::string> propertyTree) {
std::string propertyString = ConvertTreeToString(propertyTree);
if (classPropOffsets[className].find(propertyString) != classPropOffsets[className].end()) {
return true;
}
ClientClass *cc = Interfaces::pClientDLL->GetAllClasses();
while (cc) {
if (className.compare(cc->GetName()) == 0) {
RecvTable *table = cc->m_pRecvTable;
int offset = 0;
RecvProp *prop = nullptr;
if (table) {
for (auto iterator = propertyTree.begin(); iterator != propertyTree.end(); ++iterator) {
int subOffset = 0;
if (prop && prop->GetType() == DPT_DataTable) {
table = prop->GetDataTable();
}
if (!table) {
return false;
}
if (GetSubProp(table, iterator->c_str(), prop, subOffset)) {
offset += subOffset;
}
else {
return false;
}
table = nullptr;
}
classPropOffsets[className][propertyString] = offset;
return true;
}
}
cc = cc->m_pNext;
}
return false;
}
RecvProp RecvPropDataTable(
char *pVarName,
int offset,
int flags,
RecvTable *pTable,
DataTableRecvVarProxyFn varProxy
)
{
RecvProp ret;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_DataTable;
ret.m_Flags = flags;
ret.SetDataTableProxyFn( varProxy );
ret.SetDataTable( pTable );
return ret;
}
RecvProp RecvPropString(
char *pVarName,
int offset,
int bufferSize,
int flags,
RecvVarProxyFn varProxy
)
{
RecvProp ret;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_String;
ret.m_Flags = flags;
ret.m_StringBufferSize = bufferSize;
ret.SetProxyFn( varProxy );
return ret;
}
bool Entities::CheckTableBaseclass(RecvTable *sTable, std::string baseclass) {
if (std::string(sTable->GetName()).compare("DT_" + baseclass) == 0) {
return true;
}
for (int i = 0; i < sTable->GetNumProps(); i++) {
RecvProp *sProp = sTable->GetProp(i);
if (strcmp(sProp->GetName(), "baseclass") != 0) {
continue;
}
RecvTable *sChildTable = sProp->GetDataTable();
if (sChildTable) {
return CheckTableBaseclass(sChildTable, baseclass);
}
}
return false;
}
RecvProp RecvPropInt(
char *pVarName,
int offset,
int sizeofVar,
int flags,
RecvVarProxyFn varProxy
)
{
RecvProp ret;
// If they didn't specify a proxy, then figure out what type we're writing to.
if (varProxy == NULL)
{
if (sizeofVar == 1)
{
varProxy = RecvProxy_Int32ToInt8;
}
else if (sizeofVar == 2)
{
varProxy = RecvProxy_Int32ToInt16;
}
else if (sizeofVar == 4)
{
varProxy = RecvProxy_Int32ToInt32;
}
else
{
Assert(!"RecvPropInt var has invalid size");
varProxy = RecvProxy_Int32ToInt8; // safest one...
}
}
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_Int;
ret.m_Flags = flags;
ret.SetProxyFn( varProxy );
return ret;
}
void Array_Decode( DecodeInfo *pInfo )
{
SendProp *pArrayProp = pInfo->m_pProp->GetArrayProp();
AssertMsg( pArrayProp, ("Array_Decode: missing m_pArrayProp for a property.") );
// Setup a DecodeInfo that is used to decode each of the child properties.
DecodeInfo subDecodeInfo;
subDecodeInfo.CopyVars( pInfo );
subDecodeInfo.m_pProp = pArrayProp;
int elementStride = 0;
ArrayLengthRecvProxyFn lengthProxy = 0;
if ( pInfo->m_pRecvProp )
{
RecvProp *pArrayRecvProp = pInfo->m_pRecvProp->GetArrayProp();
subDecodeInfo.m_pRecvProp = pArrayRecvProp;
// Note we get the OFFSET from the array element property and the STRIDE from the array itself.
subDecodeInfo.m_pData = (char*)pInfo->m_pData + pArrayRecvProp->GetOffset();
elementStride = pInfo->m_pRecvProp->GetElementStride();
Assert( elementStride != -1 ); // (Make sure it was set..)
lengthProxy = pInfo->m_pRecvProp->GetArrayLengthProxy();
}
int nElements = pInfo->m_pIn->ReadUBitLong( pInfo->m_pProp->GetNumArrayLengthBits() );
if ( lengthProxy )
lengthProxy( pInfo->m_pStruct, pInfo->m_ObjectID, nElements );
for ( subDecodeInfo.m_iElement=0; subDecodeInfo.m_iElement < nElements; subDecodeInfo.m_iElement++ )
{
g_PropTypeFns[pArrayProp->GetType()].Decode( &subDecodeInfo );
subDecodeInfo.m_pData = (char*)subDecodeInfo.m_pData + elementStride;
}
}
RecvProp RecvPropArray3(
char *pVarName,
int offset,
int sizeofVar,
int elements,
RecvProp pArrayProp,
DataTableRecvVarProxyFn varProxy
)
{
RecvProp ret;
Assert( elements <= MAX_ARRAY_ELEMENTS );
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_DataTable;
ret.SetDataTableProxyFn( varProxy );
RecvProp *pProps = new RecvProp[elements]; // TODO free that again
const char *pParentArrayPropName = AllocateStringHelper( "%s", pVarName );
for ( int i=0; i < elements; i++ )
{
pProps[i] = pArrayProp; // copy basic property settings
pProps[i].SetOffset( i * sizeofVar ); // adjust offset
pProps[i].m_pVarName = s_ClientElementNames[i]; // give unique name
pProps[i].SetParentArrayPropName( pParentArrayPropName ); // For debugging...
}
RecvTable *pTable = new RecvTable( pProps, elements, pVarName ); // TODO free that again
ret.SetDataTable( pTable );
return ret;
}
RecvProp RecvPropFloat(
char *pVarName,
int offset,
int sizeofVar,
int flags,
RecvVarProxyFn varProxy
)
{
RecvProp ret;
// Debug type checks.
if ( varProxy == RecvProxy_FloatToFloat )
{
Assert( sizeofVar == 0 || sizeofVar == 4 );
}
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_RecvType = DPT_Float;
ret.m_Flags = flags;
ret.SetProxyFn( varProxy );
return ret;
}
bool Entities::GetSubProp(RecvTable *table, const char *propName, RecvProp *&prop, int &offset) {
for (int i = 0; i < table->GetNumProps(); i++) {
offset = 0;
RecvProp *currentProp = table->GetProp(i);
if (strcmp(currentProp->GetName(), propName) == 0) {
prop = currentProp;
offset = currentProp->GetOffset();
return true;
}
if (currentProp->GetType() == DPT_DataTable) {
if (GetSubProp(currentProp->GetDataTable(), propName, prop, offset)) {
offset += currentProp->GetOffset();
return true;
}
}
}
return false;
}
RecvProp RecvPropUtlVector(
const char *pVarName, // Use RECVINFO_UTLVECTOR to generate these 4.
int offset, // Used to generate pData in the function specified in varProxy.
int sizeofVar, // The size of each element in the utlvector.
ResizeUtlVectorFn fn,
EnsureCapacityFn ensureFn,
int nMaxElements, // Max # of elements in the array. Keep this as low as possible.
RecvProp pArrayProp
)
{
RecvProp ret;
Assert( nMaxElements <= MAX_ARRAY_ELEMENTS );
ret.m_RecvType = DPT_DataTable;
ret.m_pVarName = pVarName;
ret.SetOffset( 0 );
ret.SetDataTableProxyFn( DataTableRecvProxy_StaticDataTable );
RecvProp *pProps = new RecvProp[nMaxElements+1]; // TODO free that again
// Extra data bound to each of the properties.
CRecvPropExtra_UtlVector *pExtraData = new CRecvPropExtra_UtlVector;
pExtraData->m_nMaxElements = nMaxElements;
pExtraData->m_ElementStride = sizeofVar;
pExtraData->m_ResizeFn = fn;
pExtraData->m_EnsureCapacityFn = ensureFn;
pExtraData->m_Offset = offset;
if ( pArrayProp.m_RecvType == DPT_DataTable )
pExtraData->m_DataTableProxyFn = pArrayProp.GetDataTableProxyFn();
else
pExtraData->m_ProxyFn = pArrayProp.GetProxyFn();
// The first property is datatable with an int that tells the length of the array.
// It has to go in a datatable, otherwise if this array holds datatable properties, it will be received last.
RecvProp *pLengthProp = new RecvProp;
*pLengthProp = RecvPropInt( AllocateStringHelper( "lengthprop%d", nMaxElements ), 0, 0, 0, RecvProxy_UtlVectorLength );
pLengthProp->SetExtraData( pExtraData );
char *pLengthProxyTableName = AllocateUniqueDataTableName( false, "_LPT_%s_%d", pVarName, nMaxElements );
RecvTable *pLengthTable = new RecvTable( pLengthProp, 1, pLengthProxyTableName );
pProps[0] = RecvPropDataTable( "lengthproxy", 0, 0, pLengthTable, DataTableRecvProxy_LengthProxy );
pProps[0].SetExtraData( pExtraData );
// The first element is a sub-datatable.
for ( int i = 1; i < nMaxElements+1; i++ )
{
pProps[i] = pArrayProp; // copy array element property setting
pProps[i].SetOffset( 0 ); // leave offset at 0 so pStructBase is always a pointer to the CUtlVector
pProps[i].m_pVarName = s_ClientElementNames[i-1]; // give unique name
pProps[i].SetExtraData( pExtraData );
pProps[i].SetElementStride( i-1 ); // Kind of lame overloading element stride to hold the element index,
// but we can easily move it into its SetExtraData stuff if we need to.
// We provide our own proxy here.
if ( pArrayProp.m_RecvType == DPT_DataTable )
{
pProps[i].SetDataTableProxyFn( RecvProxy_UtlVectorElement_DataTable );
}
else
{
pProps[i].SetProxyFn( RecvProxy_UtlVectorElement );
}
}
RecvTable *pTable = new RecvTable(
pProps,
nMaxElements+1,
AllocateUniqueDataTableName( false, "_ST_%s_%d", pVarName, nMaxElements )
); // TODO free that again
ret.SetDataTable( pTable );
return ret;
}
