d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 5e27785d40
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5e27785d40'
${ noResults }
source-engine/game/shared/predictioncopy.cpp

2242 lines
54 KiB
Raw Blame History

//========= 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 )