/*
=======================
SV_SendClientMessages
=======================
*/
void SV_SendClientMessages( void ) {
int i;
client_t *c;
// send a message to each connected client
for (i=0, c = svs.clients ; i < sv_maxclients->integer ; i++, c++) {
if (!c->state) {
continue; // not connected
}
if ( svs.time < c->nextSnapshotTime ) {
continue; // not time yet
}
// send additional message fragments if the last message
// was too large to send at once
if ( c->netchan.unsentFragments ) {
c->nextSnapshotTime = svs.time +
SV_RateMsec( c, c->netchan.unsentLength - c->netchan.unsentFragmentStart );
SV_Netchan_TransmitNextFragment( &c->netchan );
continue;
}
// generate and send a new message
SV_SendClientSnapshot( c );
}
}
/*
================
SV_SendClientGameState
Sends the first message from the server to a connected client.
This will be sent on the initial connection and upon each new map load.
It will be resent if the client acknowledges a later message but has
the wrong gamestate.
================
*/
void SV_SendClientGameState( client_t *client ) {
msg_t msg;
byte msgBuffer[MAX_MSGLEN];
MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
// MW - my attempt to fix illegible server message errors caused by
// packet fragmentation of initial snapshot.
while(client->state&&client->netchan.unsentFragments)
{
// send additional message fragments if the last message
// was too large to send at once
Com_Printf ("[ISM]SV_SendClientGameState() [2] for %s, writing out old fragments\n", client->name);
SV_Netchan_TransmitNextFragment(&client->netchan);
}
Com_DPrintf ("SV_SendClientGameState() for %s\n", client->name);
Com_DPrintf( "Going from CS_CONNECTED to CS_PRIMED for %s\n", client->name );
if ( client->state == CS_CONNECTED )
client->state = CS_PRIMED;
client->pureAuthentic = 0;
client->gotCP = qfalse;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
client->gamestateMessageNum = client->netchan.outgoingSequence;
SV_CreateClientGameStateMessage( client, &msg );
// deliver this to the client
SV_SendMessageToClient( &msg, client );
}
int SV_SendQueuedMessages(void)
{
int i, retval = -1, nextFragT;
client_t *cl;
for(i=0; i < sv_maxclients->integer; i++)
{
cl = &svs.clients[i];
if(cl->state && cl->netchan.unsentFragments)
{
nextFragT = SV_RateMsec(cl);
if(!nextFragT) {
SV_Netchan_TransmitNextFragment(&cl->netchan);
nextFragT = SV_RateMsec(cl);
}
if(nextFragT >= 0 && (retval == -1 || retval > nextFragT))
retval = nextFragT;
}
}
return retval;
}
void SV_SendClientMessages( void ) {
int i, freeBytes, index;
msg_t msg;
byte buf[0x20000];
client_t *c;
byte snapClients[MAX_CLIENTS];
int numclients = 0; // NERVE - SMF - net debugging
/*
SV_SendClientMessagesA( );
return;
*/
sv.bpsTotalBytes = 0; // NERVE - SMF - net debugging
sv.ubpsTotalBytes = 0; // NERVE - SMF - net debugging
// send a message to each connected client
for ( i = 0, c = svs.clients ; i < sv_maxclients->integer ; i++, c++ ) {
if ( !c->state ) {
snapClients[i] = 0;
continue; // not connected
}
if ( svs.time < c->nextSnapshotTime ) {
snapClients[i] = 0;
continue; // not time yet
}
numclients++; // NERVE - SMF - net debugging
// send additional message fragments if the last message
// was too large to send at once
if ( c->netchan.unsentFragments ) {
c->nextSnapshotTime = svs.time + SV_RateMsec( c, c->netchan.unsentLength - c->netchan.unsentFragmentStart );
SV_Netchan_TransmitNextFragment( c );
snapClients[i] = 0;
continue;
}
// generate a new message
snapClients[i] = 1;
if ( c->state == CS_ACTIVE || c->state == CS_ZOMBIE )
SV_BuildClientSnapshot( c );
}
SV_SetServerStaticHeader();
for (i = 0, c = svs.clients; i < sv_maxclients->integer; i++, c++) {
if(snapClients[i] == 0)
continue;
SV_BeginClientSnapshot( c, &msg );
if(c->state == CS_ACTIVE || c->state == CS_ZOMBIE)
SV_WriteSnapshotToClient( c, &msg );
SV_EndClientSnapshot(c, &msg);
SV_SendClientVoiceData( c );
}
// NERVE - SMF - net debugging
if ( sv_showAverageBPS->integer && numclients > 0 ) {
float ave = 0, uave = 0;
for ( i = 0; i < MAX_BPS_WINDOW - 1; i++ ) {
sv.bpsWindow[i] = sv.bpsWindow[i + 1];
ave += sv.bpsWindow[i];
sv.ubpsWindow[i] = sv.ubpsWindow[i + 1];
uave += sv.ubpsWindow[i];
}
sv.bpsWindow[MAX_BPS_WINDOW - 1] = sv.bpsTotalBytes;
ave += sv.bpsTotalBytes;
sv.ubpsWindow[MAX_BPS_WINDOW - 1] = sv.ubpsTotalBytes;
uave += sv.ubpsTotalBytes;
if ( sv.bpsTotalBytes >= sv.bpsMaxBytes ) {
sv.bpsMaxBytes = sv.bpsTotalBytes;
}
if ( sv.ubpsTotalBytes >= sv.ubpsMaxBytes ) {
sv.ubpsMaxBytes = sv.ubpsTotalBytes;
}
sv.bpsWindowSteps++;
if ( sv.bpsWindowSteps >= MAX_BPS_WINDOW ) {
float comp_ratio;
sv.bpsWindowSteps = 0;
ave = ( ave / (float)MAX_BPS_WINDOW );
uave = ( uave / (float)MAX_BPS_WINDOW );
comp_ratio = ( 1 - ave / uave ) * 100.f;
sv.ucompAve += comp_ratio;
sv.ucompNum++;
Com_DPrintf( "bpspc(%2.0f) bps(%2.0f) pk(%i) ubps(%2.0f) upk(%i) cr(%2.2f) acr(%2.2f)\n",
ave / (float)numclients, ave, sv.bpsMaxBytes, uave, sv.ubpsMaxBytes, comp_ratio, sv.ucompAve / sv.ucompNum );
}
}
// -NERVE - SMF
if ( sv.state != SS_GAME )
{
SV_GetServerStaticHeader();
return;
}
MSG_Init(&msg, buf, sizeof(buf));
SV_ArchiveSnapshot(&msg);
SV_GetServerStaticHeader();
if ( msg.overflowed == qtrue )
{
Com_DPrintf("SV_ArchiveSnapshot: ignoring snapshot because it overflowed.\n");
return;
}
svs.archiveSnaps[svs.nextArchivedSnapshotFrames % 1200].buffer = svs.nextArchivedSnapshotBuffer;
svs.archiveSnaps[svs.nextArchivedSnapshotFrames % 1200].msgsize = msg.cursize;
index = svs.nextArchivedSnapshotBuffer % 0x2000000;
svs.nextArchivedSnapshotBuffer += msg.cursize;
if ( svs.nextArchivedSnapshotBuffer >= (signed int)0x7FFFFFFE )
{
Com_Error(0, "svs.nextArchivedSnapshotBuffer wrapped");
return;
}
freeBytes = 0x2000000 - index;
if ( msg.cursize > freeBytes )
{
memcpy(&svs.archiveSnapBuffer[index], msg.data, freeBytes);
memcpy(svs.archiveSnapBuffer, &msg.data[freeBytes], msg.cursize - freeBytes);
}
else
{
memcpy(&svs.archiveSnapBuffer[index], msg.data, msg.cursize);
}
svs.nextArchivedSnapshotFrames++;
if ( svs.nextArchivedSnapshotFrames >= (signed int)0x7FFFFFFE ){
Com_Error(0, "svs.nextArchivedSnapshotFrames wrapped");
}
}
/*
=======================
SV_SendMessageToClient
Called by SV_SendClientSnapshot and SV_SendClientGameState
=======================
*/
void SV_SendMessageToClient( msg_t *msg, client_t *client ) {
int rateMsec;
// MW - my attempt to fix illegible server message errors caused by
// packet fragmentation of initial snapshot.
while(client->state&&client->netchan.unsentFragments)
{
// send additional message fragments if the last message
// was too large to send at once
Com_Printf ("[ISM]SV_SendClientGameState() [1] for %s, writing out old fragments\n", client->name);
SV_Netchan_TransmitNextFragment(&client->netchan);
}
// record information about the message
client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg->cursize;
client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = svs.time;
client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageAcked = -1;
// send the datagram
SV_Netchan_Transmit( client, msg ); //msg->cursize, msg->data );
// set nextSnapshotTime based on rate and requested number of updates
// local clients get snapshots every frame
if ( client->netchan.remoteAddress.type == NA_LOOPBACK || Sys_IsLANAddress (client->netchan.remoteAddress) ) {
client->nextSnapshotTime = svs.time - 1;
return;
}
// normal rate / snapshotMsec calculation
rateMsec = SV_RateMsec( client, msg->cursize );
if ( rateMsec < client->snapshotMsec ) {
// never send more packets than this, no matter what the rate is at
rateMsec = client->snapshotMsec;
client->rateDelayed = qfalse;
} else {
client->rateDelayed = qtrue;
}
client->nextSnapshotTime = svs.time + rateMsec;
// don't pile up empty snapshots while connecting
if ( client->state != CS_ACTIVE ) {
// a gigantic connection message may have already put the nextSnapshotTime
// more than a second away, so don't shorten it
// do shorten if client is downloading
#ifdef _XBOX // No downloads on Xbox
if ( client->nextSnapshotTime < svs.time + 1000 ) {
#else
if ( !*client->downloadName && client->nextSnapshotTime < svs.time + 1000 ) {
#endif
client->nextSnapshotTime = svs.time + 1000;
}
}
}
/*
=======================
SV_SendClientSnapshot
Also called by SV_FinalMessage
=======================
*/
extern cvar_t *fs_gamedirvar;
void SV_SendClientSnapshot( client_t *client ) {
byte msg_buf[MAX_MSGLEN];
msg_t msg;
if (!client->sentGamedir)
{ //rww - if this is the case then make sure there is an svc_setgame sent before this snap
int i = 0;
MSG_Init (&msg, msg_buf, sizeof(msg_buf));
//have to include this for each message.
MSG_WriteLong( &msg, client->lastClientCommand );
MSG_WriteByte (&msg, svc_setgame);
while (fs_gamedirvar->string[i])
{
MSG_WriteByte(&msg, fs_gamedirvar->string[i]);
i++;
}
MSG_WriteByte(&msg, 0);
// MW - my attempt to fix illegible server message errors caused by
// packet fragmentation of initial snapshot.
//rww - reusing this code here
while(client->state&&client->netchan.unsentFragments)
{
// send additional message fragments if the last message
// was too large to send at once
Com_Printf ("[ISM]SV_SendClientGameState() [1] for %s, writing out old fragments\n", client->name);
SV_Netchan_TransmitNextFragment(&client->netchan);
}
// record information about the message
client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg.cursize;
client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = svs.time;
client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageAcked = -1;
// send the datagram
SV_Netchan_Transmit( client, &msg ); //msg->cursize, msg->data );
client->sentGamedir = qtrue;
}
// build the snapshot
SV_BuildClientSnapshot( client );
// bots need to have their snapshots build, but
// the query them directly without needing to be sent
if ( client->gentity && client->gentity->r.svFlags & SVF_BOT ) {
return;
}
MSG_Init (&msg, msg_buf, sizeof(msg_buf));
msg.allowoverflow = qtrue;
// NOTE, MRE: all server->client messages now acknowledge
// let the client know which reliable clientCommands we have received
MSG_WriteLong( &msg, client->lastClientCommand );
// (re)send any reliable server commands
SV_UpdateServerCommandsToClient( client, &msg );
// send over all the relevant entityState_t
// and the playerState_t
SV_WriteSnapshotToClient( client, &msg );
// Add any download data if the client is downloading
#ifndef _XBOX // No downloads on Xbox
SV_WriteDownloadToClient( client, &msg );
#endif
// check for overflow
if ( msg.overflowed ) {
Com_Printf ("WARNING: msg overflowed for %s\n", client->name);
MSG_Clear (&msg);
}
SV_SendMessageToClient( &msg, client );
}
/*
================
SV_SendClientGameState
Sends the first message from the server to a connected client.
This will be sent on the initial connection and upon each new map load.
It will be resent if the client acknowledges a later message but has
the wrong gamestate.
================
*/
void SV_SendClientGameState( client_t *client ) {
int start;
entityState_t *base, nullstate;
msg_t msg;
byte msgBuffer[MAX_MSGLEN];
// MW - my attempt to fix illegible server message errors caused by
// packet fragmentation of initial snapshot.
while(client->state&&client->netchan.unsentFragments)
{
// send additional message fragments if the last message
// was too large to send at once
Com_Printf ("[ISM]SV_SendClientGameState() [2] for %s, writing out old fragments\n", client->name);
SV_Netchan_TransmitNextFragment(&client->netchan);
}
Com_DPrintf ("SV_SendClientGameState() for %s\n", client->name);
Com_DPrintf( "Going from CS_CONNECTED to CS_PRIMED for %s\n", client->name );
client->state = CS_PRIMED;
client->pureAuthentic = 0;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
client->gamestateMessageNum = client->netchan.outgoingSequence;
MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
// NOTE, MRE: all server->client messages now acknowledge
// let the client know which reliable clientCommands we have received
MSG_WriteLong( &msg, client->lastClientCommand );
// send any server commands waiting to be sent first.
// we have to do this cause we send the client->reliableSequence
// with a gamestate and it sets the clc.serverCommandSequence at
// the client side
SV_UpdateServerCommandsToClient( client, &msg );
// send the gamestate
MSG_WriteByte( &msg, svc_gamestate );
MSG_WriteLong( &msg, client->reliableSequence );
// write the configstrings
for ( start = 0 ; start < MAX_CONFIGSTRINGS ; start++ ) {
if (sv.configstrings[start][0]) {
MSG_WriteByte( &msg, svc_configstring );
MSG_WriteShort( &msg, start );
MSG_WriteBigString( &msg, sv.configstrings[start] );
}
}
// write the baselines
Com_Memset( &nullstate, 0, sizeof( nullstate ) );
for ( start = 0 ; start < MAX_GENTITIES; start++ ) {
base = &sv.svEntities[start].baseline;
if ( !base->number ) {
continue;
}
MSG_WriteByte( &msg, svc_baseline );
MSG_WriteDeltaEntity( &msg, &nullstate, base, qtrue );
}
MSG_WriteByte( &msg, svc_EOF );
MSG_WriteLong( &msg, client - svs.clients);
// write the checksum feed
MSG_WriteLong( &msg, sv.checksumFeed);
//rwwRMG - send info for the terrain
if ( TheRandomMissionManager )
{
z_stream zdata;
// Send the height map
memset(&zdata, 0, sizeof(z_stream));
deflateInit ( &zdata, Z_MAX_COMPRESSION );
unsigned char heightmap[15000];
zdata.next_out = (unsigned char*)heightmap;
zdata.avail_out = 15000;
zdata.next_in = TheRandomMissionManager->GetLandScape()->GetHeightMap();
zdata.avail_in = TheRandomMissionManager->GetLandScape()->GetRealArea();
deflate(&zdata, Z_SYNC_FLUSH);
MSG_WriteShort ( &msg, (unsigned short)zdata.total_out );
MSG_WriteBits ( &msg, 1, 1 );
MSG_WriteData ( &msg, heightmap, zdata.total_out);
deflateEnd(&zdata);
// Send the flatten map
memset(&zdata, 0, sizeof(z_stream));
deflateInit ( &zdata, Z_MAX_COMPRESSION );
zdata.next_out = (unsigned char*)heightmap;
zdata.avail_out = 15000;
zdata.next_in = TheRandomMissionManager->GetLandScape()->GetFlattenMap();
zdata.avail_in = TheRandomMissionManager->GetLandScape()->GetRealArea();
deflate(&zdata, Z_SYNC_FLUSH);
MSG_WriteShort ( &msg, (unsigned short)zdata.total_out );
MSG_WriteBits ( &msg, 1, 1 );
MSG_WriteData ( &msg, heightmap, zdata.total_out);
deflateEnd(&zdata);
// Seed is needed for misc ents and noise
MSG_WriteLong ( &msg, TheRandomMissionManager->GetLandScape()->get_rand_seed ( ) );
SV_WriteRMGAutomapSymbols ( &msg );
}
else
{
MSG_WriteShort ( &msg, 0 );
}
// deliver this to the client
SV_SendMessageToClient( &msg, client );
}
/*
================
SV_SendClientGameState
Sends the first message from the server to a connected client.
This will be sent on the initial connection and upon each new map load.
It will be resent if the client acknowledges a later message but has
the wrong gamestate.
================
*/
void SV_SendClientGameState( client_t *client ) {
int start;
entityState_t *base, nullstate;
msg_t msg;
byte msgBuffer[MAX_MSGLEN];
// MW - my attempt to fix illegible server message errors caused by
// packet fragmentation of initial snapshot.
while(client->state&&client->netchan.unsentFragments)
{
// send additional message fragments if the last message
// was too large to send at once
Com_Printf ("[ISM]SV_SendClientGameState() [2] for %s, writing out old fragments\n", client->name);
SV_Netchan_TransmitNextFragment(&client->netchan);
}
Com_DPrintf ("SV_SendClientGameState() for %s\n", client->name);
Com_DPrintf( "Going from CS_CONNECTED to CS_PRIMED for %s\n", client->name );
client->state = CS_PRIMED;
client->pureAuthentic = 0;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
client->gamestateMessageNum = client->netchan.outgoingSequence;
MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
// NOTE, MRE: all server->client messages now acknowledge
// let the client know which reliable clientCommands we have received
MSG_WriteLong( &msg, client->lastClientCommand );
// send any server commands waiting to be sent first.
// we have to do this cause we send the client->reliableSequence
// with a gamestate and it sets the clc.serverCommandSequence at
// the client side
SV_UpdateServerCommandsToClient( client, &msg );
// send the gamestate
MSG_WriteByte( &msg, svc_gamestate );
MSG_WriteLong( &msg, client->reliableSequence );
// write the configstrings
for ( start = 0 ; start < MAX_CONFIGSTRINGS ; start++ ) {
if (sv.configstrings[start][0]) {
MSG_WriteByte( &msg, svc_configstring );
MSG_WriteShort( &msg, start );
MSG_WriteBigString( &msg, sv.configstrings[start] );
}
}
// write the baselines
Com_Memset( &nullstate, 0, sizeof( nullstate ) );
for ( start = 0 ; start < MAX_GENTITIES; start++ ) {
base = &sv.svEntities[start].baseline;
if ( !base->number ) {
continue;
}
MSG_WriteByte( &msg, svc_baseline );
MSG_WriteDeltaEntity( &msg, &nullstate, base, qtrue );
}
MSG_WriteByte( &msg, svc_EOF );
MSG_WriteLong( &msg, client - svs.clients);
// write the checksum feed
MSG_WriteLong( &msg, sv.checksumFeed);
// deliver this to the client
SV_SendMessageToClient( &msg, client );
}
