/*
==================
CL_DeltaEntity
Parses deltas from the given base and adds the resulting entity
to the current frame
==================
*/
void CL_DeltaEntity( msg_t *msg, clSnapshot_t *frame, int newnum, entityState_t *old, qboolean unchanged )
{
entityState_t *state;
// save the parsed entity state into the big circular buffer so
// it can be used as the source for a later delta
state = &cl.parseEntities[ cl.parseEntitiesNum & ( MAX_PARSE_ENTITIES - 1 ) ];
if ( unchanged )
{
*state = *old;
}
else
{
MSG_ReadDeltaEntity( msg, old, state, newnum );
}
if ( state->number == ( MAX_GENTITIES - 1 ) )
{
return; // entity was delta removed
}
cl.parseEntitiesNum++;
frame->numEntities++;
}
/*
==================
CL_ParseBaseline
==================
*/
void CL_ParseBaseline( sizebuf_t *msg )
{
int newnum;
float timebase;
cl_entity_t *ent;
Delta_InitClient (); // finalize client delta's
newnum = BF_ReadWord( msg );
if( newnum < 0 ) Host_Error( "CL_SpawnEdict: invalid number %i\n", newnum );
if( newnum >= clgame.maxEntities ) Host_Error( "CL_AllocEdict: no free edicts\n" );
ent = CL_EDICT_NUM( newnum );
if( !ent )
Host_Error( "CL_ParseBaseline: got invalid entity");
Q_memset( &ent->prevstate, 0, sizeof( ent->prevstate ));
ent->index = newnum;
if( cls.state == ca_active )
timebase = cl.mtime[0];
else timebase = 1.0f; // sv.state == ss_loading
MSG_ReadDeltaEntity( msg, &ent->prevstate, &ent->baseline, newnum, CL_IsPlayerIndex( newnum ), timebase );
}
// TODO(kangz) if we can make sure that the baseline entities have the correct entity
// number, then we could grab the entity number from old directly, simplifying code a bit.
void CL_DeltaEntity( msg_t *msg, clSnapshot_t *snapshot, int entityNum, const entityState_t &oldEntity)
{
entityState_t entity;
MSG_ReadDeltaEntity(msg, &oldEntity, &entity, entityNum);
if (entity.number != MAX_GENTITIES - 1) {
snapshot->entities.push_back(entity);
}
}
qboolean demoCutParseGamestate(msg_t *msg, clientConnection_t *clcCut, clientActive_t *clCut) {
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
clcCut->connectPacketCount = 0;
Com_Memset(clCut, 0, sizeof(*clCut));
clcCut->serverCommandSequence = MSG_ReadLong(msg);
clCut->gameState.dataCount = 1;
while (1) {
cmd = MSG_ReadByte(msg);
if (cmd == svc_EOF) {
break;
}
if (cmd == svc_configstring) {
int len, start;
start = msg->readcount;
i = MSG_ReadShort(msg);
if (i < 0 || i >= MAX_CONFIGSTRINGS) {
Com_Printf("configstring > MAX_CONFIGSTRINGS");
return qfalse;
}
s = MSG_ReadBigString(msg);
len = strlen(s);
if (len + 1 + clCut->gameState.dataCount > MAX_GAMESTATE_CHARS) {
Com_Printf("MAX_GAMESTATE_CHARS exceeded");
return qfalse;
}
// append it to the gameState string buffer
clCut->gameState.stringOffsets[i] = clCut->gameState.dataCount;
Com_Memcpy(clCut->gameState.stringData + clCut->gameState.dataCount, s, len + 1);
clCut->gameState.dataCount += len + 1;
} else if (cmd == svc_baseline) {
newnum = MSG_ReadBits(msg, GENTITYNUM_BITS);
if (newnum < 0 || newnum >= MAX_GENTITIES) {
Com_Printf("Baseline number out of range: %i", newnum);
return qfalse;
}
Com_Memset(&nullstate, 0, sizeof(nullstate));
es = &clCut->entityBaselines[newnum];
MSG_ReadDeltaEntity(msg, &nullstate, es, newnum);
} else {
Com_Printf("demoCutParseGameState: bad command byte");
return qfalse;
}
}
clcCut->clientNum = MSG_ReadLong(msg);
clcCut->checksumFeed = MSG_ReadLong(msg);
// RMG stuff
demoCutParseRMG(msg, clcCut, clCut);
return qtrue;
}
void demoCutParsePacketEntities(msg_t *msg, clSnapshot_t *oldSnap, clSnapshot_t *newSnap, clientActive_t *clCut) {
/* The beast that is entity parsing */
int newnum;
entityState_t *oldstate, *newstate;
int oldindex = 0;
int oldnum;
newSnap->parseEntitiesNum = clCut->parseEntitiesNum;
newSnap->numEntities = 0;
newnum = MSG_ReadBits(msg, GENTITYNUM_BITS);
while (1) {
// read the entity index number
if (oldSnap && oldindex < oldSnap->numEntities) {
oldstate = &clCut->parseEntities[(oldSnap->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
oldnum = oldstate->number;
} else {
oldstate = 0;
oldnum = 99999;
}
newstate = &clCut->parseEntities[clCut->parseEntitiesNum];
if (!oldstate && (newnum == (MAX_GENTITIES-1))) {
break;
} else if (oldnum < newnum) {
*newstate = *oldstate;
oldindex++;
} else if (oldnum == newnum) {
oldindex++;
MSG_ReadDeltaEntity(msg, oldstate, newstate, newnum);
newnum = MSG_ReadBits(msg, GENTITYNUM_BITS);
} else if (oldnum > newnum) {
MSG_ReadDeltaEntity(msg, &clCut->entityBaselines[newnum], newstate, newnum);
newnum = MSG_ReadBits(msg, GENTITYNUM_BITS);
}
if (newstate->number == MAX_GENTITIES-1)
continue;
clCut->parseEntitiesNum++;
clCut->parseEntitiesNum &= (MAX_PARSE_ENTITIES-1);
newSnap->numEntities++;
}
}
/*
==================
CL_DeltaEntity
Parses deltas from the given base and adds the resulting entity
to the current frame
==================
*/
void CL_DeltaEntity(msg_t *msg, clSnapshot_t *frame, int newnum, entityState_t *old,
qboolean unchanged)
{
entityState_t *state;
// save the parsed entity state into the big circular buffer so
// it can be used as the source for a later delta
state = &cl.parseEntities[cl.parseEntitiesNum & (MAX_PARSE_ENTITIES - 1)];
if (unchanged)
{
*state = *old;
}
else
{
MSG_ReadDeltaEntity(msg, old, state, newnum);
}
if (state->number == (MAX_GENTITIES - 1))
{
return; // entity was delta removed
}
#if 1
// DHM - Nerve :: Only draw clients if visible
if (clc.onlyVisibleClients)
{
if (state->number < MAX_CLIENTS)
{
if (isEntVisible(state))
{
entLastVisible[state->number] = frame->serverTime;
state->eFlags &= ~EF_NODRAW;
}
else
{
if (entLastVisible[state->number] < (frame->serverTime - 600))
{
state->eFlags |= EF_NODRAW;
}
}
}
}
#endif
cl.parseEntitiesNum++;
frame->numEntities++;
}
/*
==================
CL_ParseBaseline
==================
*/
void CL_ParseBaseline( msg_t *msg ) {
sharedEntityState_t *es;
int newnum;
if ( !cgvm ) {
Com_Error( ERR_DROP, "Received unexpected baseline" );
}
if ( !cl.entityBaselines.pointer ) {
Com_Error( ERR_DROP, "cgame needs to call trap_SetNetFields" );
}
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
es = DA_ElementPointer( cl.entityBaselines, newnum );
MSG_ReadDeltaEntity( msg, NULL, es, newnum );
}
/*
==================
CL_DeltaEntity
Parses deltas from the given base and adds the resulting entity
to the current frame
==================
*/
void CL_DeltaEntity (msg_t *msg, clSnapshot_t *frame, int newnum, sharedEntityState_t *old,
qboolean unchanged) {
sharedEntityState_t *state;
// save the parsed entity state into the big circular buffer so
// it can be used as the source for a later delta
state = CL_ParseEntityState( cl.parseEntitiesNum );
if ( unchanged ) {
Com_Memcpy( state, old, cl.cgameEntityStateSize );
} else {
MSG_ReadDeltaEntity( msg, old, state, newnum );
}
if ( state->number == (MAX_GENTITIES-1) ) {
return; // entity was delta removed
}
cl.parseEntitiesNum++;
frame->numEntities++;
}
/*
=================
CL_FlushEntityPacket
=================
*/
void CL_FlushEntityPacket( sizebuf_t *msg )
{
int newnum;
entity_state_t from, to;
MsgDev( D_INFO, "FlushEntityPacket()\n" );
Q_memset( &from, 0, sizeof( from ));
cl.frames[cl.parsecountmod].valid = false;
cl.validsequence = 0; // can't render a frame
// read it all, but ignore it
while( 1 )
{
newnum = BF_ReadWord( msg );
if( !newnum ) break; // done
if( BF_CheckOverflow( msg ))
Host_Error( "CL_FlushEntityPacket: read overflow\n" );
MSG_ReadDeltaEntity( msg, &from, &to, newnum, CL_IsPlayerIndex( newnum ), cl.mtime[0] );
}
}
void CL_DeltaEntity( sizebuf_t *msg, frame_t *frame, int newnum, entity_state_t *old, qboolean unchanged )
{
cl_entity_t *ent;
entity_state_t *state;
qboolean newent = (old) ? false : true;
qboolean result = true;
ent = CL_EDICT_NUM( newnum );
state = &cls.packet_entities[cls.next_client_entities % cls.num_client_entities];
ent->index = newnum;
if( newent ) old = &ent->baseline;
if( unchanged ) *state = *old;
else result = MSG_ReadDeltaEntity( msg, old, state, newnum, CL_IsPlayerIndex( newnum ), cl.mtime[0] );
if( !result )
{
if( newent ) Host_Error( "Cl_DeltaEntity: tried to release new entity\n" );
CL_KillDeadBeams( ent ); // release dead beams
#if 0
// this is for reference
if( state->number == -1 )
Msg( "Entity %i was removed from server\n", newnum );
else Msg( "Entity %i was removed from delta-message\n", newnum );
#endif
if( state->number == -1 )
{
ent->curstate.messagenum = 0;
ent->baseline.number = 0;
}
// entity was delta removed
return;
}
// entity is present in newframe
state->messagenum = cl.parsecount;
state->msg_time = cl.mtime[0];
cls.next_client_entities++;
frame->num_entities++;
// set player state
ent->player = CL_IsPlayerIndex( ent->index );
if( state->effects & EF_NOINTERP || newent )
{
// duplicate the current state so lerping doesn't hurt anything
ent->prevstate = *state;
}
else
{
// shuffle the last state to previous
ent->prevstate = ent->curstate;
}
// NOTE: always check modelindex for new state not current
if( Mod_GetType( state->modelindex ) == mod_studio )
{
CL_UpdateStudioVars( ent, state, newent );
}
else if( Mod_GetType( state->modelindex ) == mod_brush )
{
CL_UpdateBmodelVars( ent, state, newent );
}
// set right current state
ent->curstate = *state;
CL_UpdatePositions( ent );
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg ) {
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
#ifdef _DONETPROFILE_
int startBytes,endBytes;
startBytes=msg->readcount;
#endif
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 ) {
cmd = MSG_ReadByte( msg );
if ( cmd == svc_EOF ) {
break;
}
if ( cmd == svc_configstring ) {
int len, start;
start = msg->readcount;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadBigString( msg );
if (cl_shownet->integer >= 2)
{
Com_Printf("%3i: %d: %s\n", start, i, s);
}
/*
if (i == CS_SERVERINFO)
{ //get the special value here
char *f = strstr(s, "g_debugMelee");
if (f)
{
while (*f && *f != '\\')
{ //find the \ after it
f++;
}
if (*f == '\\')
{ //got it
int i = 0;
f++;
while (*f && *f != '\\' && i < 128)
{
hiddenCvarVal[i] = *f;
i++;
f++;
}
hiddenCvarVal[i] = 0;
//resume here
s = f;
}
}
}
*/
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
} else if ( cmd == svc_baseline ) {
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
Com_Memset (&nullstate, 0, sizeof(nullstate));
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
} else {
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
clc.clientNum = MSG_ReadLong(msg);
// read the checksum feed
clc.checksumFeed = MSG_ReadLong( msg );
CL_ParseRMG ( msg ); //rwwRMG - get info for it from the server
#ifdef _DONETPROFILE_
endBytes=msg->readcount;
// ClReadProf().AddField("svc_gamestate",endBytes-startBytes);
#endif
// parse serverId and other cvars
CL_SystemInfoChanged();
// reinitialize the filesystem if the game directory has changed
if( FS_ConditionalRestart( clc.checksumFeed ) ) {
// don't set to true because we yet have to start downloading
// enabling this can cause double loading of a map when connecting to
// a server which has a different game directory set
//clc.downloadRestart = qtrue;
}
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
// cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
static void demoFrameUnpack( msg_t *msg, demoFrame_t *oldFrame, demoFrame_t *newFrame ) {
int last;
qboolean isDelta = MSG_ReadBits( msg, 1 ) ? qfalse : qtrue;
if (!isDelta)
oldFrame = 0;
newFrame->serverTime = MSG_ReadLong( msg );
/* Read config strings */
newFrame->string.data[0] = 0;
newFrame->string.used = 1;
last = 0;
/* Extract config strings */
while ( 1 ) {
int i, num = MSG_ReadShort( msg );
if (!isDelta ) {
for (i = last;i<num;i++)
newFrame->string.offsets[i] = 0;
} else {
for (i = last;i<num;i++)
demoFrameAddString( &newFrame->string, i, oldFrame->string.data + oldFrame->string.offsets[i] );
}
if (num < MAX_CONFIGSTRINGS) {
demoFrameAddString( &newFrame->string, num, MSG_ReadBigString( msg ) );
} else {
break;
}
last = num + 1;
}
/* Extract player states */
Com_Memset( newFrame->clientData, 0, sizeof( newFrame->clientData ));
last = MSG_ReadByte( msg );
while (last < MAX_CLIENTS) {
playerState_t *oldPlayer, *newPlayer;
newFrame->clientData[last] = 1;
oldPlayer = isDelta && oldFrame->clientData[last] ? &oldFrame->clients[last] : &demoNullPlayerState;
newPlayer = &newFrame->clients[last];
MSG_ReadDeltaPlayerstate( msg, oldPlayer, newPlayer );
last = MSG_ReadByte( msg );
}
/* Extract entity states */
last = 0;
while ( 1 ) {
int i, num = MSG_ReadBits( msg, GENTITYNUM_BITS );
entityState_t *oldEntity, *newEntity;
if ( isDelta ) {
for (i = last;i<num;i++)
if (oldFrame->entities[i].number == i)
newFrame->entities[i] = oldFrame->entities[i];
else
newFrame->entities[i].number = MAX_GENTITIES - 1;
} else {
for (i = last;i<num;i++)
newFrame->entities[i].number = MAX_GENTITIES - 1;
}
if (num < MAX_GENTITIES - 1) {
if (isDelta) {
oldEntity = &oldFrame->entities[num];
if (oldEntity->number != num)
oldEntity = &demoNullEntityState;
} else {
oldEntity = &demoNullEntityState;
}
newEntity = &newFrame->entities[i];
MSG_ReadDeltaEntity( msg, oldEntity, newEntity, num );
} else
break;
last = num + 1;
}
/* Read the area mask */
newFrame->areaUsed = MSG_ReadByte( msg );
MSG_ReadData( msg, newFrame->areamask, newFrame->areaUsed );
/* Read the command string data */
newFrame->commandUsed = MSG_ReadLong( msg );
MSG_ReadData( msg, newFrame->commandData, newFrame->commandUsed );
}
void demoConvert( const char *oldName, const char *newBaseName, qboolean smoothen ) {
fileHandle_t oldHandle = 0;
fileHandle_t newHandle = 0;
int temp;
int oldSize;
int msgSequence;
msg_t oldMsg;
byte oldData[ MAX_MSGLEN ];
int oldTime, nextTime, fullTime;
int clientNum;
demoFrame_t *workFrame;
int parseEntitiesNum = 0;
demoConvert_t *convert;
char bigConfigString[BIG_INFO_STRING];
int bigConfigNumber;
const char *s;
clSnapshot_t *oldSnap = 0;
clSnapshot_t *newSnap;
int levelCount = 0;
char newName[MAX_OSPATH];
oldSize = FS_FOpenFileRead( oldName, &oldHandle, qtrue );
if (!oldHandle) {
Com_Printf("Failed to open %s for conversion.", oldName);
return;
}
/* Alloc some memory */
convert = Z_Malloc( sizeof( demoConvert_t) );
/* Initialize the first workframe's strings */
while (oldSize > 0) {
MSG_Init( &oldMsg, oldData, sizeof( oldData ) );
/* Read the sequence number */
if (FS_Read( &convert->messageNum, 4, oldHandle) != 4)
goto conversionerror;
convert->messageNum = LittleLong( convert->messageNum );
oldSize -= 4;
/* Read the message size */
if (FS_Read( &oldMsg.cursize,4, oldHandle) != 4)
goto conversionerror;
oldSize -= 4;
oldMsg.cursize = LittleLong( oldMsg.cursize );
/* Negative size signals end of demo */
if (oldMsg.cursize < 0)
break;
if ( oldMsg.cursize > oldMsg.maxsize )
goto conversionerror;
/* Read the actual message */
if (FS_Read( oldMsg.data, oldMsg.cursize, oldHandle ) != oldMsg.cursize)
goto conversionerror;
oldSize -= oldMsg.cursize;
// init the bitstream
MSG_BeginReading( &oldMsg );
// Skip the reliable sequence acknowledge number
MSG_ReadLong( &oldMsg );
//
// parse the message
//
while ( 1 ) {
byte cmd;
if ( oldMsg.readcount > oldMsg.cursize ) {
Com_Printf ("Demo conversion, read past end of server message.\n");
goto conversionerror;
}
cmd = MSG_ReadByte( &oldMsg );
if ( cmd == svc_EOF) {
break;
}
workFrame = &convert->frames[ convert->frameIndex % DEMOCONVERTFRAMES ];
// other commands
switch ( cmd ) {
default:
Com_Error (ERR_DROP,"CL_ParseServerMessage: Illegible server message\n");
break;
case svc_nop:
break;
case svc_serverCommand:
temp = MSG_ReadLong( &oldMsg );
s = MSG_ReadString( &oldMsg );
if (temp<=msgSequence)
break;
// Com_Printf( " server command %s\n", s );
msgSequence = temp;
Cmd_TokenizeString( s );
if ( !Q_stricmp( Cmd_Argv(0), "bcs0" ) ) {
bigConfigNumber = atoi( Cmd_Argv(1) );
Q_strncpyz( bigConfigString, Cmd_Argv(2), sizeof( bigConfigString ));
break;
}
if ( !Q_stricmp( Cmd_Argv(0), "bcs1" ) ) {
Q_strcat( bigConfigString, sizeof( bigConfigString ), Cmd_Argv(2));
break;
}
if ( !Q_stricmp( Cmd_Argv(0), "bcs2" ) ) {
Q_strcat( bigConfigString, sizeof( bigConfigString ), Cmd_Argv(2));
demoFrameAddString( &workFrame->string, bigConfigNumber, bigConfigString );
break;
}
if ( !Q_stricmp( Cmd_Argv(0), "cs" ) ) {
int num = atoi( Cmd_Argv(1) );
s = Cmd_ArgsFrom( 2 );
demoFrameAddString( &workFrame->string, num, Cmd_ArgsFrom( 2 ) );
break;
}
if ( clientNum >= 0 && clientNum < MAX_CLIENTS ) {
int len = strlen( s ) + 1;
char *dst;
if (workFrame->commandUsed + len + 1 > sizeof( workFrame->commandData)) {
Com_Printf("Overflowed state command data.\n");
goto conversionerror;
}
dst = workFrame->commandData + workFrame->commandUsed;
*dst = clientNum;
Com_Memcpy( dst+1, s, len );
workFrame->commandUsed += len + 1;
}
break;
case svc_gamestate:
if (newHandle) {
FS_FCloseFile( newHandle );
newHandle = 0;
}
if (levelCount) {
Com_sprintf( newName, sizeof( newName ), "%s.%d.mme", newBaseName, levelCount );
} else {
Com_sprintf( newName, sizeof( newName ), "%s.mme", newBaseName );
}
fullTime = -1;
clientNum = -1;
oldTime = -1;
Com_Memset( convert, 0, sizeof( *convert ));
convert->frames[0].string.used = 1;
levelCount++;
newHandle = FS_FOpenFileWrite( newName );
if (!newHandle) {
Com_Printf("Failed to open %s for target conversion target.\n", newName);
goto conversionerror;
return;
} else {
FS_Write ( demoHeader, strlen( demoHeader ), newHandle );
}
Com_sprintf( newName, sizeof( newName ), "%s.txt", newBaseName );
workFrame = &convert->frames[ convert->frameIndex % DEMOCONVERTFRAMES ];
msgSequence = MSG_ReadLong( &oldMsg );
while( 1 ) {
cmd = MSG_ReadByte( &oldMsg );
if (cmd == svc_EOF)
break;
if ( cmd == svc_configstring) {
int num;
const char *s;
num = MSG_ReadShort( &oldMsg );
s = MSG_ReadBigString( &oldMsg );
demoFrameAddString( &workFrame->string, num, s );
} else if ( cmd == svc_baseline ) {
int num = MSG_ReadBits( &oldMsg, GENTITYNUM_BITS );
if ( num < 0 || num >= MAX_GENTITIES ) {
Com_Printf( "Baseline number out of range: %i.\n", num );
goto conversionerror;
}
MSG_ReadDeltaEntity( &oldMsg, &demoNullEntityState, &convert->entityBaselines[num], num );
} else {
Com_Printf( "Unknown block while converting demo gamestate.\n" );
goto conversionerror;
}
}
clientNum = MSG_ReadLong( &oldMsg );
/* Skip the checksum feed */
MSG_ReadLong( &oldMsg );
break;
case svc_snapshot:
nextTime = MSG_ReadLong( &oldMsg );
/* Delta number, not needed */
newSnap = &convert->snapshots[convert->messageNum & PACKET_MASK];
Com_Memset (newSnap, 0, sizeof(*newSnap));
newSnap->deltaNum = MSG_ReadByte( &oldMsg );
newSnap->messageNum = convert->messageNum;
if (!newSnap->deltaNum) {
newSnap->deltaNum = -1;
newSnap->valid = qtrue; // uncompressed frame
oldSnap = NULL;
} else {
newSnap->deltaNum = newSnap->messageNum - newSnap->deltaNum;
oldSnap = &convert->snapshots[newSnap->deltaNum & PACKET_MASK];
if (!oldSnap->valid) {
Com_Printf( "Delta snapshot without base.\n" );
goto conversionerror;
} else if (oldSnap->messageNum != newSnap->deltaNum) {
// The frame that the server did the delta from
// is too old, so we can't reconstruct it properly.
Com_Printf ("Delta frame too old.\n");
} else if ( parseEntitiesNum - oldSnap->parseEntitiesNum > MAX_PARSE_ENTITIES-128 ) {
Com_Printf ("Delta parseEntitiesNum too old.\n");
} else {
newSnap->valid = qtrue; // valid delta parse
}
}
/* Snapflags, not needed */
newSnap->snapFlags = MSG_ReadByte( &oldMsg );
// read areamask
workFrame->areaUsed = MSG_ReadByte( &oldMsg );
MSG_ReadData( &oldMsg, workFrame->areamask, workFrame->areaUsed );
if (clientNum <0 || clientNum >= MAX_CLIENTS) {
Com_Printf("Got snapshot with invalid client.\n");
goto conversionerror;
}
MSG_ReadDeltaPlayerstate( &oldMsg, oldSnap ? &oldSnap->ps : &demoNullPlayerState, &newSnap->ps );
/* Read the individual entities */
newSnap->parseEntitiesNum = parseEntitiesNum;
newSnap->numEntities = 0;
Com_Memset( workFrame->entityData, 0, sizeof( workFrame->entityData ));
/* The beast that is entity parsing */
{
int newnum;
entityState_t *oldstate, *newstate;
int oldindex = 0;
int oldnum;
newnum = MSG_ReadBits( &oldMsg, GENTITYNUM_BITS );
while ( 1 ) {
// read the entity index number
if (oldSnap && oldindex < oldSnap->numEntities) {
oldstate = &convert->parseEntities[(oldSnap->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
oldnum = oldstate->number;
} else {
oldstate = 0;
oldnum = 99999;
}
newstate = &convert->parseEntities[parseEntitiesNum];
if ( !oldstate && (newnum == (MAX_GENTITIES-1))) {
break;
} else if ( oldnum < newnum ) {
*newstate = *oldstate;
oldindex++;
} else if (oldnum == newnum) {
oldindex++;
MSG_ReadDeltaEntity( &oldMsg, oldstate, newstate, newnum );
if ( newstate->number != MAX_GENTITIES-1)
workFrame->entityData[ newstate->number ] = 1;
newnum = MSG_ReadBits( &oldMsg, GENTITYNUM_BITS );
} else if (oldnum > newnum) {
MSG_ReadDeltaEntity( &oldMsg, &convert->entityBaselines[newnum], newstate , newnum );
if ( newstate->number != MAX_GENTITIES-1)
workFrame->entityData[ newstate->number ] = 1;
newnum = MSG_ReadBits( &oldMsg, GENTITYNUM_BITS );
}
if (newstate->number == MAX_GENTITIES-1)
continue;
parseEntitiesNum++;
parseEntitiesNum &= (MAX_PARSE_ENTITIES-1);
newSnap->numEntities++;
}}
/* Stop processing this further since it's an invalid snap due to lack of delta data */
if (!newSnap->valid)
break;
/* Skipped snapshots will be set invalid in the circular buffer */
if ( newSnap->messageNum - convert->lastMessageNum >= PACKET_BACKUP ) {
convert->lastMessageNum = newSnap->messageNum - ( PACKET_BACKUP - 1 );
}
for ( ; convert->lastMessageNum < newSnap->messageNum ; convert->lastMessageNum++ ) {
convert->snapshots[convert->lastMessageNum & PACKET_MASK].valid = qfalse;
}
convert->lastMessageNum = newSnap->messageNum + 1;
/* compress the frame into the new format */
if (nextTime > oldTime) {
demoFrame_t *cleanFrame;
int writeIndex;
for (temp = 0;temp<newSnap->numEntities;temp++) {
int p = (newSnap->parseEntitiesNum+temp) & (MAX_PARSE_ENTITIES-1);
entityState_t *newState = &convert->parseEntities[p];
workFrame->entities[newState->number] = *newState;
}
workFrame->clientData[clientNum] = 1;
workFrame->clients[clientNum] = newSnap->ps;
workFrame->serverTime = nextTime;
/* Which frame from the cache to save */
writeIndex = convert->frameIndex - (DEMOCONVERTFRAMES/2);
if (writeIndex >= 0) {
const demoFrame_t *newFrame;
msg_t writeMsg;
// init the message
MSG_Init( &writeMsg, demoBuffer, sizeof (demoBuffer));
MSG_Clear( &writeMsg );
MSG_Bitstream( &writeMsg );
newFrame = &convert->frames[ writeIndex % DEMOCONVERTFRAMES];
if ( smoothen )
demoFrameInterpolate( convert->frames, DEMOCONVERTFRAMES, writeIndex );
if ( nextTime > fullTime || writeIndex <= 0 ) {
/* Plan the next time for a full write */
fullTime = nextTime + 2000;
demoFramePack( &writeMsg, newFrame, 0 );
} else {
const demoFrame_t *oldFrame = &convert->frames[ ( writeIndex -1 ) % DEMOCONVERTFRAMES];
demoFramePack( &writeMsg, newFrame, oldFrame );
}
/* Write away the new data in the msg queue */
temp = LittleLong( writeMsg.cursize );
FS_Write (&temp, 4, newHandle );
FS_Write ( writeMsg.data , writeMsg.cursize, newHandle );
}
/* Clean up the upcoming frame for all new changes */
convert->frameIndex++;
cleanFrame = &convert->frames[ convert->frameIndex % DEMOCONVERTFRAMES];
cleanFrame->serverTime = 0;
for (temp = 0;temp<MAX_GENTITIES;temp++)
cleanFrame->entities[temp].number = MAX_GENTITIES-1;
Com_Memset( cleanFrame->clientData, 0, sizeof ( cleanFrame->clientData ));
Com_Memcpy( cleanFrame->string.data, workFrame->string.data, workFrame->string.used );
Com_Memcpy( cleanFrame->string.offsets, workFrame->string.offsets, sizeof( workFrame->string.offsets ));
cleanFrame->string.used = workFrame->string.used;
cleanFrame->commandUsed = 0;
/* keep track of this last frame's time */
oldTime = nextTime;
}
break;
case svc_download:
// read block number
temp = MSG_ReadShort ( &oldMsg );
if (!temp) //0 block, read file size
MSG_ReadLong( &oldMsg );
// read block size
temp = MSG_ReadShort ( &oldMsg );
// read the data block
for ( ;temp>0;temp--)
MSG_ReadByte( &oldMsg );
break;
}
}
}
conversionerror:
FS_FCloseFile( oldHandle );
FS_FCloseFile( newHandle );
Z_Free( convert );
return;
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg )
{
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 )
{
cmd = MSG_ReadByte( msg );
if ( cmd == svc_EOF )
{
break;
}
if ( cmd == svc_configstring )
{
int len;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS )
{
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadBigString( msg );
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS )
{
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
}
else if ( cmd == svc_baseline )
{
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES )
{
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
memset( &nullstate, 0, sizeof( nullstate ) );
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
}
else
{
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
clc.clientNum = MSG_ReadLong( msg );
// read the checksum feed
clc.checksumFeed = MSG_ReadLong( msg );
// parse serverId and other cvars
CL_SystemInfoChanged();
// reinitialize the filesystem if the game directory has changed
FS_ConditionalRestart( clc.checksumFeed );
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
// cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg ) {
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
char oldGame[MAX_QPATH];
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 ) {
cmd = MSG_ReadByte( msg );
if ( cmd == svc_EOF ) {
break;
}
if ( cmd == svc_configstring ) {
int len;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadBigString( msg );
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
} else if ( cmd == svc_baseline ) {
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
Com_Memset (&nullstate, 0, sizeof(nullstate));
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
} else {
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
clc.clientNum = MSG_ReadLong(msg);
// read the checksum feed
clc.checksumFeed = MSG_ReadLong( msg );
// save old gamedir
Cvar_VariableStringBuffer("fs_game", oldGame, sizeof(oldGame));
// parse useful values out of CS_SERVERINFO
CL_ParseServerInfo();
// parse serverId and other cvars
CL_SystemInfoChanged();
// stop recording now so the demo won't have an unnecessary level load at the end.
if(cl_autoRecordDemo->integer && clc.demorecording)
CL_StopRecord_f();
// reinitialize the filesystem if the game directory has changed
if(!cl_oldGameSet && (Cvar_Flags("fs_game") & CVAR_MODIFIED))
{
cl_oldGameSet = qtrue;
Q_strncpyz(cl_oldGame, oldGame, sizeof(cl_oldGame));
}
FS_ConditionalRestart(clc.checksumFeed, qfalse);
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
// cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
// Do very shallow parse of the demo (could be extended) just to get times and snapshot count
static void CL_ParseDemo(void)
{
int tstart = 0;
int demofile = 0;
// Reset our demo data
memset(&di, 0, sizeof(di));
// Parse start
di.gameStartTime = -1;
di.gameEndTime = -1;
FS_Seek(clc.demofile, 0, FS_SEEK_SET);
tstart = Sys_Milliseconds();
while (qtrue)
{
int r;
msg_t buf;
msg_t *msg;
byte bufData[MAX_MSGLEN];
int s;
int cmd;
di.demoPos = FS_FTell(clc.demofile);
// get the sequence number
r = FS_Read(&s, 4, clc.demofile);
if (r != 4)
{
CL_DemoCompleted();
return;
}
clc.serverMessageSequence = LittleLong(s);
// init the message
MSG_Init(&buf, bufData, sizeof(bufData));
// get the length
r = FS_Read(&buf.cursize, 4, clc.demofile);
if (r != 4)
{
break;
}
buf.cursize = LittleLong(buf.cursize);
if (buf.cursize == -1)
{
break;
}
if (buf.cursize > buf.maxsize)
{
Com_FuncPrinf("demoMsglen > MAX_MSGLEN");
break;
}
r = FS_Read(buf.data, buf.cursize, clc.demofile);
if (r != buf.cursize)
{
Com_FuncPrinf("Demo file was truncated.\n");
break;
}
clc.lastPacketTime = cls.realtime;
buf.readcount = 0;
// parse
msg = &buf;
MSG_Bitstream(msg);
// get the reliable sequence acknowledge number
clc.reliableAcknowledge = MSG_ReadLong(msg);
if (clc.reliableAcknowledge < clc.reliableSequence - MAX_RELIABLE_COMMANDS)
{
clc.reliableAcknowledge = clc.reliableSequence;
}
// parse the message
while (qtrue)
{
if (msg->readcount > msg->cursize)
{
Com_FuncDrop("read past end of server message");
return;
}
cmd = MSG_ReadByte(msg);
if (cmd == svc_EOF)
{
break;
}
// other commands
switch (cmd)
{
default:
Com_FuncDrop("Illegible server message %d", cmd);
return;
case svc_nop:
break;
case svc_serverCommand:
MSG_ReadLong(msg);
MSG_ReadString(msg);
break;
case svc_gamestate:
clc.serverCommandSequence = MSG_ReadLong(msg);
cl.gameState.dataCount = 1;
while (qtrue)
{
int cmd2 = MSG_ReadByte(msg);
if (cmd2 == svc_EOF)
{
break;
}
if (cmd2 == svc_configstring)
{
MSG_ReadShort(msg);
MSG_ReadBigString(msg);
}
else if (cmd2 == svc_baseline)
{
entityState_t s1, s2;
memset(&s1, 0, sizeof(s1));
memset(&s2, 0, sizeof(s2));
MSG_ReadBits(msg, GENTITYNUM_BITS);
MSG_ReadDeltaEntity(msg, &s1, &s2, 0);
}
else
{
Com_FuncDrop("bad command byte");
return;
}
}
MSG_ReadLong(msg);
MSG_ReadLong(msg);
break;
case svc_snapshot:
CL_ParseDemoSnapShotSimple(msg);
break;
case svc_download:
MSG_ReadShort(msg);
break;
}
}
if (!cl.snap.valid)
{
Com_FuncPrinf("!cl.snap.valid\n");
continue;
}
if (cl.snap.serverTime < cl.oldFrameServerTime)
{
// ignore snapshots that don't have entities
if (cl.snap.snapFlags & SNAPFLAG_NOT_ACTIVE)
{
continue;
}
cls.state = CA_ACTIVE;
// set the timedelta so we are exactly on this first frame
cl.serverTimeDelta = cl.snap.serverTime - cls.realtime;
cl.oldServerTime = cl.snap.serverTime;
clc.timeDemoBaseTime = cl.snap.serverTime;
}
cl.oldFrameServerTime = cl.snap.serverTime;
if (cl.newSnapshots)
{
CL_AdjustTimeDelta();
}
di.lastServerTime = cl.snap.serverTime;
if (di.firstServerTime == 0)
{
di.firstServerTime = cl.snap.serverTime;
Com_FuncPrinf("firstServerTime %d\n", di.firstServerTime);
}
di.snapsInDemo++;
}
Com_FuncPrinf("Snaps in demo: %i\n", di.snapsInDemo);
Com_FuncPrinf("last serverTime %d total %f minutes\n", cl.snap.serverTime, (cl.snap.serverTime - di.firstServerTime) / 1000.0 / 60.0);
Com_FuncPrinf("parse time %f seconds\n", (float)(Sys_Milliseconds() - tstart) / 1000.0);
FS_Seek(clc.demofile, 0, FS_SEEK_SET);
clc.demoplaying = qfalse;
demofile = clc.demofile;
CL_ClearState();
Com_Memset(&clc, 0, sizeof(clc));
Com_ClearDownload();
clc.demofile = demofile;
cls.state = CA_DISCONNECTED;
cl_connectedToPureServer = qfalse;
dpi.firstTime = di.firstServerTime;
dpi.lastTime = di.lastServerTime;
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg ) {
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
char *s;
Con_Close();
UI_UpdateConnectionString( "" );
// wipe local client state
CL_ClearState();
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
cl.gameState.dataCount = 1; // leave a 0 at the beginning for uninitialized configstrings
while ( 1 ) {
cmd = MSG_ReadByte( msg );
if ( cmd <= 0 ) {
break;
}
if ( cmd == svc_configstring ) {
int len;
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
s = MSG_ReadString( msg );
len = strlen( s );
if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
}
// append it to the gameState string buffer
cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
cl.gameState.dataCount += len + 1;
if ( cl_shownet->integer == 3 ) {
Com_Printf ("%3i: CS# %d %s (%d)\n",msg->readcount, i,s,len);
}
} else if ( cmd == svc_baseline ) {
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
memset (&nullstate, 0, sizeof(nullstate));
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
} else {
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
// parse serverId and other cvars
CL_SystemInfoChanged();
// reinitialize the filesystem if the game directory has changed
#if 0
if ( fs_game->modified ) {
}
#endif
// let the client game init and load data
cls.state = CA_LOADING;
CL_StartHunkUsers();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
/*
==================
CL_ParseGamestate
==================
*/
void CL_ParseGamestate( msg_t *msg )
{
int i;
entityState_t *es;
int newnum;
entityState_t nullstate;
int cmd;
Con_Close();
clc.connectPacketCount = 0;
// wipe local client state
CL_ClearState();
// a gamestate always marks a server command sequence
clc.serverCommandSequence = MSG_ReadLong( msg );
// parse all the configstrings and baselines
while ( 1 )
{
cmd = MSG_ReadByte( msg );
if ( cmd == svc_EOF )
{
break;
}
if ( cmd == svc_configstring )
{
i = MSG_ReadShort( msg );
if ( i < 0 || i >= MAX_CONFIGSTRINGS )
{
Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
}
const char* str = MSG_ReadBigString( msg );
std::string s = str;
cl.gameState[i] = str;
}
else if ( cmd == svc_baseline )
{
newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
if ( newnum < 0 || newnum >= MAX_GENTITIES )
{
Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
}
memset( &nullstate, 0, sizeof( nullstate ) );
es = &cl.entityBaselines[ newnum ];
MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
}
else
{
Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
}
}
clc.clientNum = MSG_ReadLong( msg );
// read the checksum feed
clc.checksumFeed = MSG_ReadLong( msg );
// parse serverId and other cvars
CL_SystemInfoChanged();
// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
// cgame
CL_InitDownloads();
// make sure the game starts
Cvar_Set( "cl_paused", "0" );
}
