FWGS/xash3d-fwgs
2
0
Fork 0
mirror of https://github.com/FWGS/xash3d-fwgs synced 2024-11-11 05:19:01 +01:00
Code Issues 2 Projects Releases Wiki Activity
3503c721ac
xash3d-fwgs/engine/common/net_encode.c

2199 lines
57 KiB
C
Raw Blame History

/*
net_encode.c - encode network messages
Copyright (C) 2010 Uncle Mike
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include "common.h"
#include "netchan.h"
#include "xash3d_mathlib.h"
#include "net_encode.h"
#include "event_api.h"
#include "usercmd.h"
#include "pm_movevars.h"
#include "entity_state.h"
#include "weaponinfo.h"
#include "event_args.h"
#include "protocol.h"
#include "client.h"
#define DELTA_PATH "delta.lst"
#define DT_BYTE BIT( 0 ) // A byte
#define DT_SHORT BIT( 1 ) // 2 byte field
#define DT_FLOAT BIT( 2 ) // A floating point field
#define DT_INTEGER BIT( 3 ) // 4 byte integer
#define DT_ANGLE BIT( 4 ) // A floating point angle ( will get masked correctly )
#define DT_TIMEWINDOW_8 BIT( 5 ) // A floating point timestamp, relative to sv.time
#define DT_TIMEWINDOW_BIG BIT( 6 ) // and re-encoded on the client relative to the client's clock
#define DT_STRING BIT( 7 ) // A null terminated string, sent as 8 byte chars
#define DT_SIGNED BIT( 8 ) // sign modificator
#define NUM_FIELDS( x ) ((sizeof( x ) / sizeof( x[0] )) - 1)
// helper macroses
#define ENTS_DEF( x ) #x, offsetof( entity_state_t, x ), sizeof( ((entity_state_t *)0)->x )
#define UCMD_DEF( x ) #x, offsetof( usercmd_t, x ), sizeof( ((usercmd_t *)0)->x )
#define EVNT_DEF( x ) #x, offsetof( event_args_t, x ), sizeof( ((event_args_t *)0)->x )
#define PHYS_DEF( x ) #x, offsetof( movevars_t, x ), sizeof( ((movevars_t *)0)->x )
#define CLDT_DEF( x ) #x, offsetof( clientdata_t, x ), sizeof( ((clientdata_t *)0)->x )
#define WPDT_DEF( x ) #x, offsetof( weapon_data_t, x ), sizeof( ((weapon_data_t *)0)->x )
static qboolean delta_init = false;
// list of all the struct names
static const delta_field_t cmd_fields[] =
{
{ UCMD_DEF( lerp_msec ) },
{ UCMD_DEF( msec ) },
{ UCMD_DEF( viewangles[0] ) },
{ UCMD_DEF( viewangles[1] ) },
{ UCMD_DEF( viewangles[2] ) },
{ UCMD_DEF( forwardmove ) },
{ UCMD_DEF( sidemove ) },
{ UCMD_DEF( upmove ) },
{ UCMD_DEF( lightlevel ) },
{ UCMD_DEF( buttons ) },
{ UCMD_DEF( impulse ) },
{ UCMD_DEF( weaponselect ) },
{ UCMD_DEF( impact_index ) },
{ UCMD_DEF( impact_position[0] ) },
{ UCMD_DEF( impact_position[1] ) },
{ UCMD_DEF( impact_position[2] ) },
{ NULL },
};
static const delta_field_t pm_fields[] =
{
{ PHYS_DEF( gravity ) },
{ PHYS_DEF( stopspeed ) },
{ PHYS_DEF( maxspeed ) },
{ PHYS_DEF( spectatormaxspeed ) },
{ PHYS_DEF( accelerate ) },
{ PHYS_DEF( airaccelerate ) },
{ PHYS_DEF( wateraccelerate ) },
{ PHYS_DEF( friction ) },
{ PHYS_DEF( edgefriction ) },
{ PHYS_DEF( waterfriction ) },
{ PHYS_DEF( bounce ) },
{ PHYS_DEF( stepsize ) },
{ PHYS_DEF( maxvelocity ) },
{ PHYS_DEF( zmax ) },
{ PHYS_DEF( waveHeight ) },
{ PHYS_DEF( footsteps ) },
{ PHYS_DEF( skyName ) },
{ PHYS_DEF( rollangle ) },
{ PHYS_DEF( rollspeed ) },
{ PHYS_DEF( skycolor_r ) },
{ PHYS_DEF( skycolor_g ) },
{ PHYS_DEF( skycolor_b ) },
{ PHYS_DEF( skyvec_x ) },
{ PHYS_DEF( skyvec_y ) },
{ PHYS_DEF( skyvec_z ) },
{ PHYS_DEF( fog_settings ) },
{ PHYS_DEF( wateralpha ) },
{ PHYS_DEF( skydir_x ) },
{ PHYS_DEF( skydir_y ) },
{ PHYS_DEF( skydir_z ) },
{ PHYS_DEF( skyangle ) },
{ NULL },
};
static const delta_field_t ev_fields[] =
{
{ EVNT_DEF( flags ) },
{ EVNT_DEF( entindex ) },
{ EVNT_DEF( origin[0] ) },
{ EVNT_DEF( origin[1] ) },
{ EVNT_DEF( origin[2] ) },
{ EVNT_DEF( angles[0] ) },
{ EVNT_DEF( angles[1] ) },
{ EVNT_DEF( angles[2] ) },
{ EVNT_DEF( velocity[0] ) },
{ EVNT_DEF( velocity[1] ) },
{ EVNT_DEF( velocity[2] ) },
{ EVNT_DEF( ducking ) },
{ EVNT_DEF( fparam1 ) },
{ EVNT_DEF( fparam2 ) },
{ EVNT_DEF( iparam1 ) },
{ EVNT_DEF( iparam2 ) },
{ EVNT_DEF( bparam1 ) },
{ EVNT_DEF( bparam2 ) },
{ NULL },
};
static const delta_field_t wd_fields[] =
{
{ WPDT_DEF( m_iId ) },
{ WPDT_DEF( m_iClip ) },
{ WPDT_DEF( m_flNextPrimaryAttack ) },
{ WPDT_DEF( m_flNextSecondaryAttack ) },
{ WPDT_DEF( m_flTimeWeaponIdle ) },
{ WPDT_DEF( m_fInReload ) },
{ WPDT_DEF( m_fInSpecialReload ) },
{ WPDT_DEF( m_flNextReload ) },
{ WPDT_DEF( m_flPumpTime ) },
{ WPDT_DEF( m_fReloadTime ) },
{ WPDT_DEF( m_fAimedDamage ) },
{ WPDT_DEF( m_fNextAimBonus ) },
{ WPDT_DEF( m_fInZoom ) },
{ WPDT_DEF( m_iWeaponState ) },
{ WPDT_DEF( iuser1 ) },
{ WPDT_DEF( iuser2 ) },
{ WPDT_DEF( iuser3 ) },
{ WPDT_DEF( iuser4 ) },
{ WPDT_DEF( fuser1 ) },
{ WPDT_DEF( fuser2 ) },
{ WPDT_DEF( fuser3 ) },
{ WPDT_DEF( fuser4 ) },
{ NULL },
};
static const delta_field_t cd_fields[] =
{
{ CLDT_DEF( origin[0] ) },
{ CLDT_DEF( origin[1] ) },
{ CLDT_DEF( origin[2] ) },
{ CLDT_DEF( velocity[0] ) },
{ CLDT_DEF( velocity[1] ) },
{ CLDT_DEF( velocity[2] ) },
{ CLDT_DEF( viewmodel ) },
{ CLDT_DEF( punchangle[0] ) },
{ CLDT_DEF( punchangle[1] ) },
{ CLDT_DEF( punchangle[2] ) },
{ CLDT_DEF( flags ) },
{ CLDT_DEF( waterlevel ) },
{ CLDT_DEF( watertype ) },
{ CLDT_DEF( view_ofs[0] ) },
{ CLDT_DEF( view_ofs[1] ) },
{ CLDT_DEF( view_ofs[2] ) },
{ CLDT_DEF( health ) },
{ CLDT_DEF( bInDuck ) },
{ CLDT_DEF( weapons ) },
{ CLDT_DEF( flTimeStepSound ) },
{ CLDT_DEF( flDuckTime ) },
{ CLDT_DEF( flSwimTime ) },
{ CLDT_DEF( waterjumptime ) },
{ CLDT_DEF( maxspeed ) },
{ CLDT_DEF( fov ) },
{ CLDT_DEF( weaponanim ) },
{ CLDT_DEF( m_iId ) },
{ CLDT_DEF( ammo_shells ) },
{ CLDT_DEF( ammo_nails ) },
{ CLDT_DEF( ammo_cells ) },
{ CLDT_DEF( ammo_rockets ) },
{ CLDT_DEF( m_flNextAttack ) },
{ CLDT_DEF( tfstate ) },
{ CLDT_DEF( pushmsec ) },
{ CLDT_DEF( deadflag ) },
{ CLDT_DEF( physinfo ) },
{ CLDT_DEF( iuser1 ) },
{ CLDT_DEF( iuser2 ) },
{ CLDT_DEF( iuser3 ) },
{ CLDT_DEF( iuser4 ) },
{ CLDT_DEF( fuser1 ) },
{ CLDT_DEF( fuser2 ) },
{ CLDT_DEF( fuser3 ) },
{ CLDT_DEF( fuser4 ) },
{ CLDT_DEF( vuser1[0] ) },
{ CLDT_DEF( vuser1[1] ) },
{ CLDT_DEF( vuser1[2] ) },
{ CLDT_DEF( vuser2[0] ) },
{ CLDT_DEF( vuser2[1] ) },
{ CLDT_DEF( vuser2[2] ) },
{ CLDT_DEF( vuser3[0] ) },
{ CLDT_DEF( vuser3[1] ) },
{ CLDT_DEF( vuser3[2] ) },
{ CLDT_DEF( vuser4[0] ) },
{ CLDT_DEF( vuser4[1] ) },
{ CLDT_DEF( vuser4[2] ) },
{ NULL },
};
static const delta_field_t ent_fields[] =
{
{ ENTS_DEF( entityType ) },
{ ENTS_DEF( origin[0] ) },
{ ENTS_DEF( origin[1] ) },
{ ENTS_DEF( origin[2] ) },
{ ENTS_DEF( angles[0] ) },
{ ENTS_DEF( angles[1] ) },
{ ENTS_DEF( angles[2] ) },
{ ENTS_DEF( modelindex ) },
{ ENTS_DEF( sequence ) },
{ ENTS_DEF( frame ) },
{ ENTS_DEF( colormap ) },
{ ENTS_DEF( skin ) },
{ ENTS_DEF( solid ) },
{ ENTS_DEF( effects ) },
{ ENTS_DEF( scale ) },
{ ENTS_DEF( eflags ) },
{ ENTS_DEF( rendermode ) },
{ ENTS_DEF( renderamt ) },
{ ENTS_DEF( rendercolor.r ) },
{ ENTS_DEF( rendercolor.g ) },
{ ENTS_DEF( rendercolor.b ) },
{ ENTS_DEF( renderfx ) },
{ ENTS_DEF( movetype ) },
{ ENTS_DEF( animtime ) },
{ ENTS_DEF( framerate ) },
{ ENTS_DEF( body ) },
{ ENTS_DEF( controller[0] ) },
{ ENTS_DEF( controller[1] ) },
{ ENTS_DEF( controller[2] ) },
{ ENTS_DEF( controller[3] ) },
{ ENTS_DEF( blending[0] ) },
{ ENTS_DEF( blending[1] ) },
{ ENTS_DEF( blending[2] ) },
{ ENTS_DEF( blending[3] ) },
{ ENTS_DEF( velocity[0] ) },
{ ENTS_DEF( velocity[1] ) },
{ ENTS_DEF( velocity[2] ) },
{ ENTS_DEF( mins[0] ) },
{ ENTS_DEF( mins[1] ) },
{ ENTS_DEF( mins[2] ) },
{ ENTS_DEF( maxs[0] ) },
{ ENTS_DEF( maxs[1] ) },
{ ENTS_DEF( maxs[2] ) },
{ ENTS_DEF( aiment ) },
{ ENTS_DEF( owner ) },
{ ENTS_DEF( friction ) },
{ ENTS_DEF( gravity ) },
{ ENTS_DEF( team ) },
{ ENTS_DEF( playerclass ) },
{ ENTS_DEF( health ) },
{ ENTS_DEF( spectator ) },
{ ENTS_DEF( weaponmodel ) },
{ ENTS_DEF( gaitsequence ) },
{ ENTS_DEF( basevelocity[0] ) },
{ ENTS_DEF( basevelocity[1] ) },
{ ENTS_DEF( basevelocity[2] ) },
{ ENTS_DEF( usehull ) },
{ ENTS_DEF( oldbuttons ) }, // probably never transmitted
{ ENTS_DEF( onground ) },
{ ENTS_DEF( iStepLeft ) },
{ ENTS_DEF( flFallVelocity ) },
{ ENTS_DEF( fov ) },
{ ENTS_DEF( weaponanim ) },
{ ENTS_DEF( startpos[0] ) },
{ ENTS_DEF( startpos[1] ) },
{ ENTS_DEF( startpos[2] ) },
{ ENTS_DEF( endpos[0] ) },
{ ENTS_DEF( endpos[1] ) },
{ ENTS_DEF( endpos[2] ) },
{ ENTS_DEF( impacttime ) },
{ ENTS_DEF( starttime ) },
{ ENTS_DEF( iuser1 ) },
{ ENTS_DEF( iuser2 ) },
{ ENTS_DEF( iuser3 ) },
{ ENTS_DEF( iuser4 ) },
{ ENTS_DEF( fuser1 ) },
{ ENTS_DEF( fuser2 ) },
{ ENTS_DEF( fuser3 ) },
{ ENTS_DEF( fuser4 ) },
{ ENTS_DEF( vuser1[0] ) },
{ ENTS_DEF( vuser1[1] ) },
{ ENTS_DEF( vuser1[2] ) },
{ ENTS_DEF( vuser2[0] ) },
{ ENTS_DEF( vuser2[1] ) },
{ ENTS_DEF( vuser2[2] ) },
{ ENTS_DEF( vuser3[0] ) },
{ ENTS_DEF( vuser3[1] ) },
{ ENTS_DEF( vuser3[2] ) },
{ ENTS_DEF( vuser4[0] ) },
{ ENTS_DEF( vuser4[1] ) },
{ ENTS_DEF( vuser4[2] ) },
{ NULL },
};
#if XASH_ENGINE_TESTS
typedef struct delta_test_struct_t
{
char dt_string[128]; // always signed
float dt_timewindow_big; // always signed
float dt_timewindow_8; // always signed
float dt_angle; // always_signed
float dt_float_signed;
float dt_float_unsigned;
int32_t dt_integer_signed;
uint32_t dt_integer_unsigned;
int16_t dt_short_signed;
uint16_t dt_short_unsigned;
int8_t dt_byte_signed;
uint8_t dt_byte_unsigned;
} delta_test_struct_t;
#define TEST_DEF( x ) #x, offsetof( delta_test_struct_t, x ), sizeof( ((delta_test_struct_t *)0)->x )
static const delta_field_t test_fields[] =
{
{ TEST_DEF( dt_string ) },
{ TEST_DEF( dt_timewindow_big )},
{ TEST_DEF( dt_timewindow_8 )},
{ TEST_DEF( dt_angle ) },
{ TEST_DEF( dt_float_signed ) },
{ TEST_DEF( dt_float_unsigned ) },
{ TEST_DEF( dt_integer_signed ) },
{ TEST_DEF( dt_integer_unsigned ) },
{ TEST_DEF( dt_short_signed ) },
{ TEST_DEF( dt_short_unsigned ) },
{ TEST_DEF( dt_byte_signed ) },
{ TEST_DEF( dt_byte_unsigned ) },
{ NULL },
};
#endif
enum
{
DT_EVENT_T = 0,
DT_MOVEVARS_T,
DT_USERCMD_T,
DT_CLIENTDATA_T,
DT_WEAPONDATA_T,
DT_ENTITY_STATE_T,
DT_ENTITY_STATE_PLAYER_T,
DT_CUSTOM_ENTITY_STATE_T,
#if XASH_ENGINE_TESTS
DT_DELTA_TEST_STRUCT_T,
#endif
DT_STRUCT_COUNT
};
static delta_info_t dt_info[] =
{
[DT_EVENT_T] = { "event_t", ev_fields, NUM_FIELDS( ev_fields ) },
[DT_MOVEVARS_T] = { "movevars_t", pm_fields, NUM_FIELDS( pm_fields ) },
[DT_USERCMD_T] = { "usercmd_t", cmd_fields, NUM_FIELDS( cmd_fields ) },
[DT_CLIENTDATA_T] = { "clientdata_t", cd_fields, NUM_FIELDS( cd_fields ) },
[DT_WEAPONDATA_T] = { "weapon_data_t", wd_fields, NUM_FIELDS( wd_fields ) },
[DT_ENTITY_STATE_T] = { "entity_state_t", ent_fields, NUM_FIELDS( ent_fields ) },
[DT_ENTITY_STATE_PLAYER_T] = { "entity_state_player_t", ent_fields, NUM_FIELDS( ent_fields ) },
[DT_CUSTOM_ENTITY_STATE_T] = { "custom_entity_state_t", ent_fields, NUM_FIELDS( ent_fields ) },
#if XASH_ENGINE_TESTS
[DT_DELTA_TEST_STRUCT_T] = { "delta_test_struct_t", test_fields, NUM_FIELDS( test_fields ) },
#endif
[DT_STRUCT_COUNT] = { NULL },
};
static delta_info_t *Delta_FindStruct( const char *name )
{
int i;
if( !COM_CheckString( name ))
return NULL;
for( i = 0; i < NUM_FIELDS( dt_info ); i++ )
{
if( !Q_stricmp( dt_info[i].pName, name ))
return &dt_info[i];
}
Con_DPrintf( S_WARN "Struct %s not found in delta_info\n", name );
// found nothing
return NULL;
}
static int Delta_NumTables( void )
{
return NUM_FIELDS( dt_info );
}
static delta_info_t *Delta_FindStructByIndex( int index )
{
return &dt_info[index];
}
static delta_info_t *Delta_FindStructByEncoder( const char *encoderName )
{
int i;
if( !COM_CheckString( encoderName ) )
return NULL;
for( i = 0; i < NUM_FIELDS( dt_info ); i++ )
{
if( !Q_stricmp( dt_info[i].funcName, encoderName ))
return &dt_info[i];
}
// found nothing
return NULL;
}
static delta_info_t *Delta_FindStructByDelta( const delta_t *pFields )
{
int i;
if( !pFields ) return NULL;
for( i = 0; i < NUM_FIELDS( dt_info ); i++ )
{
if( dt_info[i].pFields == pFields )
return &dt_info[i];
}
// found nothing
return NULL;
}
static void Delta_CustomEncode( delta_info_t *dt, const void *from, const void *to )
{
int i;
Assert( dt != NULL );
// set all fields is active by default
for( i = 0; i < dt->numFields; i++ )
dt->pFields[i].bInactive = false;
if( dt->userCallback )
dt->userCallback( dt->pFields, from, to );
}
static delta_field_t *Delta_FindFieldInfo( const delta_field_t *pInfo, const char *fieldName )
{
if( !fieldName || !*fieldName )
return NULL;
for( ; pInfo->name; pInfo++ )
{
if( !Q_strcmp( pInfo->name, fieldName ))
return (delta_field_t *)pInfo;
}
return NULL;
}
static int Delta_IndexForFieldInfo( const delta_field_t *pInfo, const char *fieldName )
{
int i;
if( !fieldName || !*fieldName )
return -1;
for( i = 0; pInfo->name; i++, pInfo++ )
{
if( !Q_strcmp( pInfo->name, fieldName ))
return i;
}
return -1;
}
static qboolean Delta_AddField( delta_info_t *dt, const char *pName, int flags, int bits, float mul, float post_mul )
{
delta_field_t *pFieldInfo;
delta_t *pField;
int i;
// check for coexisting field
for( i = 0, pField = dt->pFields; i < dt->numFields; i++, pField++ )
{
if( !Q_strcmp( pField->name, pName ))
{
// update existed field
pField->flags = flags;
pField->bits = bits;
pField->multiplier = mul;
pField->post_multiplier = post_mul;
return true;
}
}
// find field description
pFieldInfo = Delta_FindFieldInfo( dt->pInfo, pName );
if( !pFieldInfo )
{
Con_DPrintf( S_ERROR "Delta_Add: couldn't find description for %s->%s\n", dt->pName, pName );
return false;
}
if( dt->numFields + 1 > dt->maxFields )
{
Con_DPrintf( S_WARN "Delta_Add: can't add %s->%s encoder list is full\n", dt->pName, pName );
return false; // too many fields specified (duplicated ?)
}
// allocate a new one
dt->pFields = Z_Realloc( dt->pFields, (dt->numFields + 1) * sizeof( delta_t ));
for( i = 0, pField = dt->pFields; i < dt->numFields; i++, pField++ );
// copy info to new field
pField->name = pFieldInfo->name;
pField->offset = pFieldInfo->offset;
pField->size = pFieldInfo->size;
pField->flags = flags;
pField->bits = bits;
pField->multiplier = mul;
pField->post_multiplier = post_mul;
dt->numFields++;
return true;
}
static void Delta_WriteTableField( sizebuf_t *msg, int tableIndex, const delta_t *pField )
{
int nameIndex;
delta_info_t *dt;
Assert( pField != NULL );
if( !COM_CheckString( pField->name ))
return;// not initialized ?
dt = Delta_FindStructByIndex( tableIndex );
Assert( dt && dt->bInitialized );
nameIndex = Delta_IndexForFieldInfo( dt->pInfo, pField->name );
Assert( nameIndex >= 0 && nameIndex < dt->maxFields );
MSG_BeginServerCmd( msg, svc_deltatable );
MSG_WriteUBitLong( msg, tableIndex, 4 ); // assume we support 16 network tables
MSG_WriteUBitLong( msg, nameIndex, 8 ); // 255 fields by struct should be enough
MSG_WriteUBitLong( msg, pField->flags, 10 ); // flags are indicated various input types
MSG_WriteUBitLong( msg, pField->bits - 1, 5 ); // max received value is 32 (32 bit)
// multipliers is null-compressed
if( !Q_equal( pField->multiplier, 1.0f ))
{
MSG_WriteOneBit( msg, 1 );
MSG_WriteFloat( msg, pField->multiplier );
}
else MSG_WriteOneBit( msg, 0 );
if( !Q_equal( pField->post_multiplier, 1.0f ))
{
MSG_WriteOneBit( msg, 1 );
MSG_WriteFloat( msg, pField->post_multiplier );
}
else MSG_WriteOneBit( msg, 0 );
}
void Delta_ParseTableField( sizebuf_t *msg )
{
int tableIndex, nameIndex;
float mul = 1.0f, post_mul = 1.0f;
int flags, bits;
const char *pName;
qboolean ignore = false;
delta_info_t *dt;
tableIndex = MSG_ReadUBitLong( msg, 4 );
dt = Delta_FindStructByIndex( tableIndex );
if( !dt )
Host_Error( "Delta_ParseTableField: not initialized" );
nameIndex = MSG_ReadUBitLong( msg, 8 ); // read field name index
if( ( nameIndex >= 0 && nameIndex < dt->maxFields ) )
{
pName = dt->pInfo[nameIndex].name;
}
else
{
ignore = true;
Con_Reportf( "Delta_ParseTableField: wrong nameIndex %d for table %s, ignoring\n", nameIndex, dt->pName );
}
flags = MSG_ReadUBitLong( msg, 10 );
bits = MSG_ReadUBitLong( msg, 5 ) + 1;
// read the multipliers
if( MSG_ReadOneBit( msg ))
mul = MSG_ReadFloat( msg );
if( MSG_ReadOneBit( msg ))
post_mul = MSG_ReadFloat( msg );
if( ignore )
return;
// delta encoders it's already initialized on this machine (local game)
if( delta_init )
Delta_Shutdown();
// add field to table
Delta_AddField( dt, pName, flags, bits, mul, post_mul );
}
static qboolean Delta_ParseField( char **delta_script, const delta_field_t *pInfo, delta_t *pField, qboolean bPost )
{
string token;
delta_field_t *pFieldInfo;
char *oldpos;
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( Q_strcmp( token, "(" ))
{
Con_DPrintf( S_ERROR "Delta_ParseField: expected '(', found '%s' instead\n", token );
return false;
}
// read the variable name
if(( *delta_script = COM_ParseFile( *delta_script, token, sizeof( token ))) == NULL )
{
Con_DPrintf( S_ERROR "Delta_ParseField: missing field name\n" );
return false;
}
pFieldInfo = Delta_FindFieldInfo( pInfo, token );
if( !pFieldInfo )
{
Con_DPrintf( S_ERROR "Delta_ParseField: unable to find field %s\n", token );
return false;
}
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( Q_strcmp( token, "," ))
{
Con_DPrintf( S_ERROR "Delta_ParseField: expected ',', found '%s' instead\n", token );
return false;
}
// copy base info to new field
pField->name = pFieldInfo->name;
pField->offset = pFieldInfo->offset;
pField->size = pFieldInfo->size;
pField->flags = 0;
// read delta-flags
while(( *delta_script = COM_ParseFile( *delta_script, token, sizeof( token ))) != NULL )
{
if( !Q_strcmp( token, "," ))
break; // end of flags argument
if( !Q_strcmp( token, "|" ))
continue;
if( !Q_strcmp( token, "DT_BYTE" ))
pField->flags |= DT_BYTE;
else if( !Q_strcmp( token, "DT_SHORT" ))
pField->flags |= DT_SHORT;
else if( !Q_strcmp( token, "DT_FLOAT" ))
pField->flags |= DT_FLOAT;
else if( !Q_strcmp( token, "DT_INTEGER" ))
pField->flags |= DT_INTEGER;
else if( !Q_strcmp( token, "DT_ANGLE" ))
pField->flags |= DT_ANGLE;
else if( !Q_strcmp( token, "DT_TIMEWINDOW_8" ))
pField->flags |= DT_TIMEWINDOW_8;
else if( !Q_strcmp( token, "DT_TIMEWINDOW_BIG" ))
pField->flags |= DT_TIMEWINDOW_BIG;
else if( !Q_strcmp( token, "DT_STRING" ))
pField->flags |= DT_STRING;
else if( !Q_strcmp( token, "DT_SIGNED" ))
pField->flags |= DT_SIGNED;
}
if( Q_strcmp( token, "," ))
{
Con_DPrintf( S_ERROR "Delta_ParseField: expected ',', found '%s' instead\n", token );
return false;
}
// read delta-bits
if(( *delta_script = COM_ParseFile( *delta_script, token, sizeof( token ))) == NULL )
{
Con_DPrintf( S_ERROR "Delta_ParseField: %s field bits argument is missing\n", pField->name );
return false;
}
pField->bits = Q_atoi( token );
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( Q_strcmp( token, "," ))
{
Con_DPrintf( S_ERROR "Delta_ParseField: expected ',', found '%s' instead\n", token );
return false;
}
// read delta-multiplier
if(( *delta_script = COM_ParseFile( *delta_script, token, sizeof( token ))) == NULL )
{
Con_DPrintf( S_ERROR "Delta_ParseField: %s missing 'multiplier' argument\n", pField->name );
return false;
}
pField->multiplier = Q_atof( token );
if( bPost )
{
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( Q_strcmp( token, "," ))
{
Con_DPrintf( S_ERROR "Delta_ParseField: expected ',', found '%s' instead\n", token );
return false;
}
// read delta-postmultiplier
if(( *delta_script = COM_ParseFile( *delta_script, token, sizeof( token ))) == NULL )
{
Con_DPrintf( S_ERROR "Delta_ParseField: %s missing 'post_multiply' argument\n", pField->name );
return false;
}
pField->post_multiplier = Q_atof( token );
}
else
{
// to avoid division by zero
pField->post_multiplier = 1.0f;
}
// closing brace...
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( Q_strcmp( token, ")" ))
{
Con_DPrintf( S_ERROR "Delta_ParseField: expected ')', found '%s' instead\n", token );
return false;
}
// ... and trying to parse optional ',' post-symbol
oldpos = *delta_script;
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( token[0] != ',' ) *delta_script = oldpos; // not a ','
return true;
}
static void Delta_ParseTable( char **delta_script, delta_info_t *dt, const char *encodeDll, const char *encodeFunc )
{
string token;
delta_t *pField;
const delta_field_t *pInfo;
// allocate the delta-structures
if( !dt->pFields ) dt->pFields = (delta_t *)Z_Calloc( dt->maxFields * sizeof( delta_t ));
pField = dt->pFields;
pInfo = dt->pInfo;
dt->numFields = 0;
// assume we have handled '{'
while(( *delta_script = COM_ParseFile( *delta_script, token, sizeof( token ))) != NULL )
{
Assert( dt->numFields <= dt->maxFields );
if( !Q_strcmp( token, "DEFINE_DELTA" ))
{
if( Delta_ParseField( delta_script, pInfo, &pField[dt->numFields], false ))
dt->numFields++;
}
else if( !Q_strcmp( token, "DEFINE_DELTA_POST" ))
{
if( Delta_ParseField( delta_script, pInfo, &pField[dt->numFields], true ))
dt->numFields++;
}
else if( token[0] == '}' )
{
// end of the section
break;
}
}
// copy function name
Q_strncpy( dt->funcName, encodeFunc, sizeof( dt->funcName ));
if( !Q_stricmp( encodeDll, "none" ))
dt->customEncode = CUSTOM_NONE;
else if( !Q_stricmp( encodeDll, "gamedll" ))
dt->customEncode = CUSTOM_SERVER_ENCODE;
else if( !Q_stricmp( encodeDll, "clientdll" ))
dt->customEncode = CUSTOM_CLIENT_ENCODE;
// adjust to fit memory size
if( dt->numFields < dt->maxFields )
{
dt->pFields = Z_Realloc( dt->pFields, dt->numFields * sizeof( delta_t ));
}
dt->bInitialized = true; // table is ok
}
static void Delta_InitFields( void )
{
byte *afile;
char *pfile;
string encodeDll, encodeFunc, token;
delta_info_t *dt;
afile = FS_LoadFile( DELTA_PATH, NULL, false );
if( !afile ) Sys_Error( "DELTA_Load: couldn't load file %s\n", DELTA_PATH );
pfile = (char *)afile;
while(( pfile = COM_ParseFile( pfile, token, sizeof( token ))) != NULL )
{
dt = Delta_FindStruct( token );
if( dt == NULL )
{
Sys_Error( "%s: unknown struct %s\n", DELTA_PATH, token );
}
pfile = COM_ParseFile( pfile, encodeDll, sizeof( encodeDll ));
if( !Q_stricmp( encodeDll, "none" ))
Q_strncpy( encodeFunc, "null", sizeof( encodeFunc ));
else pfile = COM_ParseFile( pfile, encodeFunc, sizeof( encodeFunc ));
// jump to '{'
pfile = COM_ParseFile( pfile, token, sizeof( token ));
if( token[0] != '{' )
{
Sys_Error( "%s: missing '{' in section %s\n", DELTA_PATH, dt->pName );
}
Delta_ParseTable( &pfile, dt, encodeDll, encodeFunc );
}
Mem_Free( afile );
}
void Delta_Init( void )
{
delta_info_t *dt;
// shutdown it first
if( delta_init ) Delta_Shutdown ();
Delta_InitFields (); // initialize fields
delta_init = true;
dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
Assert( dt != NULL );
if( dt->bInitialized ) return; // "movevars_t" already specified by user
// create movevars_t delta internal
Delta_AddField( dt, "gravity", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "stopspeed", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "maxspeed", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "spectatormaxspeed", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "accelerate", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "airaccelerate", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "wateraccelerate", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "friction", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "edgefriction", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "waterfriction", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "bounce", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "stepsize", DT_FLOAT|DT_SIGNED, 16, 16.0f, 1.0f );
Delta_AddField( dt, "maxvelocity", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
if( FBitSet( host.features, ENGINE_WRITE_LARGE_COORD ))
Delta_AddField( dt, "zmax", DT_FLOAT|DT_SIGNED, 18, 1.0f, 1.0f );
else Delta_AddField( dt, "zmax", DT_FLOAT|DT_SIGNED, 16, 1.0f, 1.0f );
Delta_AddField( dt, "waveHeight", DT_FLOAT|DT_SIGNED, 16, 16.0f, 1.0f );
Delta_AddField( dt, "skyName", DT_STRING, 1, 1.0f, 1.0f );
Delta_AddField( dt, "footsteps", DT_INTEGER, 1, 1.0f, 1.0f );
Delta_AddField( dt, "rollangle", DT_FLOAT|DT_SIGNED, 16, 32.0f, 1.0f );
Delta_AddField( dt, "rollspeed", DT_FLOAT|DT_SIGNED, 16, 8.0f, 1.0f );
Delta_AddField( dt, "skycolor_r", DT_FLOAT|DT_SIGNED, 16, 1.0f, 1.0f ); // 0 - 264
Delta_AddField( dt, "skycolor_g", DT_FLOAT|DT_SIGNED, 16, 1.0f, 1.0f );
Delta_AddField( dt, "skycolor_b", DT_FLOAT|DT_SIGNED, 16, 1.0f, 1.0f );
Delta_AddField( dt, "skyvec_x", DT_FLOAT|DT_SIGNED, 16, 32.0f, 1.0f ); // 0 - 1
Delta_AddField( dt, "skyvec_y", DT_FLOAT|DT_SIGNED, 16, 32.0f, 1.0f );
Delta_AddField( dt, "skyvec_z", DT_FLOAT|DT_SIGNED, 16, 32.0f, 1.0f );
Delta_AddField( dt, "wateralpha", DT_FLOAT|DT_SIGNED, 16, 32.0f, 1.0f );
Delta_AddField( dt, "fog_settings", DT_INTEGER, 32, 1.0f, 1.0f );
dt->numFields = NUM_FIELDS( pm_fields ) - 4;
// now done
dt->bInitialized = true;
}
void Delta_InitClient( void )
{
int i, numActive = 0;
// already initalized
if( delta_init ) return;
for( i = 0; i < NUM_FIELDS( dt_info ); i++ )
{
if( dt_info[i].numFields > 0 )
{
dt_info[i].bInitialized = true;
numActive++;
}
}
if( numActive ) delta_init = true;
}
void Delta_Shutdown( void )
{
int i;
if( !delta_init ) return;
for( i = 0; i < NUM_FIELDS( dt_info ); i++ )
{
dt_info[i].numFields = 0;
dt_info[i].customEncode = CUSTOM_NONE;
dt_info[i].userCallback = NULL;
dt_info[i].funcName[0] = '\0';
if( dt_info[i].pFields )
{
Z_Free( dt_info[i].pFields );
dt_info[i].pFields = NULL;
}
dt_info[i].bInitialized = false;
}
delta_init = false;
}
/*
=====================
Delta_ClampIntegerField
prevent data to out of range
=====================
*/
static int Delta_ClampIntegerField( delta_t *pField, int iValue, int signbit, int numbits )
{
#ifdef _DEBUG
if( numbits < 32 && abs( iValue ) >= (uint)BIT( numbits ))
Con_Reportf( S_WARN "Delta_ClampIntegerField: field %s = %d overflowed %d\n", pField->name, abs( iValue ), (uint)BIT( numbits ));
#endif
if( numbits < 32 )
{
int signbits = numbits - signbit;
int maxnum = BIT( signbits ) - 1;
if( iValue > maxnum )
iValue = maxnum;
else if( signbit && iValue < -maxnum - 1 )
iValue = -maxnum - 1;
}
return iValue; // clamped;
}
/*
=====================
Delta_CompareField
compare fields by offsets
assume from and to is valid
=====================
*/
static qboolean Delta_CompareField( delta_t *pField, void *from, void *to, double timebase )
{
int signbit = ( pField->flags & DT_SIGNED ) ? 1 : 0;
float val_a, val_b;
int fromF, toF;
Assert( pField != NULL );
Assert( from != NULL );
Assert( to != NULL );
if( pField->bInactive )
return true;
fromF = toF = 0;
if( pField->flags & DT_BYTE )
{
if( signbit )
{
fromF = *(int8_t *)((int8_t *)from + pField->offset );
toF = *(int8_t *)((int8_t *)to + pField->offset );
}
else
{
fromF = *(uint8_t *)((int8_t *)from + pField->offset );
toF = *(uint8_t *)((int8_t *)to + pField->offset );
}
if( !Q_equal(pField->multiplier, 1.0f ))
{
fromF *= pField->multiplier;
toF *= pField->multiplier;
}
fromF = Delta_ClampIntegerField( pField, fromF, signbit, pField->bits );
toF = Delta_ClampIntegerField( pField, toF, signbit, pField->bits );
}
else if( pField->flags & DT_SHORT )
{
if( signbit )
{
fromF = *(int16_t *)((int8_t *)from + pField->offset );
toF = *(int16_t *)((int8_t *)to + pField->offset );
}
else
{
fromF = *(uint16_t *)((int8_t *)from + pField->offset );
toF = *(uint16_t *)((int8_t *)to + pField->offset );
}
if( !Q_equal(pField->multiplier, 1.0f ))
{
fromF *= pField->multiplier;
toF *= pField->multiplier;
}
fromF = Delta_ClampIntegerField( pField, fromF, signbit, pField->bits );
toF = Delta_ClampIntegerField( pField, toF, signbit, pField->bits );
}
else if( pField->flags & DT_INTEGER )
{
if( signbit )
{
fromF = *(int32_t *)((int8_t *)from + pField->offset );
toF = *(int32_t *)((int8_t *)to + pField->offset );
}
else
{
fromF = *(uint32_t *)((int8_t *)from + pField->offset );
toF = *(uint32_t *)((int8_t *)to + pField->offset );
}
if( !Q_equal(pField->multiplier, 1.0f ))
{
fromF *= pField->multiplier;
toF *= pField->multiplier;
}
fromF = Delta_ClampIntegerField( pField, fromF, signbit, pField->bits );
toF = Delta_ClampIntegerField( pField, toF, signbit, pField->bits );
}
else if( pField->flags & ( DT_ANGLE|DT_FLOAT ))
{
// don't convert floats to integers
fromF = *((int *)((byte *)from + pField->offset ));
toF = *((int *)((byte *)to + pField->offset ));
}
else if( pField->flags & DT_TIMEWINDOW_8 )
{
val_a = *(float *)((byte *)from + pField->offset );
val_b = *(float *)((byte *)to + pField->offset );
fromF = Q_rint( val_a * 100.0 );
toF = Q_rint( val_b * 100.0 );
}
else if( pField->flags & DT_TIMEWINDOW_BIG )
{
val_a = *(float *)((byte *)from + pField->offset );
val_b = *(float *)((byte *)to + pField->offset );
fromF = Q_rint( val_a * pField->multiplier );
toF = Q_rint( val_b * pField->multiplier );
}
else if( pField->flags & DT_STRING )
{
// compare strings
char *s1 = (char *)((byte *)from + pField->offset );
char *s2 = (char *)((byte *)to + pField->offset );
// 0 is equal, otherwise not equal
toF = Q_strcmp( s1, s2 );
}
return fromF == toF;
}
/*
=====================
Delta_TestBaseline
compare baselines to find optimal
=====================
*/
int Delta_TestBaseline( entity_state_t *from, entity_state_t *to, qboolean player, double timebase )
{
delta_info_t *dt = NULL;
delta_t *pField;
int i, countBits;
countBits = MAX_ENTITY_BITS + 2;
if( to == NULL )
{
if( from == NULL ) return 0;
return countBits;
}
if( FBitSet( to->entityType, ENTITY_BEAM ))
dt = Delta_FindStructByIndex( DT_CUSTOM_ENTITY_STATE_T );
else if( player )
dt = Delta_FindStructByIndex( DT_ENTITY_STATE_PLAYER_T );
else dt = Delta_FindStructByIndex( DT_ENTITY_STATE_T );
Assert( dt && dt->bInitialized );
countBits++; // entityType flag
pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
// flag about field change (sets always)
countBits++;
if( !Delta_CompareField( pField, from, to, timebase ))
{
// strings are handled differently
if( FBitSet( pField->flags, DT_STRING ))
countBits += Q_strlen((char *)((byte *)to + pField->offset )) * 8;
else countBits += pField->bits;
}
}
// g-cont. compare bitcount directly no reason to call BitByte here
return countBits;
}
/*
=====================
Delta_WriteField
write fields by offsets
assume from and to is valid
=====================
*/
static qboolean Delta_WriteField( sizebuf_t *msg, delta_t *pField, void *from, void *to, double timebase )
{
int signbit = FBitSet( pField->flags, DT_SIGNED ) ? 1 : 0;
float flValue, flAngle;
uint iValue;
int dt;
const char *pStr;
if( Delta_CompareField( pField, from, to, timebase ))
{
MSG_WriteOneBit( msg, 0 ); // unchanged
return false;
}
MSG_WriteOneBit( msg, 1 ); // changed
if( pField->flags & DT_BYTE )
{
if( signbit )
iValue = *(int8_t *)((int8_t *)to + pField->offset );
else
iValue = *(uint8_t *)((int8_t *)to + pField->offset );
if( !Q_equal( pField->multiplier, 1.0 ))
iValue *= pField->multiplier;
iValue = Delta_ClampIntegerField( pField, iValue, signbit, pField->bits );
MSG_WriteBitLong( msg, iValue, pField->bits, signbit );
}
else if( pField->flags & DT_SHORT )
{
if( signbit )
iValue = *(int16_t *)((int8_t *)to + pField->offset );
else
iValue = *(uint16_t *)((int8_t *)to + pField->offset );
if( !Q_equal( pField->multiplier, 1.0 ))
iValue *= pField->multiplier;
iValue = Delta_ClampIntegerField( pField, iValue, signbit, pField->bits );
MSG_WriteBitLong( msg, iValue, pField->bits, signbit );
}
else if( pField->flags & DT_INTEGER )
{
if( signbit )
iValue = *(int32_t *)((int8_t *)to + pField->offset );
else
iValue = *(uint32_t *)((int8_t *)to + pField->offset );
if( !Q_equal( pField->multiplier, 1.0 ))
iValue *= pField->multiplier;
iValue = Delta_ClampIntegerField( pField, iValue, signbit, pField->bits );
MSG_WriteBitLong( msg, iValue, pField->bits, signbit );
}
else if( pField->flags & DT_FLOAT )
{
flValue = *(float *)((byte *)to + pField->offset );
iValue = (int)((double)flValue * pField->multiplier);
iValue = Delta_ClampIntegerField( pField, iValue, signbit, pField->bits );
MSG_WriteBitLong( msg, iValue, pField->bits, signbit );
}
else if( pField->flags & DT_ANGLE )
{
flAngle = *(float *)((byte *)to + pField->offset );
// NOTE: never applies multipliers to angle because
// result may be wrong on client-side
MSG_WriteBitAngle( msg, flAngle, pField->bits );
}
else if( pField->flags & DT_TIMEWINDOW_8 )
{
flValue = *(float *)((byte *)to + pField->offset );
dt = Q_rint(( timebase - flValue ) * 100.0 );
dt = Delta_ClampIntegerField( pField, dt, 1, pField->bits );
MSG_WriteSBitLong( msg, dt, pField->bits );
}
else if( pField->flags & DT_TIMEWINDOW_BIG )
{
flValue = *(float *)((byte *)to + pField->offset );
dt = Q_rint(( timebase - flValue ) * pField->multiplier );
dt = Delta_ClampIntegerField( pField, dt, 1, pField->bits );
MSG_WriteSBitLong( msg, dt, pField->bits );
}
else if( pField->flags & DT_STRING )
{
pStr = (char *)((byte *)to + pField->offset );
MSG_WriteString( msg, pStr );
}
return true;
}
/*
====================
Delta_CopyField
====================
*/
static void Delta_CopyField( delta_t *pField, void *from, void *to, double timebase )
{
qboolean bSigned = FBitSet( pField->flags, DT_SIGNED );
uint8_t *to_field = (uint8_t *)to + pField->offset;
uint8_t *from_field = (uint8_t *)from + pField->offset;
if( FBitSet( pField->flags, DT_BYTE ))
{
if( bSigned )
*(int8_t *)( to_field ) = *(int8_t *)( from_field );
else
*(uint8_t *)( to_field ) = *(uint8_t *)( from_field );
}
else if( FBitSet( pField->flags, DT_SHORT ))
{
if( bSigned )
*(int16_t *)( to_field ) = *(int16_t *)( from_field );
else
*(uint16_t *)( to_field ) = *(uint16_t *)( from_field );
}
else if( FBitSet( pField->flags, DT_INTEGER ))
{
if( bSigned )
*(int32_t *)( to_field ) = *(int32_t *)( from_field );
else
*(uint32_t *)( to_field ) = *(uint32_t *)( from_field );
}
else if( FBitSet( pField->flags, DT_FLOAT|DT_ANGLE|DT_TIMEWINDOW_8|DT_TIMEWINDOW_BIG ))
{
*(float *)( to_field ) = *(float *)( from_field );
}
else if( FBitSet( pField->flags, DT_STRING ))
{
Q_strncpy( to_field, from_field, pField->size );
}
else
{
Assert( 0 );
}
}
/*
=====================
Delta_ReadField
read fields by offsets
assume 'from' and 'to' is valid
=====================
*/
static qboolean Delta_ReadField( sizebuf_t *msg, delta_t *pField, void *from, void *to, double timebase )
{
qboolean bSigned = ( pField->flags & DT_SIGNED ) ? true : false;
float flValue, flAngle, flTime;
uint iValue;
const char *pStr;
char *pOut;
if( !MSG_ReadOneBit( msg ) )
{
Delta_CopyField( pField, from, to, timebase );
return false;
}
Assert( pField->multiplier != 0.0f );
if( pField->flags & DT_BYTE )
{
iValue = MSG_ReadBitLong( msg, pField->bits, bSigned );
if( !Q_equal( pField->multiplier, 1.0 ))
iValue /= pField->multiplier;
if( !Q_equal( pField->post_multiplier, 1.0 ))
iValue *= pField->post_multiplier;
if( bSigned )
*(int8_t *)((uint8_t *)to + pField->offset ) = iValue;
else
*(uint8_t *)((uint8_t *)to + pField->offset ) = iValue;
}
else if( pField->flags & DT_SHORT )
{
iValue = MSG_ReadBitLong( msg, pField->bits, bSigned );
if( !Q_equal( pField->multiplier, 1.0 ))
iValue /= pField->multiplier;
if( !Q_equal( pField->post_multiplier, 1.0 ))
iValue *= pField->post_multiplier;
if( bSigned )
*(int16_t *)((uint8_t *)to + pField->offset ) = iValue;
else
*(uint16_t *)((uint8_t *)to + pField->offset ) = iValue;
}
else if( pField->flags & DT_INTEGER )
{
iValue = MSG_ReadBitLong( msg, pField->bits, bSigned );
if( !Q_equal( pField->multiplier, 1.0 ))
iValue /= pField->multiplier;
if( !Q_equal( pField->post_multiplier, 1.0 ))
iValue *= pField->post_multiplier;
if( bSigned )
*(int32_t *)((uint8_t *)to + pField->offset ) = iValue;
else
*(uint32_t *)((uint8_t *)to + pField->offset ) = iValue;
}
else if( pField->flags & DT_FLOAT )
{
iValue = MSG_ReadBitLong( msg, pField->bits, bSigned );
if( bSigned )
flValue = (int)iValue;
else
flValue = iValue;
if( !Q_equal( pField->multiplier, 1.0 ))
flValue /= pField->multiplier;
if( !Q_equal( pField->post_multiplier, 1.0 ))
flValue *= pField->post_multiplier;
*(float *)((byte *)to + pField->offset ) = flValue;
}
else if( pField->flags & DT_ANGLE )
{
flAngle = MSG_ReadBitAngle( msg, pField->bits );
*(float *)((byte *)to + pField->offset ) = flAngle;
}
else if( pField->flags & DT_TIMEWINDOW_8 )
{
iValue = MSG_ReadSBitLong( msg, pField->bits );
flTime = ( timebase * 100.0 - (int)iValue ) / 100.0;
*(float *)((byte *)to + pField->offset ) = flTime;
}
else if( pField->flags & DT_TIMEWINDOW_BIG )
{
iValue = MSG_ReadSBitLong( msg, pField->bits );
flTime = ( timebase * pField->multiplier - (int)iValue ) / pField->multiplier;
*(float *)((byte *)to + pField->offset ) = flTime;
}
else if( pField->flags & DT_STRING )
{
pStr = MSG_ReadString( msg );
pOut = (char *)((byte *)to + pField->offset );
Q_strncpy( pOut, pStr, pField->size );
}
return true;
}
/*
=============================================================================
usercmd_t communication
=============================================================================
*/
/*
=====================
MSG_WriteDeltaUsercmd
=====================
*/
void MSG_WriteDeltaUsercmd( sizebuf_t *msg, usercmd_t *from, usercmd_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_USERCMD_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_WriteField( msg, pField, from, to, 0.0f );
}
}
/*
=====================
MSG_ReadDeltaUsercmd
=====================
*/
void MSG_ReadDeltaUsercmd( sizebuf_t *msg, usercmd_t *from, usercmd_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_USERCMD_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
*to = *from;
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, 0.0f );
}
COM_NormalizeAngles( to->viewangles );
}
/*
============================================================================
event_args_t communication
============================================================================
*/
/*
=====================
MSG_WriteDeltaEvent
=====================
*/
void MSG_WriteDeltaEvent( sizebuf_t *msg, event_args_t *from, event_args_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_EVENT_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_WriteField( msg, pField, from, to, 0.0f );
}
}
/*
=====================
MSG_ReadDeltaEvent
=====================
*/
void MSG_ReadDeltaEvent( sizebuf_t *msg, event_args_t *from, event_args_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_EVENT_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
*to = *from;
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, 0.0f );
}
}
/*
=============================================================================
movevars_t communication
=============================================================================
*/
qboolean MSG_WriteDeltaMovevars( sizebuf_t *msg, movevars_t *from, movevars_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i, startBit;
int numChanges = 0;
dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
startBit = msg->iCurBit;
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
MSG_BeginServerCmd( msg, svc_deltamovevars );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, 0.0f ))
numChanges++;
}
// if we have no changes - kill the message
if( !numChanges )
{
MSG_SeekToBit( msg, startBit, SEEK_SET );
return false;
}
return true;
}
void MSG_ReadDeltaMovevars( sizebuf_t *msg, movevars_t *from, movevars_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
*to = *from;
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, 0.0f );
}
}
/*
=============================================================================
clientdata_t communication
=============================================================================
*/
/*
==================
MSG_WriteClientData
Writes current client data only for local client
Other clients can grab the client state from entity_state_t
==================
*/
void MSG_WriteClientData( sizebuf_t *msg, clientdata_t *from, clientdata_t *to, double timebase )
{
delta_t *pField;
delta_info_t *dt;
int i, startBit;
int numChanges = 0;
dt = Delta_FindStructByIndex( DT_CLIENTDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
startBit = msg->iCurBit;
MSG_WriteOneBit( msg, 1 ); // have clientdata
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, timebase ))
numChanges++;
}
if( numChanges ) return; // we have updates
MSG_SeekToBit( msg, startBit, SEEK_SET );
MSG_WriteOneBit( msg, 0 ); // no changes
}
/*
==================
MSG_ReadClientData
Read the clientdata
==================
*/
void MSG_ReadClientData( sizebuf_t *msg, clientdata_t *from, clientdata_t *to, double timebase )
{
#if !XASH_DEDICATED
delta_t *pField;
delta_info_t *dt;
int i;
qboolean noChanges;
dt = Delta_FindStructByIndex( DT_CLIENTDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
noChanges = !cls.legacymode && !MSG_ReadOneBit( msg );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
if( noChanges )
Delta_CopyField( pField, from, to, timebase );
else Delta_ReadField( msg, pField, from, to, timebase );
}
#endif
}
/*
=============================================================================
weapon_data_t communication
=============================================================================
*/
/*
==================
MSG_WriteWeaponData
Writes current client data only for local client
Other clients can grab the client state from entity_state_t
==================
*/
void MSG_WriteWeaponData( sizebuf_t *msg, weapon_data_t *from, weapon_data_t *to, double timebase, int index )
{
delta_t *pField;
delta_info_t *dt;
int i, startBit;
int numChanges = 0;
dt = Delta_FindStructByIndex( DT_WEAPONDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
startBit = msg->iCurBit;
MSG_WriteOneBit( msg, 1 );
MSG_WriteUBitLong( msg, index, MAX_WEAPON_BITS );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, timebase ))
numChanges++;
}
// if we have no changes - kill the message
if( !numChanges ) MSG_SeekToBit( msg, startBit, SEEK_SET );
}
/*
==================
MSG_ReadWeaponData
Read the clientdata
==================
*/
void MSG_ReadWeaponData( sizebuf_t *msg, weapon_data_t *from, weapon_data_t *to, double timebase )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_WEAPONDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, timebase );
}
}
/*
=============================================================================
entity_state_t communication
=============================================================================
*/
/*
==================
MSG_WriteDeltaEntity
Writes part of a packetentities message, including the entity number.
Can delta from either a baseline or a previous packet_entity
If to is NULL, a remove entity update will be sent
If force is not set, then nothing at all will be generated if the entity is
identical, under the assumption that the in-order delta code will catch it.
==================
*/
void MSG_WriteDeltaEntity( entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qboolean force, int delta_type, double timebase, int baseline )
{
delta_info_t *dt = NULL;
delta_t *pField;
int i, startBit;
int numChanges = 0;
if( to == NULL )
{
int fRemoveType;
if( from == NULL ) return;
// a NULL to is a delta remove message
MSG_WriteUBitLong( msg, from->number, MAX_ENTITY_BITS );
// fRemoveType:
// 0 - keep alive, has delta-update
// 1 - remove from delta message (but keep states)
// 2 - completely remove from server
if( force ) fRemoveType = 2;
else fRemoveType = 1;
MSG_WriteUBitLong( msg, fRemoveType, 2 );
return;
}
startBit = msg->iCurBit;
if( to->number < 0 || to->number >= GI->max_edicts )
Host_Error( "MSG_WriteDeltaEntity: Bad entity number: %i\n", to->number );
MSG_WriteUBitLong( msg, to->number, MAX_ENTITY_BITS );
MSG_WriteUBitLong( msg, 0, 2 ); // alive
if( baseline != 0 )
{
MSG_WriteOneBit( msg, 1 );
MSG_WriteSBitLong( msg, baseline, 7 );
}
else MSG_WriteOneBit( msg, 0 );
if( force || ( to->entityType != from->entityType ))
{
MSG_WriteOneBit( msg, 1 );
MSG_WriteUBitLong( msg, to->entityType, 2 );
numChanges++;
}
else MSG_WriteOneBit( msg, 0 );
if( FBitSet( to->entityType, ENTITY_BEAM ))
{
dt = Delta_FindStructByIndex( DT_CUSTOM_ENTITY_STATE_T );
}
else if( delta_type == DELTA_PLAYER )
{
dt = Delta_FindStructByIndex( DT_ENTITY_STATE_PLAYER_T );
}
else
{
dt = Delta_FindStructByIndex( DT_ENTITY_STATE_T );
}
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
if( delta_type == DELTA_STATIC )
{
// static entities won't to be custom encoded
for( i = 0; i < dt->numFields; i++ )
dt->pFields[i].bInactive = false;
}
else
{
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
}
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, timebase ))
numChanges++;
}
// if we have no changes - kill the message
if( !numChanges && !force ) MSG_SeekToBit( msg, startBit, SEEK_SET );
}
/*
==================
MSG_ReadDeltaEntity
The entity number has already been read from the message, which
is how the from state is identified.
If the delta removes the entity, entity_state_t->number will be set to MAX_EDICTS
Can go from either a baseline or a previous packet_entity
==================
*/
qboolean MSG_ReadDeltaEntity( sizebuf_t *msg, entity_state_t *from, entity_state_t *to, int number, int delta_type, double timebase )
{
#if !XASH_DEDICATED
delta_info_t *dt = NULL;
delta_t *pField;
int i, fRemoveType;
int baseline_offset = 0;
if( number < 0 || number >= clgame.maxEntities )
Host_Error( "MSG_ReadDeltaEntity: bad delta entity number: %i\n", number );
fRemoveType = MSG_ReadUBitLong( msg, 2 );
if( fRemoveType )
{
// check for a remove
memset( to, 0, sizeof( *to ));
if( fRemoveType & 1 )
{
// removed from delta-message
return false;
}
if( fRemoveType & 2 )
{
// entity was removed from server
to->number = -1;
return false;
}
Host_Error( "MSG_ReadDeltaEntity: unknown update type %i\n", fRemoveType );
}
if( !cls.legacymode )
{
if( MSG_ReadOneBit( msg ))
baseline_offset = MSG_ReadSBitLong( msg, 7 );
if( baseline_offset != 0 )
{
if( delta_type == DELTA_STATIC )
{
int backup = Q_max( 0, clgame.numStatics - abs( baseline_offset ));
from = &clgame.static_entities[backup].baseline;
}
else if( baseline_offset > 0 )
{
int backup = cls.next_client_entities - baseline_offset;
from = &cls.packet_entities[backup % cls.num_client_entities];
}
else
{
baseline_offset = abs( baseline_offset + 1 );
if( baseline_offset < cl.instanced_baseline_count )
from = &cl.instanced_baseline[baseline_offset];
}
}
}
// g-cont. probably is redundant
*to = *from;
if( MSG_ReadOneBit( msg ))
to->entityType = MSG_ReadUBitLong( msg, 2 );
to->number = number;
if( cls.legacymode ? ( to->entityType == ENTITY_BEAM ) : FBitSet( to->entityType, ENTITY_BEAM ))
{
dt = Delta_FindStructByIndex( DT_CUSTOM_ENTITY_STATE_T );
}
else if( delta_type == DELTA_PLAYER )
{
dt = Delta_FindStructByIndex( DT_ENTITY_STATE_PLAYER_T );
}
else
{
dt = Delta_FindStructByIndex( DT_ENTITY_STATE_T );
}
Assert( dt && dt->bInitialized );
pField = dt->pFields;
Assert( pField != NULL );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, timebase );
}
#endif // XASH_DEDICATED
// message parsed
return true;
}
/*
==================
Delta_WriteDescriptionToClient
send delta communication encoding
==================
*/
void Delta_WriteDescriptionToClient( sizebuf_t *msg )
{
int tableIndex;
int fieldIndex;
for( tableIndex = 0; tableIndex < Delta_NumTables(); tableIndex++ )
{
delta_info_t *dt = Delta_FindStructByIndex( tableIndex );
for( fieldIndex = 0; fieldIndex < dt->numFields; fieldIndex++ )
Delta_WriteTableField( msg, tableIndex, &dt->pFields[fieldIndex] );
}
}
/*
=============================================================================
game.dll interface
=============================================================================
*/
void GAME_EXPORT Delta_AddEncoder( char *name, pfnDeltaEncode encodeFunc )
{
delta_info_t *dt;
dt = Delta_FindStructByEncoder( name );
if( !dt || !dt->bInitialized )
{
Con_DPrintf( S_ERROR "Delta_AddEncoder: couldn't find delta with specified custom encode %s\n", name );
return;
}
if( dt->customEncode == CUSTOM_NONE )
{
Con_DPrintf( S_ERROR "Delta_AddEncoder: %s not supposed for custom encoding\n", dt->pName );
return;
}
// register new encode func
dt->userCallback = encodeFunc;
}
int GAME_EXPORT Delta_FindField( delta_t *pFields, const char *fieldname )
{
delta_info_t *dt;
delta_t *pField;
int i;
dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || !fieldname || !fieldname[0] )
return -1;
for( i = 0, pField = dt->pFields; i < dt->numFields; i++, pField++ )
{
if( !Q_strcmp( pField->name, fieldname ))
return i;
}
return -1;
}
void GAME_EXPORT Delta_SetField( delta_t *pFields, const char *fieldname )
{
delta_info_t *dt;
delta_t *pField;
int i;
dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || !fieldname || !fieldname[0] )
return;
for( i = 0, pField = dt->pFields; i < dt->numFields; i++, pField++ )
{
if( !Q_strcmp( pField->name, fieldname ))
{
pField->bInactive = false;
return;
}
}
}
void GAME_EXPORT Delta_UnsetField( delta_t *pFields, const char *fieldname )
{
delta_info_t *dt;
delta_t *pField;
int i;
dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || !fieldname || !fieldname[0] )
return;
for( i = 0, pField = dt->pFields; i < dt->numFields; i++, pField++ )
{
if( !Q_strcmp( pField->name, fieldname ))
{
pField->bInactive = true;
return;
}
}
}
void GAME_EXPORT Delta_SetFieldByIndex( delta_t *pFields, int fieldNumber )
{
delta_info_t *dt;
dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || fieldNumber < 0 || fieldNumber >= dt->numFields )
return;
dt->pFields[fieldNumber].bInactive = false;
}
void GAME_EXPORT Delta_UnsetFieldByIndex( delta_t *pFields, int fieldNumber )
{
delta_info_t *dt;
dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || fieldNumber < 0 || fieldNumber >= dt->numFields )
return;
dt->pFields[fieldNumber].bInactive = true;
}
#if XASH_ENGINE_TESTS
#include "tests.h"
void Test_RunDelta( void )
{
delta_info_t *dt = &dt_info[DT_DELTA_TEST_STRUCT_T];
delta_test_struct_t from, to = { 0 };
delta_test_struct_t null = { 0 };
sizebuf_t msg;
int i;
char buffer[4096] = { 0 };
const double timebase = 123.123;
// a1ba: netbuffer bitmasks are initialized in netchan for some reason
// initialize it ourselves just in case
MSG_InitMasks(); // initialize bit-masks
Delta_AddField( dt, "dt_string", DT_STRING, 1, 1.0f, 1.0f );
Delta_AddField( dt, "dt_timewindow_big", DT_TIMEWINDOW_BIG, 24, 1000.f, 1.0f );
Delta_AddField( dt, "dt_timewindow_8", DT_TIMEWINDOW_8, 8, 1.0f, 1.0f );
Delta_AddField( dt, "dt_angle", DT_ANGLE, 16, 1.0f, 1.0f );
Delta_AddField( dt, "dt_float_signed", DT_FLOAT | DT_SIGNED, 22, 100.0f, 1.0f );
Delta_AddField( dt, "dt_float_unsigned", DT_FLOAT, 24, 10000.0f, 0.1f );
Delta_AddField( dt, "dt_integer_signed", DT_INTEGER | DT_SIGNED, 24, 1.0f, 1.0f );
Delta_AddField( dt, "dt_integer_unsigned", DT_INTEGER, 24, 1.0f, 1.0f );
Delta_AddField( dt, "dt_short_signed", DT_SHORT | DT_SIGNED, 16, 1.0f, 1.0f );
Delta_AddField( dt, "dt_short_unsigned", DT_SHORT, 15, 0.125f, 1.0f );
Delta_AddField( dt, "dt_byte_signed", DT_BYTE | DT_SIGNED, 6, 1.0f, 1.0f );
Delta_AddField( dt, "dt_byte_unsigned", DT_BYTE, 8, 1.0f, 1.0f );
Q_strncpy( from.dt_string, "test data check it's the same", sizeof( from.dt_string ));
from.dt_timewindow_big = timebase + 2.3456;
from.dt_timewindow_8 = timebase + 0.0234;
from.dt_angle = 160.245f;
from.dt_float_signed = -15.123f;
from.dt_float_unsigned = 1235.321f;
from.dt_integer_signed = -412784;
from.dt_integer_unsigned = 123453;
from.dt_short_signed = -12343;
from.dt_short_unsigned = 32131;
from.dt_byte_signed = 16;
from.dt_byte_unsigned = 218;
MSG_Init( &msg, "test message", buffer, sizeof( buffer ));
for( i = 0; i < dt->numFields; i++ )
Delta_WriteField( &msg, &dt->pFields[i], &null, &from, timebase );
MSG_SeekToBit( &msg, 0, SEEK_SET );
for( i = 0; i < dt->numFields; i++ )
Delta_ReadField( &msg, &dt->pFields[i], &null, &to, timebase );
Con_Printf( "struct as encoded to delta:\n" );
TASSERT_STR( from.dt_string, to.dt_string );
// the epsilon value is derived from multiplier value
TASSERT( Q_equal_e( from.dt_timewindow_big, to.dt_timewindow_big, 0.001f ));
// dt_timewindow_8 type has multiplier locked at 100.0f
TASSERT( Q_equal_e( from.dt_timewindow_8, to.dt_timewindow_8, 0.01f ));
TASSERT( Q_equal_e( from.dt_angle, to.dt_angle, 0.1f ));
TASSERT( Q_equal_e( from.dt_float_signed, to.dt_float_signed, 0.01f ));
// dt_float_unsigned has post-multiplier that doesn't affect network data
// and therefore should be reverted back when comparing
TASSERT( Q_equal_e( from.dt_float_unsigned, to.dt_float_unsigned * 10.f , 0.01f ));
TASSERT_EQi( from.dt_integer_signed, to.dt_integer_signed );
TASSERT_EQi( from.dt_integer_unsigned, to.dt_integer_unsigned );
TASSERT_EQi( from.dt_short_signed, to.dt_short_signed );
TASSERT(( from.dt_short_unsigned & ( 0xffff << 3 )) == to.dt_short_unsigned );
TASSERT_EQi( from.dt_byte_signed, to.dt_byte_signed );
TASSERT_EQi( from.dt_byte_unsigned, to.dt_byte_unsigned );
Con_Printf( "from.dt_timewindow_big = %f\n", from.dt_timewindow_big );
Con_Printf( "to.dt_timewindow_big = %f\n", to.dt_timewindow_big );
Con_Printf( "from.dt_timewindow_8 = %f\n", from.dt_timewindow_8 );
Con_Printf( "to.dt_timewindow_8 = %f\n", to.dt_timewindow_8 );
Con_Printf( "from.dt_angle = %f\n", from.dt_angle );
Con_Printf( "to.dt_angle = %f\n", to.dt_angle );
Con_Printf( "from.dt_float_signed = %f\n", from.dt_float_signed );
Con_Printf( "to.dt_float_signed = %f\n", to.dt_float_signed );
Con_Printf( "from.dt_float_unsigned = %f\n", from.dt_float_unsigned );
Con_Printf( "to.dt_float_unsigned = %f\n", to.dt_float_unsigned );
Con_Printf( "from.dt_integer_signed = %i\n", from.dt_integer_signed );
Con_Printf( "to.dt_integer_signed = %i\n", to.dt_integer_signed );
Con_Printf( "from.dt_integer_unsigned = %i\n", from.dt_integer_unsigned );
Con_Printf( "to.dt_integer_unsigned = %i\n", to.dt_integer_unsigned );
Con_Printf( "from.dt_short_signed = %i\n", from.dt_short_signed );
Con_Printf( "to.dt_short_signed = %i\n", to.dt_short_signed );
Con_Printf( "from.dt_short_unsigned = %i\n", from.dt_short_unsigned );
Con_Printf( "to.dt_short_unsigned = %i\n", to.dt_short_unsigned );
Con_Printf( "from.dt_byte_signed = %i\n", from.dt_byte_signed );
Con_Printf( "to.dt_byte_signed = %i\n", to.dt_byte_signed );
Con_Printf( "from.dt_byte_unsigned = %i\n", from.dt_byte_unsigned );
Con_Printf( "to.dt_byte_unsigned = %i\n", to.dt_byte_unsigned );
}
#endif // XASH_ENGINE_TESTS
Reference in New Issue View Git Blame Copy Permalink