2243 lines
54 KiB
C++
2243 lines
54 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
|
|
#if !defined( NO_ENTITY_PREDICTION )
|
|
|
|
#if defined( CLIENT_DLL )
|
|
|
|
#include "igamesystem.h"
|
|
|
|
#endif
|
|
#include <memory.h>
|
|
#include <stdarg.h>
|
|
#include "tier0/dbg.h"
|
|
#include "tier1/strtools.h"
|
|
#include "predictioncopy.h"
|
|
#include "engine/ivmodelinfo.h"
|
|
#include "tier1/fmtstr.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// --------------------------------------------------------------
|
|
//
|
|
// CSave
|
|
//
|
|
// --------------------------------------------------------------
|
|
static const char *g_FieldTypes[ FIELD_TYPECOUNT ] =
|
|
{
|
|
"FIELD_VOID", // FIELD_VOID
|
|
"FIELD_FLOAT", // FIELD_FLOAT
|
|
"FIELD_STRING", // FIELD_STRING
|
|
"FIELD_VECTOR", // FIELD_VECTOR
|
|
"FIELD_QUATERNION", // FIELD_QUATERNION
|
|
"FIELD_INTEGER", // FIELD_INTEGER
|
|
"FIELD_BOOLEAN", // FIELD_BOOLEAN
|
|
"FIELD_SHORT", // FIELD_SHORT
|
|
"FIELD_CHARACTER", // FIELD_CHARACTER
|
|
"FIELD_COLOR32", // FIELD_COLOR32
|
|
"FIELD_EMBEDDED", // FIELD_EMBEDDED (handled specially)
|
|
"FIELD_CUSTOM", // FIELD_CUSTOM (handled specially)
|
|
"FIELD_CLASSPTR", // FIELD_CLASSPTR
|
|
"FIELD_EHANDLE", // FIELD_EHANDLE
|
|
"FIELD_EDICT", // FIELD_EDICT
|
|
"FIELD_POSITION_VECTOR",// FIELD_POSITION_VECTOR
|
|
"FIELD_TIME", // FIELD_TIME
|
|
"FIELD_TICK", // FIELD_TICK
|
|
"FIELD_MODELNAME", // FIELD_MODELNAME
|
|
"FIELD_SOUNDNAME", // FIELD_SOUNDNAME
|
|
"FIELD_INPUT", // FIELD_INPUT (uses custom type)
|
|
"FIELD_FUNCTION", // FIELD_FUNCTION
|
|
"FIELD_VMATRIX",
|
|
"FIELD_VMATRIX_WORLDSPACE",
|
|
"FIELD_MATRIX3X4_WORLDSPACE",
|
|
"FIELD_INTERVAL" // FIELD_INTERVAL
|
|
"FIELD_MODELINDEX" // FIELD_MODELINDEX
|
|
};
|
|
|
|
CPredictionCopy::CPredictionCopy( int type, void *dest, bool dest_packed, void const *src, bool src_packed,
|
|
bool counterrors /*= false*/, bool reporterrors /*= false*/, bool performcopy /*= true*/,
|
|
bool describefields /*= false*/, FN_FIELD_COMPARE func /*= NULL*/ )
|
|
{
|
|
m_nType = type;
|
|
m_pDest = dest;
|
|
m_pSrc = src;
|
|
m_nDestOffsetIndex = dest_packed ? TD_OFFSET_PACKED : TD_OFFSET_NORMAL;
|
|
m_nSrcOffsetIndex = src_packed ? TD_OFFSET_PACKED : TD_OFFSET_NORMAL;
|
|
m_bErrorCheck = counterrors;
|
|
m_bReportErrors = reporterrors;
|
|
m_bPerformCopy = performcopy;
|
|
m_bDescribeFields = describefields;
|
|
|
|
m_pCurrentField = NULL;
|
|
m_pCurrentMap = NULL;
|
|
m_pCurrentClassName = NULL;
|
|
m_bShouldReport = false;
|
|
m_bShouldDescribe = false;
|
|
m_nErrorCount = 0;
|
|
|
|
m_FieldCompareFunc = func;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *fmt -
|
|
// ... -
|
|
//-----------------------------------------------------------------------------
|
|
void CPredictionCopy::ReportFieldsDiffer( const char *fmt, ... )
|
|
{
|
|
++m_nErrorCount;
|
|
|
|
if ( !m_bShouldReport )
|
|
return;
|
|
|
|
if ( m_bDescribeFields && m_FieldCompareFunc )
|
|
return;
|
|
|
|
Assert( m_pCurrentMap );
|
|
Assert( m_pCurrentClassName );
|
|
|
|
const char *fieldname = "empty";
|
|
int flags = 0;
|
|
|
|
if ( m_pCurrentField )
|
|
{
|
|
flags = m_pCurrentField->flags;
|
|
fieldname = m_pCurrentField->fieldName ? m_pCurrentField->fieldName : "NULL";
|
|
}
|
|
|
|
va_list argptr;
|
|
char data[ 4096 ];
|
|
int len;
|
|
va_start(argptr, fmt);
|
|
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
if ( m_nErrorCount == 1 )
|
|
{
|
|
Msg( "\n" );
|
|
}
|
|
|
|
Msg( "%03i %s::%s - %s",
|
|
m_nErrorCount,
|
|
m_pCurrentClassName,
|
|
fieldname,
|
|
data );
|
|
|
|
m_bShouldReport = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *fmt -
|
|
// ... -
|
|
//-----------------------------------------------------------------------------
|
|
void CPredictionCopy::DescribeFields( difftype_t dt, const char *fmt, ... )
|
|
{
|
|
if ( !m_bShouldDescribe )
|
|
return;
|
|
|
|
if ( !m_FieldCompareFunc )
|
|
return;
|
|
|
|
Assert( m_pCurrentMap );
|
|
Assert( m_pCurrentClassName );
|
|
|
|
const char *fieldname = "empty";
|
|
int flags = 0;
|
|
|
|
if ( m_pCurrentField )
|
|
{
|
|
flags = m_pCurrentField->flags;
|
|
fieldname = m_pCurrentField->fieldName ? m_pCurrentField->fieldName : "NULL";
|
|
}
|
|
|
|
va_list argptr;
|
|
char data[ 4096 ];
|
|
int len;
|
|
va_start(argptr, fmt);
|
|
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
bool isnetworked = ( flags & FTYPEDESC_INSENDTABLE ) ? true : false;
|
|
bool isnoterrorchecked = ( flags & FTYPEDESC_NOERRORCHECK ) ? true : false;
|
|
|
|
( *m_FieldCompareFunc )(
|
|
m_pCurrentClassName,
|
|
fieldname,
|
|
g_FieldTypes[ m_pCurrentField->fieldType ],
|
|
isnetworked,
|
|
isnoterrorchecked,
|
|
dt != IDENTICAL ? true : false,
|
|
dt == WITHINTOLERANCE ? true : false,
|
|
data
|
|
);
|
|
|
|
m_bShouldDescribe = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CPredictionCopy::CanCheck( void )
|
|
{
|
|
Assert( m_pCurrentField );
|
|
|
|
if ( m_pCurrentField->flags & FTYPEDESC_NOERRORCHECK )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : size -
|
|
// *outdata -
|
|
// *indata -
|
|
//-----------------------------------------------------------------------------
|
|
/*
|
|
void CPredictionCopy::CopyData( difftype_t dt, int size, char *outdata, const char *indata )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
memcpy( outdata, indata, size );
|
|
}
|
|
*/
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareData( int size, char *outdata, const char *indata )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
if ( memcmp( outdata, indata, size ) )
|
|
{
|
|
return DIFFERS;
|
|
}
|
|
else
|
|
{
|
|
// No difference, so no need to copy
|
|
return IDENTICAL;
|
|
}
|
|
}
|
|
|
|
// Fields differ
|
|
return IDENTICAL;
|
|
}
|
|
|
|
void CPredictionCopy::DescribeData( difftype_t dt, int size, char *outdata, const char *indata )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
ReportFieldsDiffer( "binary data differs (%i bytes)\n", size );
|
|
}
|
|
|
|
DescribeFields( dt, "binary (%i bytes)\n", size );
|
|
}
|
|
|
|
void CPredictionCopy::WatchData( difftype_t dt, int size, char *outdata, const char *indata )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "binary (%i bytes)", size );
|
|
}
|
|
|
|
void CPredictionCopy::DescribeShort( difftype_t dt, short *outvalue, const short *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
ReportFieldsDiffer( "short differs (net %i pred %i) diff(%i)\n", (int)(invalue[i]), (int)(outvalue[i]), (int)(outvalue[i] - invalue[i]) );
|
|
}
|
|
|
|
DescribeFields( dt, "short (%i)\n", (int)(outvalue[0]) );
|
|
}
|
|
|
|
void CPredictionCopy::WatchShort( difftype_t dt, short *outvalue, const short *invalue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "short (%i)", (int)(outvalue[0]) );
|
|
}
|
|
|
|
#if defined( CLIENT_DLL )
|
|
#include "cdll_int.h"
|
|
|
|
#endif
|
|
|
|
void CPredictionCopy::DescribeInt( difftype_t dt, int *outvalue, const int *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
ReportFieldsDiffer( "int differs (net %i pred %i) diff(%i)\n", invalue[i], outvalue[i], outvalue[i] - invalue[i] );
|
|
}
|
|
|
|
#if defined( CLIENT_DLL )
|
|
bool described = false;
|
|
if ( m_pCurrentField->flags & FTYPEDESC_MODELINDEX )
|
|
{
|
|
int modelindex = outvalue[0];
|
|
model_t const *m = modelinfo->GetModel( modelindex );
|
|
if ( m )
|
|
{
|
|
described = true;
|
|
char shortfile[ 512 ];
|
|
shortfile[ 0 ] = 0;
|
|
Q_FileBase( modelinfo->GetModelName( m ), shortfile, sizeof( shortfile ) );
|
|
|
|
DescribeFields( dt, "integer (%i->%s)\n", outvalue[0], shortfile );
|
|
}
|
|
}
|
|
|
|
if ( !described )
|
|
{
|
|
DescribeFields( dt, "integer (%i)\n", outvalue[0] );
|
|
}
|
|
#else
|
|
DescribeFields( dt, "integer (%i)\n", outvalue[0] );
|
|
#endif
|
|
}
|
|
|
|
void CPredictionCopy::WatchInt( difftype_t dt, int *outvalue, const int *invalue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
#if defined( CLIENT_DLL )
|
|
bool described = false;
|
|
if ( m_pCurrentField->flags & FTYPEDESC_MODELINDEX )
|
|
{
|
|
int modelindex = outvalue[0];
|
|
model_t const *m = modelinfo->GetModel( modelindex );
|
|
if ( m )
|
|
{
|
|
described = true;
|
|
char shortfile[ 512 ];
|
|
shortfile[ 0 ] = 0;
|
|
Q_FileBase( modelinfo->GetModelName( m ), shortfile, sizeof( shortfile ) );
|
|
|
|
WatchMsg( "integer (%i->%s)", outvalue[0], shortfile );
|
|
}
|
|
}
|
|
|
|
if ( !described )
|
|
{
|
|
WatchMsg( "integer (%i)", outvalue[0] );
|
|
}
|
|
#else
|
|
WatchMsg( "integer (%i)", outvalue[0] );
|
|
#endif
|
|
}
|
|
|
|
void CPredictionCopy::DescribeBool( difftype_t dt, bool *outvalue, const bool *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
ReportFieldsDiffer( "bool differs (net %s pred %s)\n", (invalue[i]) ? "true" : "false", (outvalue[i]) ? "true" : "false" );
|
|
}
|
|
|
|
DescribeFields( dt, "bool (%s)\n", (outvalue[0]) ? "true" : "false" );
|
|
}
|
|
|
|
|
|
void CPredictionCopy::WatchBool( difftype_t dt, bool *outvalue, const bool *invalue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "bool (%s)", (outvalue[0]) ? "true" : "false" );
|
|
}
|
|
|
|
void CPredictionCopy::DescribeFloat( difftype_t dt, float *outvalue, const float *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
ReportFieldsDiffer( "float differs (net %f pred %f) diff(%f)\n", invalue[ i ], outvalue[ i ], outvalue[ i ] - invalue[ i ] );
|
|
}
|
|
|
|
DescribeFields( dt, "float (%f)\n", outvalue[ 0 ] );
|
|
}
|
|
|
|
void CPredictionCopy::WatchFloat( difftype_t dt, float *outvalue, const float *invalue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "float (%f)", outvalue[ 0 ] );
|
|
}
|
|
|
|
void CPredictionCopy::DescribeString( difftype_t dt, char *outstring, const char *instring )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
ReportFieldsDiffer( "string differs (net %s pred %s)\n", instring, outstring );
|
|
}
|
|
|
|
DescribeFields( dt, "string (%s)\n", outstring );
|
|
}
|
|
|
|
void CPredictionCopy::WatchString( difftype_t dt, char *outstring, const char *instring )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "string (%s)", outstring );
|
|
}
|
|
|
|
void CPredictionCopy::DescribeVector( difftype_t dt, Vector& outValue, const Vector &inValue )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
Vector delta = outValue - inValue;
|
|
|
|
ReportFieldsDiffer( "vec differs (net %f %f %f - pred %f %f %f) delta(%f %f %f)\n",
|
|
inValue.x, inValue.y, inValue.z,
|
|
outValue.x, outValue.y, outValue.z,
|
|
delta.x, delta.y, delta.z );
|
|
}
|
|
|
|
DescribeFields( dt, "vector (%f %f %f)\n",
|
|
outValue.x, outValue.y, outValue.z );
|
|
}
|
|
|
|
void CPredictionCopy::DescribeVector( difftype_t dt, Vector* outValue, const Vector *inValue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
Vector delta = outValue[ i ] - inValue[ i ];
|
|
|
|
ReportFieldsDiffer( "vec[] differs (1st diff) (net %f %f %f - pred %f %f %f) delta(%f %f %f)\n",
|
|
inValue[i].x, inValue[i].y, inValue[i].z,
|
|
outValue[i].x, outValue[i].y, outValue[i].z,
|
|
delta.x, delta.y, delta.z );
|
|
}
|
|
|
|
DescribeFields( dt, "vector (%f %f %f)\n",
|
|
outValue[0].x, outValue[0].y, outValue[0].z );
|
|
}
|
|
|
|
void CPredictionCopy::WatchVector( difftype_t dt, Vector& outValue, const Vector &inValue )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "vector (%f %f %f)", outValue.x, outValue.y, outValue.z );
|
|
}
|
|
|
|
void CPredictionCopy::WatchVector( difftype_t dt, Vector* outValue, const Vector *inValue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "vector (%f %f %f)", outValue[0].x, outValue[0].y, outValue[0].z );
|
|
}
|
|
|
|
|
|
|
|
void CPredictionCopy::DescribeQuaternion( difftype_t dt, Quaternion& outValue, const Quaternion &inValue )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
Quaternion delta;
|
|
|
|
for ( int i = 0; i < 4; i++ )
|
|
{
|
|
delta[i] = outValue[i] - inValue[i];
|
|
}
|
|
|
|
ReportFieldsDiffer( "quaternion differs (net %f %f %f %f - pred %f %f %f %f) delta(%f %f %f %f)\n",
|
|
inValue[0], inValue[1], inValue[2], inValue[3],
|
|
outValue[0], outValue[1], outValue[2], outValue[3],
|
|
delta[0], delta[1], delta[2], delta[3] );
|
|
}
|
|
|
|
DescribeFields( dt, "quaternion (%f %f %f %f)\n",
|
|
outValue[0], outValue[1], outValue[2], outValue[3] );
|
|
}
|
|
|
|
void CPredictionCopy::DescribeQuaternion( difftype_t dt, Quaternion* outValue, const Quaternion *inValue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
Quaternion delta;
|
|
|
|
for ( int j = 0; j < 4; j++ )
|
|
{
|
|
delta[j] = outValue[i][j] - inValue[i][j];
|
|
}
|
|
|
|
ReportFieldsDiffer( "quaternion[] differs (1st diff) (net %f %f %f %f - pred %f %f %f %f) delta(%f %f %f %f)\n",
|
|
(float)inValue[i][0], (float)inValue[i][1], (float)inValue[i][2], (float)inValue[i][3],
|
|
(float)outValue[i][0], (float)outValue[i][1], (float)outValue[i][2], (float)outValue[i][3],
|
|
delta[0], delta[1], delta[2], delta[3] );
|
|
}
|
|
|
|
DescribeFields( dt, "quaternion (%f %f %f %f)\n",
|
|
(float)outValue[0][0], (float)outValue[0][1], (float)outValue[0][2], (float)outValue[0][3] );
|
|
}
|
|
|
|
void CPredictionCopy::WatchQuaternion( difftype_t dt, Quaternion& outValue, const Quaternion &inValue )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "quaternion (%f %f %f %f)", (float)outValue[0], (float)outValue[1], (float)outValue[2], (float)outValue[3] );
|
|
}
|
|
|
|
void CPredictionCopy::WatchQuaternion( difftype_t dt, Quaternion* outValue, const Quaternion *inValue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
WatchMsg( "quaternion (%f %f %f %f)", outValue[0][0], outValue[0][1], outValue[0][2], outValue[0][3] );
|
|
}
|
|
|
|
|
|
|
|
void CPredictionCopy::DescribeEHandle( difftype_t dt, EHANDLE *outvalue, EHANDLE const *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return;
|
|
|
|
if ( dt == DIFFERS )
|
|
{
|
|
int i = 0;
|
|
ReportFieldsDiffer( "EHandles differ (net) 0x%p (pred) 0x%p\n", (void const *)invalue[ i ].Get(), (void *)outvalue[ i ].Get() );
|
|
}
|
|
|
|
#if defined( CLIENT_DLL )
|
|
C_BaseEntity *ent = outvalue[0].Get();
|
|
if ( ent )
|
|
{
|
|
const char *classname = ent->GetClassname();
|
|
if ( !classname[0] )
|
|
{
|
|
classname = typeid( *ent ).name();
|
|
}
|
|
|
|
DescribeFields( dt, "EHandle (0x%p->%s)", (void *)outvalue[ 0 ], classname );
|
|
}
|
|
else
|
|
{
|
|
DescribeFields( dt, "EHandle (NULL)" );
|
|
}
|
|
|
|
#else
|
|
DescribeFields( dt, "EHandle (0x%p)", (void *)outvalue[ 0 ] );
|
|
#endif
|
|
|
|
}
|
|
|
|
void CPredictionCopy::WatchEHandle( difftype_t dt, EHANDLE *outvalue, EHANDLE const *invalue, int count )
|
|
{
|
|
if ( m_pWatchField != m_pCurrentField )
|
|
return;
|
|
|
|
#if defined( CLIENT_DLL )
|
|
C_BaseEntity *ent = outvalue[0].Get();
|
|
if ( ent )
|
|
{
|
|
const char *classname = ent->GetClassname();
|
|
if ( !classname[0] )
|
|
{
|
|
classname = typeid( *ent ).name();
|
|
}
|
|
|
|
WatchMsg( "EHandle (0x%p->%s)", (void *)outvalue[ 0 ], classname );
|
|
}
|
|
else
|
|
{
|
|
WatchMsg( "EHandle (NULL)" );
|
|
}
|
|
|
|
#else
|
|
WatchMsg( "EHandle (0x%p)", (void *)outvalue[ 0 ] );
|
|
#endif
|
|
|
|
}
|
|
|
|
void CPredictionCopy::CopyShort( difftype_t dt, short *outvalue, const short *invalue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, sizeof(short) * count, (char *)outvalue, (const char *)invalue );
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareShort( short *outvalue, const short *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( outvalue[ i ] == invalue[ i ] )
|
|
continue;
|
|
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
|
|
void CPredictionCopy::CopyInt( difftype_t dt, int *outvalue, const int *invalue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, sizeof(int) * count, (char *)outvalue, (const char *)invalue );
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareInt( int *outvalue, const int *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( outvalue[ i ] == invalue[ i ] )
|
|
continue;
|
|
|
|
ReportFieldsDiffer( "int differs (net %i pred %i) diff(%i)\n", invalue[i], outvalue[i], outvalue[i] - invalue[i] );
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
void CPredictionCopy::CopyBool( difftype_t dt, bool *outvalue, const bool *invalue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, sizeof( bool ) * count, (char *)outvalue, (const char *)invalue );
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareBool( bool *outvalue, const bool *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( outvalue[ i ] == invalue[ i ] )
|
|
continue;
|
|
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
void CPredictionCopy::CopyFloat( difftype_t dt, float *outvalue, const float *invalue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, sizeof( float ) * count, (char *)outvalue, (const char *)invalue );
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareFloat( float *outvalue, const float *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
difftype_t retval = IDENTICAL;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
float tolerance = m_pCurrentField->fieldTolerance;
|
|
Assert( tolerance >= 0.0f );
|
|
bool usetolerance = tolerance > 0.0f;
|
|
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( outvalue[ i ] == invalue[ i ] )
|
|
continue;
|
|
|
|
if ( usetolerance &&
|
|
( fabs( outvalue[ i ] - invalue[ i ] ) <= tolerance ) )
|
|
{
|
|
retval = WITHINTOLERANCE;
|
|
continue;
|
|
}
|
|
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
void CPredictionCopy::CopyString( difftype_t dt, char *outstring, const char *instring )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, Q_strlen( instring ) + 1, (char *)outstring, (const char *)instring );
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareString( char *outstring, const char *instring )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
if ( Q_strcmp( outstring, instring ) )
|
|
{
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
void CPredictionCopy::CopyVector( difftype_t dt, Vector& outValue, const Vector &inValue )
|
|
{
|
|
CopyVector( dt, &outValue, &inValue, 1 );
|
|
}
|
|
|
|
void CPredictionCopy::CopyQuaternion( difftype_t dt, Quaternion& outValue, const Quaternion &inValue )
|
|
{
|
|
CopyQuaternion( dt, &outValue, &inValue, 1 );
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareVector( Vector& outValue, const Vector &inValue )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
float tolerance = m_pCurrentField->fieldTolerance;
|
|
Assert( tolerance >= 0.0f );
|
|
|
|
if ( outValue != inValue && ( tolerance > 0.0f ) )
|
|
{
|
|
Vector delta = outValue - inValue;
|
|
|
|
if ( fabs( delta.x ) <= tolerance &&
|
|
fabs( delta.y ) <= tolerance &&
|
|
fabs( delta.z ) <= tolerance )
|
|
{
|
|
return WITHINTOLERANCE;
|
|
}
|
|
}
|
|
|
|
return DIFFERS;
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
static int QuaternionCompare (const Quaternion& q1, const Quaternion& q2 )
|
|
{
|
|
for ( int i = 0; i < 4; i++ )
|
|
{
|
|
if ( q1[i] != q2[i] )
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareQuaternion( Quaternion& outValue, const Quaternion &inValue )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
float tolerance = m_pCurrentField->fieldTolerance;
|
|
Assert( tolerance >= 0.0f );
|
|
|
|
if ( QuaternionCompare( outValue, inValue ) == 0
|
|
&& ( tolerance > 0.0f ) )
|
|
{
|
|
Quaternion delta;
|
|
|
|
for ( int j = 0; j < 4; j++ )
|
|
{
|
|
delta[j] = outValue[j] - inValue[j];
|
|
}
|
|
|
|
if ( fabs( delta[0] ) <= tolerance &&
|
|
fabs( delta[1] ) <= tolerance &&
|
|
fabs( delta[2] ) <= tolerance &&
|
|
fabs( delta[3] ) <= tolerance )
|
|
{
|
|
return WITHINTOLERANCE;
|
|
}
|
|
}
|
|
|
|
return DIFFERS;
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
void CPredictionCopy::CopyVector( difftype_t dt, Vector* outValue, const Vector *inValue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, sizeof( Vector ) * count, (char *)outValue, (const char *)inValue );
|
|
}
|
|
|
|
void CPredictionCopy::CopyQuaternion( difftype_t dt, Quaternion* outValue, const Quaternion *inValue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
CopyData( dt, sizeof( Quaternion ) * count, (char *)outValue, (const char *)inValue );
|
|
}
|
|
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareVector( Vector* outValue, const Vector *inValue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
difftype_t retval = IDENTICAL;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
float tolerance = m_pCurrentField->fieldTolerance;
|
|
Assert( tolerance >= 0.0f );
|
|
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( outValue[ i ] == inValue[ i ] )
|
|
continue;
|
|
|
|
Vector delta = outValue[ i ] - inValue[ i ];
|
|
|
|
if ( tolerance > 0.0f )
|
|
{
|
|
if ( fabs( delta.x ) <= tolerance &&
|
|
fabs( delta.y ) <= tolerance &&
|
|
fabs( delta.z ) <= tolerance )
|
|
{
|
|
retval = WITHINTOLERANCE;
|
|
continue;
|
|
}
|
|
}
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareQuaternion( Quaternion* outValue, const Quaternion *inValue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
difftype_t retval = IDENTICAL;
|
|
|
|
if ( CanCheck() )
|
|
{
|
|
float tolerance = m_pCurrentField->fieldTolerance;
|
|
Assert( tolerance >= 0.0f );
|
|
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( QuaternionCompare( outValue[ i ], inValue[ i ] ) )
|
|
continue;
|
|
|
|
Quaternion delta;
|
|
|
|
for ( int j = 0; j < 4; j++ )
|
|
{
|
|
delta[j] = outValue[i][j] - inValue[i][j];
|
|
}
|
|
|
|
if ( tolerance > 0.0f )
|
|
{
|
|
if ( fabs( delta[0] ) <= tolerance &&
|
|
fabs( delta[1] ) <= tolerance &&
|
|
fabs( delta[2] ) <= tolerance &&
|
|
fabs( delta[3] ) <= tolerance )
|
|
{
|
|
retval = WITHINTOLERANCE;
|
|
continue;
|
|
}
|
|
}
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
void CPredictionCopy::CopyEHandle( difftype_t dt, EHANDLE *outvalue, EHANDLE const *invalue, int count )
|
|
{
|
|
if ( !m_bPerformCopy )
|
|
return;
|
|
|
|
if ( dt == IDENTICAL )
|
|
return;
|
|
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
outvalue[ i ] = invalue[ i ];
|
|
}
|
|
}
|
|
|
|
CPredictionCopy::difftype_t CPredictionCopy::CompareEHandle( EHANDLE *outvalue, EHANDLE const *invalue, int count )
|
|
{
|
|
if ( !m_bErrorCheck )
|
|
return DIFFERS;
|
|
|
|
int i;
|
|
if ( CanCheck() )
|
|
{
|
|
for ( i = 0; i < count; i++ )
|
|
{
|
|
if ( outvalue[ i ].Get() == invalue[ i ].Get() )
|
|
continue;
|
|
|
|
return DIFFERS;
|
|
}
|
|
}
|
|
|
|
return IDENTICAL;
|
|
}
|
|
|
|
void CPredictionCopy::CopyFields( int chain_count, datamap_t *pRootMap, typedescription_t *pFields, int fieldCount )
|
|
{
|
|
int i;
|
|
int flags;
|
|
int fieldOffsetSrc;
|
|
int fieldOffsetDest;
|
|
int fieldSize;
|
|
|
|
m_pCurrentMap = pRootMap;
|
|
if ( !m_pCurrentClassName )
|
|
{
|
|
m_pCurrentClassName = pRootMap->dataClassName;
|
|
}
|
|
|
|
for ( i = 0; i < fieldCount; i++ )
|
|
{
|
|
m_pCurrentField = &pFields[ i ];
|
|
flags = m_pCurrentField->flags;
|
|
|
|
// Mark any subchains first
|
|
if ( m_pCurrentField->override_field != NULL )
|
|
{
|
|
m_pCurrentField->override_field->override_count = chain_count;
|
|
}
|
|
|
|
// Skip this field?
|
|
if ( m_pCurrentField->override_count == chain_count )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Always recurse into embeddeds
|
|
if ( m_pCurrentField->fieldType != FIELD_EMBEDDED )
|
|
{
|
|
// Don't copy fields that are private to server or client
|
|
if ( flags & FTYPEDESC_PRIVATE )
|
|
continue;
|
|
|
|
// For PC_NON_NETWORKED_ONLYs skip any fields that are present in the network send tables
|
|
if ( m_nType == PC_NON_NETWORKED_ONLY && ( flags & FTYPEDESC_INSENDTABLE ) )
|
|
continue;
|
|
|
|
// For PC_NETWORKED_ONLYs skip any fields that are not present in the network send tables
|
|
if ( m_nType == PC_NETWORKED_ONLY && !( flags & FTYPEDESC_INSENDTABLE ) )
|
|
continue;
|
|
}
|
|
|
|
void *pOutputData;
|
|
void const *pInputData;
|
|
|
|
fieldOffsetDest = m_pCurrentField->fieldOffset[ m_nDestOffsetIndex ];
|
|
fieldOffsetSrc = m_pCurrentField->fieldOffset[ m_nSrcOffsetIndex ];
|
|
fieldSize = m_pCurrentField->fieldSize;
|
|
|
|
pOutputData = (void *)((char *)m_pDest + fieldOffsetDest );
|
|
pInputData = (void const *)((char *)m_pSrc + fieldOffsetSrc );
|
|
|
|
// Assume we can report
|
|
m_bShouldReport = m_bReportErrors;
|
|
m_bShouldDescribe = true;
|
|
|
|
bool bShouldWatch = m_pWatchField == m_pCurrentField;
|
|
|
|
difftype_t difftype;
|
|
|
|
switch( m_pCurrentField->fieldType )
|
|
{
|
|
case FIELD_EMBEDDED:
|
|
{
|
|
typedescription_t *save = m_pCurrentField;
|
|
void *saveDest = m_pDest;
|
|
void const *saveSrc = m_pSrc;
|
|
const char *saveName = m_pCurrentClassName;
|
|
|
|
m_pCurrentClassName = m_pCurrentField->td->dataClassName;
|
|
|
|
// FIXME: Should this be done outside the FIELD_EMBEDDED case??
|
|
// Don't follow the pointer if we're reading from a compressed packet
|
|
m_pSrc = pInputData;
|
|
if ( ( flags & FTYPEDESC_PTR ) && (m_nSrcOffsetIndex == PC_DATA_NORMAL) )
|
|
{
|
|
m_pSrc = *((void**)m_pSrc);
|
|
}
|
|
|
|
m_pDest = pOutputData;
|
|
if ( ( flags & FTYPEDESC_PTR ) && (m_nDestOffsetIndex == PC_DATA_NORMAL) )
|
|
{
|
|
m_pDest = *((void**)m_pDest);
|
|
}
|
|
|
|
CopyFields( chain_count, pRootMap, m_pCurrentField->td->dataDesc, m_pCurrentField->td->dataNumFields );
|
|
|
|
m_pCurrentClassName = saveName;
|
|
m_pCurrentField = save;
|
|
m_pDest = saveDest;
|
|
m_pSrc = saveSrc;
|
|
}
|
|
break;
|
|
case FIELD_FLOAT:
|
|
{
|
|
difftype = CompareFloat( (float *)pOutputData, (float const *)pInputData, fieldSize );
|
|
CopyFloat( difftype, (float *)pOutputData, (float const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeFloat( difftype, (float *)pOutputData, (float const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchFloat( difftype, (float *)pOutputData, (float const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
|
|
case FIELD_TIME:
|
|
case FIELD_TICK:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_STRING:
|
|
{
|
|
difftype = CompareString( (char *)pOutputData, (char const*)pInputData );
|
|
CopyString( difftype, (char *)pOutputData, (char const*)pInputData );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeString( difftype,(char *)pOutputData, (char const*)pInputData );
|
|
if ( bShouldWatch ) WatchString( difftype,(char *)pOutputData, (char const*)pInputData );
|
|
}
|
|
break;
|
|
|
|
case FIELD_MODELINDEX:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_MODELNAME:
|
|
case FIELD_SOUNDNAME:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_CUSTOM:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_CLASSPTR:
|
|
case FIELD_EDICT:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_POSITION_VECTOR:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_VECTOR:
|
|
{
|
|
difftype = CompareVector( (Vector *)pOutputData, (Vector const *)pInputData, fieldSize );
|
|
CopyVector( difftype, (Vector *)pOutputData, (Vector const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeVector( difftype, (Vector *)pOutputData, (Vector const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchVector( difftype, (Vector *)pOutputData, (Vector const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
|
|
case FIELD_QUATERNION:
|
|
{
|
|
difftype = CompareQuaternion( (Quaternion *)pOutputData, (Quaternion const *)pInputData, fieldSize );
|
|
CopyQuaternion( difftype, (Quaternion *)pOutputData, (Quaternion const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeQuaternion( difftype, (Quaternion *)pOutputData, (Quaternion const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchQuaternion( difftype, (Quaternion *)pOutputData, (Quaternion const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
|
|
case FIELD_COLOR32:
|
|
{
|
|
difftype = CompareData( 4*fieldSize, (char *)pOutputData, (const char *)pInputData );
|
|
CopyData( difftype, 4*fieldSize, (char *)pOutputData, (const char *)pInputData );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeData( difftype, 4*fieldSize, (char *)pOutputData, (const char *)pInputData );
|
|
if ( bShouldWatch ) WatchData( difftype, 4*fieldSize, (char *)pOutputData, (const char *)pInputData );
|
|
}
|
|
break;
|
|
|
|
case FIELD_BOOLEAN:
|
|
{
|
|
difftype = CompareBool( (bool *)pOutputData, (bool const *)pInputData, fieldSize );
|
|
CopyBool( difftype, (bool *)pOutputData, (bool const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeBool( difftype, (bool *)pOutputData, (bool const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchBool( difftype, (bool *)pOutputData, (bool const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
|
|
case FIELD_INTEGER:
|
|
{
|
|
difftype = CompareInt( (int *)pOutputData, (int const *)pInputData, fieldSize );
|
|
CopyInt( difftype, (int *)pOutputData, (int const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeInt( difftype, (int *)pOutputData, (int const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchInt( difftype, (int *)pOutputData, (int const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
|
|
case FIELD_SHORT:
|
|
{
|
|
difftype = CompareShort( (short *)pOutputData, (short const *)pInputData, fieldSize );
|
|
CopyShort( difftype, (short *)pOutputData, (short const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeShort( difftype, (short *)pOutputData, (short const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchShort( difftype, (short *)pOutputData, (short const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
|
|
case FIELD_CHARACTER:
|
|
{
|
|
difftype = CompareData( fieldSize, ((char *)pOutputData), (const char *)pInputData );
|
|
CopyData( difftype, fieldSize, ((char *)pOutputData), (const char *)pInputData );
|
|
|
|
int valOut = *((char *)pOutputData);
|
|
int valIn = *((const char *)pInputData);
|
|
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeInt( difftype, &valOut, &valIn, fieldSize );
|
|
if ( bShouldWatch ) WatchData( difftype, fieldSize, ((char *)pOutputData), (const char *)pInputData );
|
|
}
|
|
break;
|
|
case FIELD_EHANDLE:
|
|
{
|
|
difftype = CompareEHandle( (EHANDLE *)pOutputData, (EHANDLE const *)pInputData, fieldSize );
|
|
CopyEHandle( difftype, (EHANDLE *)pOutputData, (EHANDLE const *)pInputData, fieldSize );
|
|
if ( m_bErrorCheck && m_bShouldDescribe ) DescribeEHandle( difftype, (EHANDLE *)pOutputData, (EHANDLE const *)pInputData, fieldSize );
|
|
if ( bShouldWatch ) WatchEHandle( difftype, (EHANDLE *)pOutputData, (EHANDLE const *)pInputData, fieldSize );
|
|
}
|
|
break;
|
|
case FIELD_FUNCTION:
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
break;
|
|
case FIELD_VOID:
|
|
{
|
|
// Don't do anything, it's an empty data description
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
Warning( "Bad field type\n" );
|
|
Assert(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_pCurrentClassName = NULL;
|
|
}
|
|
|
|
void CPredictionCopy::TransferData_R( int chaincount, datamap_t *dmap )
|
|
{
|
|
// Copy from here first, then baseclasses
|
|
CopyFields( chaincount, dmap, dmap->dataDesc, dmap->dataNumFields );
|
|
|
|
if ( dmap->baseMap )
|
|
{
|
|
TransferData_R( chaincount, dmap->baseMap );
|
|
}
|
|
}
|
|
|
|
static int g_nChainCount = 1;
|
|
|
|
static typedescription_t *FindFieldByName_R( const char *fieldname, datamap_t *dmap )
|
|
{
|
|
int c = dmap->dataNumFields;
|
|
for ( int i = 0; i < c; i++ )
|
|
{
|
|
typedescription_t *td = &dmap->dataDesc[ i ];
|
|
if ( td->fieldType == FIELD_VOID )
|
|
continue;
|
|
|
|
if ( td->fieldType == FIELD_EMBEDDED )
|
|
{
|
|
// TODO: this will only find the first subclass with the variable of the specified name
|
|
// At some point we might want to support multiple levels of overriding automatically
|
|
typedescription_t *ret = FindFieldByName_R( fieldname, td->td );
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if ( !V_stricmp( td->fieldName, fieldname ) )
|
|
{
|
|
return td;
|
|
}
|
|
}
|
|
|
|
if ( dmap->baseMap )
|
|
{
|
|
return FindFieldByName_R( fieldname, dmap->baseMap );
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void ValidateChains_R( datamap_t *dmap )
|
|
{
|
|
dmap->chains_validated = true;
|
|
|
|
int c = dmap->dataNumFields;
|
|
for ( int i = 0; i < c; i++ )
|
|
{
|
|
typedescription_t *td = &dmap->dataDesc[ i ];
|
|
if ( td->fieldType == FIELD_VOID )
|
|
continue;
|
|
|
|
if ( td->fieldType == FIELD_EMBEDDED )
|
|
{
|
|
ValidateChains_R( td->td );
|
|
continue;
|
|
}
|
|
|
|
if ( !( td->flags & FTYPEDESC_OVERRIDE ) )
|
|
continue;
|
|
|
|
if ( dmap->baseMap )
|
|
{
|
|
typedescription_t *basefield = FindFieldByName_R( td->fieldName, dmap->baseMap );
|
|
if ( basefield )
|
|
{
|
|
td->override_field = basefield;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( dmap->baseMap )
|
|
{
|
|
if ( !dmap->baseMap->chains_validated )
|
|
{
|
|
ValidateChains_R( dmap->baseMap );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *fieldname -
|
|
// *dmap -
|
|
// Output : typedescription_t
|
|
//-----------------------------------------------------------------------------
|
|
typedescription_t *FindFieldByName( const char *fieldname, datamap_t *dmap )
|
|
{
|
|
return FindFieldByName_R( fieldname, dmap );
|
|
}
|
|
|
|
static ConVar pwatchent( "pwatchent", "-1", FCVAR_CHEAT, "Entity to watch for prediction system changes." );
|
|
static ConVar pwatchvar( "pwatchvar", "", FCVAR_CHEAT, "Entity variable to watch in prediction system for changes." );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *fmt -
|
|
// ... -
|
|
//-----------------------------------------------------------------------------
|
|
void CPredictionCopy::WatchMsg( const char *fmt, ... )
|
|
{
|
|
Assert( m_pCurrentField && (m_pCurrentField == m_pWatchField) );
|
|
Assert( m_pOperation );
|
|
|
|
va_list argptr;
|
|
char data[ 4096 ];
|
|
int len;
|
|
va_start(argptr, fmt);
|
|
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
Msg( "%i %s %s : %s\n", gpGlobals->tickcount, m_pOperation, m_pCurrentField->fieldName, data );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *operation -
|
|
// entindex -
|
|
// *dmap -
|
|
//-----------------------------------------------------------------------------
|
|
void CPredictionCopy::DetermineWatchField( const char *operation, int entindex, datamap_t *dmap )
|
|
{
|
|
m_pWatchField = NULL;
|
|
m_pOperation = operation;
|
|
if ( !m_pOperation || !m_pOperation[0] )
|
|
return;
|
|
|
|
int enttowatch = pwatchent.GetInt();
|
|
if ( enttowatch < 0 )
|
|
return;
|
|
|
|
if ( entindex != enttowatch )
|
|
return;
|
|
|
|
// See if they specified a field
|
|
if ( pwatchvar.GetString()[0] == 0 )
|
|
return;
|
|
|
|
m_pWatchField = FindFieldByName( pwatchvar.GetString(), dmap );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *operation -
|
|
// entindex -
|
|
// *dmap -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CPredictionCopy::TransferData( const char *operation, int entindex, datamap_t *dmap )
|
|
{
|
|
++g_nChainCount;
|
|
|
|
if ( !dmap->chains_validated )
|
|
{
|
|
ValidateChains_R( dmap );
|
|
}
|
|
|
|
DetermineWatchField( operation, entindex, dmap );
|
|
|
|
TransferData_R( g_nChainCount, dmap );
|
|
|
|
return m_nErrorCount;
|
|
}
|
|
|
|
/*
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Simply dumps all data fields in object
|
|
//-----------------------------------------------------------------------------
|
|
class CPredictionDescribeData
|
|
{
|
|
public:
|
|
CPredictionDescribeData( void const *src );
|
|
|
|
void DescribeShort( const short *invalue, int count );
|
|
void DescribeInt( const int *invalue, int count );
|
|
void DescribeBool( const bool *invalue, int count );
|
|
void DescribeFloat( const float *invalue, int count );
|
|
void DescribeData( int size, const char *indata );
|
|
void DescribeString( const char *instring );
|
|
void DescribeVector( const Vector &inValue );
|
|
void DescribeVector( const Vector *inValue, int count );
|
|
void DescribeEHandle( EHANDLE const *invalue, int count );
|
|
|
|
void DescribeFields( datamap_t *pMap, typedescription_t *pFields, int fieldCount );
|
|
|
|
private:
|
|
|
|
void const *m_pSrc;
|
|
void Describe( const char *fmt, ... );
|
|
|
|
typedescription_t *m_pCurrentField;
|
|
char const *m_pCurrentClassName;
|
|
datamap_t *m_pCurrentMap;
|
|
};
|
|
*/
|
|
|
|
CPredictionDescribeData::CPredictionDescribeData( void const *src, bool src_packed, FN_FIELD_DESCRIPTION func /*= 0*/ )
|
|
{
|
|
m_pSrc = src;
|
|
m_nSrcOffsetIndex = src_packed ? TD_OFFSET_PACKED : TD_OFFSET_NORMAL;
|
|
|
|
m_pCurrentField = NULL;
|
|
m_pCurrentMap = NULL;
|
|
m_pCurrentClassName = NULL;
|
|
m_bShouldReport = false;
|
|
|
|
m_FieldDescFunc = func;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *fmt -
|
|
// ... -
|
|
//-----------------------------------------------------------------------------
|
|
void CPredictionDescribeData::Describe( const char *fmt, ... )
|
|
{
|
|
// if ( !m_bShouldReport )
|
|
// return;
|
|
|
|
Assert( m_pCurrentMap );
|
|
Assert( m_pCurrentClassName );
|
|
|
|
const char *fieldname = "empty";
|
|
int flags = 0;
|
|
|
|
if ( m_pCurrentField )
|
|
{
|
|
flags = m_pCurrentField->flags;
|
|
fieldname = m_pCurrentField->fieldName ? m_pCurrentField->fieldName : "NULL";
|
|
}
|
|
|
|
va_list argptr;
|
|
char data[ 4096 ];
|
|
int len;
|
|
va_start(argptr, fmt);
|
|
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
bool isprivate = ( flags & FTYPEDESC_PRIVATE ) ? true : false;
|
|
bool isnetworked = ( flags & FTYPEDESC_INSENDTABLE ) ? true : false;
|
|
|
|
if ( m_FieldDescFunc )
|
|
{
|
|
(*m_FieldDescFunc)(
|
|
m_pCurrentClassName,
|
|
m_pCurrentField->fieldName,
|
|
g_FieldTypes[ m_pCurrentField->fieldType ],
|
|
isnetworked,
|
|
data );
|
|
}
|
|
else
|
|
{
|
|
char suffix[ 128 ];
|
|
|
|
suffix[ 0 ] = 0;
|
|
if ( isprivate )
|
|
{
|
|
Q_strncat( suffix, "private", sizeof( suffix ), COPY_ALL_CHARACTERS );
|
|
}
|
|
if ( isnetworked )
|
|
{
|
|
if ( suffix[ 0 ] )
|
|
{
|
|
Q_strncat( suffix, " - ", sizeof( suffix ), COPY_ALL_CHARACTERS );
|
|
}
|
|
Q_strncat( suffix, "net", sizeof( suffix ), COPY_ALL_CHARACTERS );
|
|
}
|
|
|
|
if ( suffix[ 0 ] )
|
|
{
|
|
Msg( "%s::%s(%s) - %s",
|
|
m_pCurrentClassName,
|
|
fieldname,
|
|
suffix,
|
|
data );
|
|
}
|
|
else
|
|
{
|
|
Msg( "%s::%s - %s",
|
|
m_pCurrentClassName,
|
|
fieldname,
|
|
data );
|
|
}
|
|
}
|
|
|
|
m_bShouldReport = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : size -
|
|
// *outdata -
|
|
// *indata -
|
|
//-----------------------------------------------------------------------------
|
|
void CPredictionDescribeData::DescribeData( int size, const char *indata )
|
|
{
|
|
if ( !indata )
|
|
return;
|
|
|
|
Describe( "binary (%i bytes)\n", size );
|
|
}
|
|
|
|
|
|
void CPredictionDescribeData::DescribeShort( const short *invalue, int count )
|
|
{
|
|
Describe( "short (%i)\n", (int)(invalue[0]) );
|
|
}
|
|
|
|
|
|
void CPredictionDescribeData::DescribeInt( const int *invalue, int count )
|
|
{
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
Describe( "[%i] integer (%i)\n", i, invalue[i] );
|
|
}
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeBool( const bool *invalue, int count )
|
|
{
|
|
Describe( "bool (%s)\n", (invalue[0]) ? "true" : "false" );
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeFloat( const float *invalue, int count )
|
|
{
|
|
Describe( "float (%f)\n", invalue[ 0 ] );
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeString( const char *instring )
|
|
{
|
|
Describe( "string (%s)\n", instring );
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeVector( const Vector &inValue )
|
|
{
|
|
Describe( "vector (%f %f %f)\n",
|
|
inValue.x, inValue.y, inValue.z );
|
|
}
|
|
|
|
|
|
void CPredictionDescribeData::DescribeVector( const Vector *inValue, int count )
|
|
{
|
|
Describe( "vector (%f %f %f)\n",
|
|
inValue[0].x, inValue[0].y, inValue[0].z );
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeQuaternion( const Quaternion &inValue )
|
|
{
|
|
Describe( "quaternion (%f %f %f %f)\n",
|
|
inValue[0], inValue[1], inValue[2], inValue[3] );
|
|
}
|
|
|
|
|
|
void CPredictionDescribeData::DescribeQuaternion( const Quaternion *inValue, int count )
|
|
{
|
|
Describe( "quaternion (%f %f %f %f)\n",
|
|
inValue[0][0], inValue[0][1], inValue[0][2], inValue[0][3] );
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeEHandle( EHANDLE const *invalue, int count )
|
|
{
|
|
Describe( "EHandle (%p)\n", (void *)invalue[ 0 ] );
|
|
}
|
|
|
|
void CPredictionDescribeData::DescribeFields_R( int chain_count, datamap_t *pRootMap, typedescription_t *pFields, int fieldCount )
|
|
{
|
|
int i;
|
|
int flags;
|
|
int fieldOffsetSrc;
|
|
int fieldSize;
|
|
|
|
m_pCurrentMap = pRootMap;
|
|
if ( !m_pCurrentClassName )
|
|
{
|
|
m_pCurrentClassName = pRootMap->dataClassName;
|
|
}
|
|
|
|
for ( i = 0; i < fieldCount; i++ )
|
|
{
|
|
m_pCurrentField = &pFields[ i ];
|
|
flags = m_pCurrentField->flags;
|
|
|
|
// Mark any subchains first
|
|
if ( m_pCurrentField->override_field != NULL )
|
|
{
|
|
m_pCurrentField->override_field->override_count = chain_count;
|
|
}
|
|
|
|
// Skip this field?
|
|
if ( m_pCurrentField->override_count == chain_count )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
void const *pInputData;
|
|
|
|
fieldOffsetSrc = m_pCurrentField->fieldOffset[ m_nSrcOffsetIndex ];
|
|
fieldSize = m_pCurrentField->fieldSize;
|
|
|
|
pInputData = (void const *)((char *)m_pSrc + fieldOffsetSrc );
|
|
|
|
// Assume we can report
|
|
m_bShouldReport = true;
|
|
|
|
switch( m_pCurrentField->fieldType )
|
|
{
|
|
case FIELD_EMBEDDED:
|
|
{
|
|
typedescription_t *save = m_pCurrentField;
|
|
void const *saveSrc = m_pSrc;
|
|
const char *saveName = m_pCurrentClassName;
|
|
|
|
m_pCurrentClassName = m_pCurrentField->td->dataClassName;
|
|
|
|
m_pSrc = pInputData;
|
|
if ( ( flags & FTYPEDESC_PTR ) && (m_nSrcOffsetIndex == PC_DATA_NORMAL) )
|
|
{
|
|
m_pSrc = *((void**)m_pSrc);
|
|
}
|
|
|
|
DescribeFields_R( chain_count, pRootMap, m_pCurrentField->td->dataDesc, m_pCurrentField->td->dataNumFields );
|
|
|
|
m_pCurrentClassName = saveName;
|
|
m_pCurrentField = save;
|
|
m_pSrc = saveSrc;
|
|
}
|
|
break;
|
|
case FIELD_FLOAT:
|
|
DescribeFloat( (float const *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_TIME:
|
|
case FIELD_TICK:
|
|
Assert( 0 );
|
|
break;
|
|
case FIELD_STRING:
|
|
DescribeString( (char const*)pInputData );
|
|
break;
|
|
|
|
case FIELD_MODELNAME:
|
|
case FIELD_SOUNDNAME:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_MODELINDEX:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_CUSTOM:
|
|
Assert( 0 );
|
|
break;
|
|
|
|
case FIELD_CLASSPTR:
|
|
case FIELD_EDICT:
|
|
break;
|
|
case FIELD_POSITION_VECTOR:
|
|
Assert( 0 );
|
|
break;
|
|
case FIELD_VECTOR:
|
|
DescribeVector( (const Vector *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_QUATERNION:
|
|
DescribeQuaternion( ( const Quaternion * )pInputData, fieldSize );
|
|
break;
|
|
|
|
case FIELD_COLOR32:
|
|
DescribeData( 4*fieldSize, (const char *)pInputData );
|
|
break;
|
|
|
|
case FIELD_BOOLEAN:
|
|
DescribeBool( (bool const *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_INTEGER:
|
|
DescribeInt( (int const *)pInputData, fieldSize );
|
|
break;
|
|
|
|
case FIELD_SHORT:
|
|
DescribeShort( (short const *)pInputData, fieldSize );
|
|
break;
|
|
|
|
case FIELD_CHARACTER:
|
|
DescribeData( fieldSize, (const char *)pInputData );
|
|
break;
|
|
|
|
case FIELD_EHANDLE:
|
|
DescribeEHandle( (EHANDLE const *)pInputData, fieldSize );
|
|
break;
|
|
case FIELD_FUNCTION:
|
|
Assert( 0 );
|
|
break;
|
|
case FIELD_VOID:
|
|
Describe( "FIELD_VOID: empty field\n" );
|
|
break;
|
|
default:
|
|
Warning( "Bad field type\n" );
|
|
Assert(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_pCurrentClassName = NULL;
|
|
}
|
|
|
|
void CPredictionDescribeData::DumpDescription( datamap_t *pMap )
|
|
{
|
|
++g_nChainCount;
|
|
|
|
if ( !pMap->chains_validated )
|
|
{
|
|
ValidateChains_R( pMap );
|
|
}
|
|
|
|
while ( pMap )
|
|
{
|
|
DescribeFields_R( g_nChainCount, pMap, pMap->dataDesc, pMap->dataNumFields );
|
|
pMap = pMap->baseMap;
|
|
}
|
|
}
|
|
|
|
#if defined( CLIENT_DLL )
|
|
CValueChangeTracker::CValueChangeTracker() :
|
|
m_bActive( false ),
|
|
m_bTracking( false )
|
|
{
|
|
Q_memset( m_OrigValueBuf, 0, sizeof( m_OrigValueBuf ) );
|
|
}
|
|
|
|
C_BaseEntity *CValueChangeTracker::GetEntity()
|
|
{
|
|
return m_hEntityToTrack.Get();
|
|
}
|
|
|
|
void CValueChangeTracker::GetValue( char *buf, size_t bufsize )
|
|
{
|
|
buf[ 0 ] = 0;
|
|
|
|
Assert( IsActive() );
|
|
|
|
if ( !m_hEntityToTrack.Get() )
|
|
return;
|
|
|
|
void const *pInputData = ( const void * )m_hEntityToTrack.Get();
|
|
typedescription_t *td = NULL;
|
|
for ( int i = 0; i < m_FieldStack.Count(); ++i )
|
|
{
|
|
td = m_FieldStack[ i ];
|
|
Assert( ( i == ( m_FieldStack.Count() -1 ) ) ||
|
|
( td->fieldType & FIELD_EMBEDDED ) );
|
|
int fieldOffsetSrc = td->fieldOffset[ TD_OFFSET_NORMAL ];
|
|
const void *pSaveSrc = (const void *)( (char *)pInputData + fieldOffsetSrc );
|
|
if ( ( td->flags & FTYPEDESC_PTR ) &&
|
|
( td->fieldType & FIELD_EMBEDDED ) )
|
|
{
|
|
pInputData = *(const void **)pSaveSrc;
|
|
}
|
|
else
|
|
{
|
|
pInputData = (void const *)((char *)pSaveSrc );
|
|
}
|
|
}
|
|
|
|
if ( !td || !pInputData )
|
|
return;
|
|
|
|
int fieldType = td->fieldType;
|
|
|
|
switch( fieldType )
|
|
{
|
|
default:
|
|
case FIELD_EMBEDDED:
|
|
case FIELD_MODELNAME:
|
|
case FIELD_SOUNDNAME:
|
|
case FIELD_CUSTOM:
|
|
case FIELD_CLASSPTR:
|
|
case FIELD_EDICT:
|
|
case FIELD_POSITION_VECTOR:
|
|
case FIELD_VOID:
|
|
case FIELD_FUNCTION:
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
break;
|
|
case FIELD_FLOAT:
|
|
case FIELD_TIME:
|
|
Q_snprintf( buf, bufsize, "%f", *(float const *)pInputData );
|
|
break;
|
|
case FIELD_STRING:
|
|
Q_snprintf( buf, bufsize, "%s", (char const*)pInputData );
|
|
break;
|
|
case FIELD_VECTOR:
|
|
{
|
|
const Vector *pVec = (const Vector *)pInputData;
|
|
Q_snprintf( buf, bufsize, "%f %f %f", pVec->x, pVec->y, pVec->z );
|
|
}
|
|
break;
|
|
case FIELD_QUATERNION:
|
|
{
|
|
const Quaternion *p = ( const Quaternion * )pInputData;
|
|
Q_snprintf( buf, bufsize, "%f %f %f %f", p->x, p->y, p->z, p->w );
|
|
}
|
|
break;
|
|
|
|
case FIELD_COLOR32:
|
|
{
|
|
const Color *color = ( const Color * )pInputData;
|
|
Q_snprintf( buf, bufsize, "%d %d %d %d", color->r(), color->g(), color->b(), color->a() );
|
|
}
|
|
break;
|
|
|
|
case FIELD_BOOLEAN:
|
|
Q_snprintf( buf, bufsize, "%s", (*(const bool *)pInputData) ? "true" : "false" );
|
|
break;
|
|
case FIELD_INTEGER:
|
|
case FIELD_TICK:
|
|
case FIELD_MODELINDEX:
|
|
Q_snprintf( buf, bufsize, "%i", *(const int*)pInputData );
|
|
break;
|
|
|
|
case FIELD_SHORT:
|
|
Q_snprintf( buf, bufsize, "%i", (int)*(const short*)pInputData );
|
|
break;
|
|
|
|
case FIELD_CHARACTER:
|
|
Q_snprintf( buf, bufsize, "%c", *(const char *)pInputData );
|
|
break;
|
|
|
|
case FIELD_EHANDLE:
|
|
Q_snprintf( buf, bufsize, "eh 0x%p", (void const *)((const EHANDLE *)pInputData)->Get() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CValueChangeTracker::StartTrack( char const *pchContext )
|
|
{
|
|
if ( !IsActive() )
|
|
return;
|
|
|
|
m_strContext = pchContext;
|
|
|
|
// Grab current value into scratch buffer
|
|
GetValue( m_OrigValueBuf, sizeof( m_OrigValueBuf ) );
|
|
|
|
m_bTracking = true;
|
|
}
|
|
|
|
void CValueChangeTracker::EndTrack()
|
|
{
|
|
if ( !IsActive() )
|
|
return;
|
|
|
|
if ( !m_bTracking )
|
|
return;
|
|
m_bTracking = false;
|
|
|
|
char final[ eChangeTrackerBufSize ];
|
|
GetValue( final, sizeof( final ) );
|
|
|
|
CUtlString *history = &m_History[ m_History.AddToTail() ];
|
|
if ( Q_stricmp( final, m_OrigValueBuf ) )
|
|
{
|
|
history->Set( CFmtStr( "+++ %-20.20s: %s (was %s)", m_strContext.String(), final, m_OrigValueBuf ) );
|
|
}
|
|
else
|
|
{
|
|
history->Set( CFmtStr( " %-20.20s: %s", m_strContext.String(), final ) );
|
|
}
|
|
|
|
Msg( ":%s\n", history->String() );
|
|
}
|
|
|
|
void CValueChangeTracker::ClearTracking()
|
|
{
|
|
m_bActive = false;
|
|
m_bTracking = false;
|
|
m_hEntityToTrack = NULL;
|
|
m_strFieldName = "";
|
|
m_History.RemoveAll();
|
|
m_FieldStack.RemoveAll();
|
|
}
|
|
|
|
static bool FindFieldStackByName_R( const char *fieldname, datamap_t *dmap, CUtlVector< typedescription_t * >& stack )
|
|
{
|
|
int c = dmap->dataNumFields;
|
|
for ( int i = 0; i < c; i++ )
|
|
{
|
|
typedescription_t *td = &dmap->dataDesc[ i ];
|
|
|
|
if ( td->fieldType == FIELD_VOID )
|
|
continue;
|
|
|
|
stack.AddToTail( td );
|
|
|
|
if ( td->fieldType == FIELD_EMBEDDED )
|
|
{
|
|
// TODO: this will only find the first subclass with the variable of the specified name
|
|
// At some point we might want to support multiple levels of overriding automatically
|
|
bool ret = FindFieldStackByName_R( fieldname, td->td, stack );
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if ( !Q_stricmp( td->fieldName, fieldname ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
stack.FindAndRemove( td );
|
|
}
|
|
|
|
if ( dmap->baseMap )
|
|
{
|
|
return FindFieldStackByName_R( fieldname, dmap->baseMap, stack );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CValueChangeTracker::SetupTracking( C_BaseEntity *ent, char const *pchFieldName )
|
|
{
|
|
ClearTracking();
|
|
|
|
// Find the field
|
|
datamap_t *dmap = ent->GetPredDescMap();
|
|
if ( !dmap )
|
|
{
|
|
Msg( "No prediction datamap_t for entity %d/%s\n", ent->index, ent->GetClassname() );
|
|
return;
|
|
}
|
|
|
|
bool bFound = FindFieldStackByName_R( pchFieldName, dmap, m_FieldStack );
|
|
if ( !bFound || !m_FieldStack.Count() )
|
|
{
|
|
Msg( "No field '%s' in datamap_t for entity %d/%s\n", pchFieldName, ent->index, ent->GetClassname() );
|
|
return;
|
|
}
|
|
|
|
m_hEntityToTrack = ent;
|
|
m_strFieldName = pchFieldName;
|
|
m_bActive = true;
|
|
}
|
|
|
|
void CValueChangeTracker::Reset()
|
|
{
|
|
m_History.RemoveAll();
|
|
}
|
|
|
|
bool CValueChangeTracker::IsActive() const
|
|
{
|
|
return m_bActive;
|
|
}
|
|
|
|
void CValueChangeTracker::Spew()
|
|
{
|
|
if ( IsActive() )
|
|
{
|
|
for ( int i = 0 ; i < m_History.Count(); ++i )
|
|
{
|
|
Msg( "%s\n", m_History[ i ].String() );
|
|
}
|
|
}
|
|
|
|
Reset();
|
|
}
|
|
|
|
static CValueChangeTracker g_ChangeTracker;
|
|
CValueChangeTracker *g_pChangeTracker = &g_ChangeTracker;
|
|
|
|
CON_COMMAND_F( cl_pred_track, "<entindex> <fieldname>: Track changes to entity index entindex, for field fieldname.", 0 )
|
|
{
|
|
g_pChangeTracker->ClearTracking();
|
|
|
|
if ( args.ArgC() != 3 )
|
|
{
|
|
Msg( "cl_pred_track <entindex> <fieldname>\n" );
|
|
return;
|
|
}
|
|
|
|
int iEntIndex = Q_atoi( args[1] );
|
|
|
|
C_BaseEntity *ent = cl_entitylist->GetBaseEntity( iEntIndex );
|
|
if ( !ent )
|
|
{
|
|
Msg( "cl_pred_track: Unknown ent index %d\n", iEntIndex );
|
|
return;
|
|
}
|
|
|
|
g_pChangeTracker->SetupTracking( ent, args[2] );
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined( CLIENT_DLL ) && defined( COPY_CHECK_STRESSTEST )
|
|
|
|
class CPredictionCopyTester : public IGameSystem
|
|
{
|
|
public:
|
|
|
|
// Init, shutdown
|
|
virtual void Init()
|
|
{
|
|
RunTests();
|
|
Remove( this );
|
|
}
|
|
|
|
virtual void Shutdown() {}
|
|
|
|
// Level init, shutdown
|
|
virtual void LevelInit() {}
|
|
// The level is shutdown in two parts
|
|
virtual void LevelShutdownPreEntity() {}
|
|
// Entities are deleted / released here...
|
|
virtual void LevelShutdownPostEntity() {}
|
|
// end of level shutdown
|
|
|
|
// Called before rendering
|
|
virtual void PreRender ( ) {}
|
|
|
|
// Called after rendering
|
|
virtual void PostRender() {}
|
|
|
|
// Gets called each frame
|
|
virtual void Update( float frametime ) {}
|
|
|
|
private:
|
|
|
|
void RunTests( void );
|
|
};
|
|
|
|
IGameSystem* GetPredictionCopyTester( void )
|
|
{
|
|
static CPredictionCopyTester s_PredictionCopyTesterSystem;
|
|
return &s_PredictionCopyTesterSystem;
|
|
}
|
|
|
|
class CCopyTesterData
|
|
{
|
|
public:
|
|
|
|
CCopyTesterData()
|
|
{
|
|
m_CharValue = 'a';
|
|
m_ShortValue = (short)100;
|
|
m_IntValue = (int)100;
|
|
m_FloatValue = 1.0f;
|
|
Q_strncpy( m_szValue, "primarydata", sizeof( m_szValue ) );
|
|
m_Vector = Vector( 100, 100, 100 );
|
|
m_Bool = false;
|
|
m_Clr.r = m_Clr.g = m_Clr.b = m_Clr.a = 255;
|
|
|
|
m_Ptr = (void *)0xfedcba98;
|
|
// m_hEHandle = NULL;
|
|
}
|
|
|
|
void MakeDifferent( void )
|
|
{
|
|
m_CharValue = 'd';
|
|
m_ShortValue = (short)400;
|
|
m_IntValue = (int)400;
|
|
m_FloatValue = 4.0f;
|
|
Q_strncpy( m_szValue, "secondarydata", sizeof( m_szValue ) );
|
|
m_Vector = Vector( 400, 400, 400 );
|
|
m_Bool = true;
|
|
m_Clr.r = m_Clr.g = m_Clr.b = m_Clr.a = 1;
|
|
m_Ptr = (void *)0x00000001;
|
|
// m_hEHandle = (C_BaseEntity *)0x00000001;
|
|
}
|
|
|
|
DECLARE_PREDICTABLE();
|
|
|
|
char m_CharValue;
|
|
short m_ShortValue;
|
|
int m_IntValue;
|
|
float m_FloatValue;
|
|
char m_szValue[ 128 ];
|
|
Vector m_Vector;
|
|
bool m_Bool;
|
|
color32 m_Clr;
|
|
void *m_Ptr;
|
|
// EHANDLE m_hEHandle;
|
|
|
|
};
|
|
|
|
BEGIN_PREDICTION_DATA_NO_BASE( CCopyTesterData )
|
|
|
|
DEFINE_FIELD( CCopyTesterData, m_CharValue, FIELD_CHARACTER ),
|
|
DEFINE_FIELD( CCopyTesterData, m_ShortValue, FIELD_SHORT ),
|
|
DEFINE_FIELD( CCopyTesterData, m_IntValue, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CCopyTesterData, m_FloatValue, FIELD_FLOAT ),
|
|
DEFINE_FIELD( CCopyTesterData, m_szValue, FIELD_STRING ),
|
|
DEFINE_FIELD( CCopyTesterData, m_Vector, FIELD_VECTOR ),
|
|
DEFINE_FIELD( CCopyTesterData, m_Bool, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( CCopyTesterData, m_Clr, FIELD_COLOR32 ),
|
|
// DEFINE_FIELD( CCopyTesterData, m_hEHandle, FIELD_EHANDLE ),
|
|
|
|
END_PREDICTION_DATA()
|
|
|
|
class CCopyTesterData2 : public C_BaseEntity
|
|
{
|
|
DECLARE_CLASS( CCopyTesterData2, C_BaseEntity );
|
|
|
|
public:
|
|
CCopyTesterData2()
|
|
{
|
|
CONSTRUCT_PREDICTABLE( CCopyTesterData2 );
|
|
|
|
m_CharValue = 'b';
|
|
m_ShortValue = (short)200;
|
|
m_IntValue = (int)200;
|
|
m_FloatValue = 2.0f;
|
|
}
|
|
|
|
void MakeDifferent( void )
|
|
{
|
|
m_CharValue = 'e';
|
|
m_ShortValue = (short)500;
|
|
m_IntValue = (int)500;
|
|
m_FloatValue = 5.0f;
|
|
m_FooData.MakeDifferent();
|
|
}
|
|
|
|
DECLARE_PREDICTABLE();
|
|
|
|
char m_CharValue;
|
|
short m_ShortValue;
|
|
int m_IntValue;
|
|
float m_FloatValue;
|
|
|
|
CCopyTesterData m_FooData;
|
|
};
|
|
|
|
BEGIN_PREDICTION_DATA_NO_BASE( CCopyTesterData2 )
|
|
|
|
DEFINE_FIELD( CCopyTesterData2, m_CharValue, FIELD_CHARACTER ),
|
|
DEFINE_FIELD( CCopyTesterData2, m_ShortValue, FIELD_SHORT ),
|
|
DEFINE_PRED_TYPEDESCRIPTION( CCopyTesterData2, m_FooData, CCopyTesterData ),
|
|
DEFINE_FIELD( CCopyTesterData2, m_IntValue, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CCopyTesterData2, m_FloatValue, FIELD_FLOAT ),
|
|
|
|
END_PREDICTION_DATA()
|
|
|
|
void CPredictionCopyTester::RunTests( void )
|
|
{
|
|
CCopyTesterData2 *foo1, *foo2, *foo3;
|
|
|
|
foo1 = new CCopyTesterData2;
|
|
foo2 = new CCopyTesterData2;
|
|
foo3 = new CCopyTesterData2;
|
|
|
|
foo2->MakeDifferent();
|
|
|
|
|
|
{
|
|
Msg( "Comparing and copying == objects, should have zero diffcount\n" );
|
|
|
|
CPredictionCopy tester( PC_NON_NETWORKED_ONLY, foo1, false, foo3, false, true );
|
|
int diff_count = 0;
|
|
diff_count = tester.TransferData( foo3->GetPredDescMap(), foo1->GetPredDescMap()->dataDesc, foo1->GetPredDescMap()->dataNumFields );
|
|
|
|
Msg( "diff_count == %i\n", diff_count );
|
|
Assert( !diff_count );
|
|
}
|
|
|
|
{
|
|
Msg( "Simple compare of != objects, should spew and have non-zero diffcount\n" );
|
|
|
|
CPredictionCopy tester( PC_NON_NETWORKED_ONLY, foo1, false, foo2, false, true, false );
|
|
int diff_count = 0;
|
|
diff_count = tester.TransferData( foo2->GetPredDescMap(), foo1->GetPredDescMap()->dataDesc, foo1->GetPredDescMap()->dataNumFields );
|
|
|
|
Msg( "diff_count == %i (should be 12)\n", diff_count );
|
|
Assert( diff_count == 12 );
|
|
}
|
|
|
|
{
|
|
Msg( "Comparing and coyping same != objects, should spew and have non-zero diffcount\n" );
|
|
|
|
CPredictionCopy tester( PC_NON_NETWORKED_ONLY, foo1, false, foo2, false, true );
|
|
int diff_count = 0;
|
|
diff_count = tester.TransferData( foo2->GetPredDescMap(), foo1->GetPredDescMap()->dataDesc, foo1->GetPredDescMap()->dataNumFields );
|
|
|
|
Msg( "diff_count == %i (should be 12)\n", diff_count );
|
|
Assert( diff_count == 12 );
|
|
}
|
|
|
|
{
|
|
Msg( "Comparing and copying objects which were just made to coincide, should have zero diffcount\n" );
|
|
|
|
|
|
CPredictionCopy tester( PC_NON_NETWORKED_ONLY, foo1, false, foo2, false, true );
|
|
int diff_count = 0;
|
|
diff_count = tester.TransferData( foo2->GetPredDescMap(), foo1->GetPredDescMap()->dataDesc, foo1->GetPredDescMap()->dataNumFields );
|
|
|
|
Msg( "diff_count == %i\n", diff_count );
|
|
Assert( !diff_count );
|
|
}
|
|
|
|
{
|
|
CPredictionDescribeData describe( foo1, false );
|
|
describe.DumpDescription( foo1->GetPredDescMap(), foo1->GetPredDescMap()->dataDesc, foo1->GetPredDescMap()->dataNumFields );
|
|
}
|
|
|
|
delete foo3;
|
|
delete foo2;
|
|
delete foo1;
|
|
|
|
}
|
|
|
|
#endif // CLIENT_DLL
|
|
#endif // !NO_ENTITY_PREDICTION )
|