sv_snapshot.c File Reference

#include "server.h"

Include dependency graph for sv_snapshot.c:

Go to the source code of this file.

Data Structures
struct	snapshotEntityNumbers_t
Defines
#define	HEADER_RATE_BYTES   48
#define	MAX_SNAPSHOT_ENTITIES   1024
Functions
void	SV_AddEntitiesVisibleFromPoint (vec3_t origin, clientSnapshot_t *frame, snapshotEntityNumbers_t *eNums, qboolean portal)
void	SV_AddEntToSnapshot (svEntity_t *svEnt, sharedEntity_t *gEnt, snapshotEntityNumbers_t *eNums)
void	SV_BuildClientSnapshot (client_t *client)
void	SV_EmitPacketEntities (clientSnapshot_t *from, clientSnapshot_t *to, msg_t *msg)
int QDECL	SV_QsortEntityNumbers (const void *a, const void *b)
int	SV_RateMsec (client_t *client, int messageSize)
void	SV_SendClientMessages (void)
void	SV_SendClientSnapshot (client_t *client)
void	SV_SendMessageToClient (msg_t *msg, client_t *client)
void	SV_UpdateServerCommandsToClient (client_t *client, msg_t *msg)
void	SV_WriteSnapshotToClient (client_t *client, msg_t *msg)

---

Define Documentation

#define HEADER_RATE_BYTES   48

Definition at line 526 of file sv_snapshot.c.

#define MAX_SNAPSHOT_ENTITIES   1024

Definition at line 228 of file sv_snapshot.c.

---

Function Documentation

void SV_AddEntitiesVisibleFromPoint (  vec3_t  origin, clientSnapshot_t *  frame, snapshotEntityNumbers_t *  eNums, qboolean  portal )  [static]

Definition at line 283 of file sv_snapshot.c. References clientSnapshot_t::areabits, clientSnapshot_t::areabytes, svEntity_s::areanum, svEntity_s::areanum2, byte, playerState_s::clientNum, svEntity_s::clusternums, CM_AreasConnected(), CM_ClusterPVS(), CM_LeafArea(), CM_LeafCluster(), CM_PointLeafnum(), CM_WriteAreaBits(), Com_DPrintf(), Com_Error(), e, ERR_DROP, entityState_s::generic1, i, l, svEntity_s::lastCluster, entityShared_t::linked, server_t::num_entities, entityState_s::number, svEntity_s::numClusters, entityState_s::origin, entityState_s::origin2, clientSnapshot_t::ps, qtrue, sharedEntity_t::r, sharedEntity_t::s, entityShared_t::singleClient, server_t::snapshotCounter, svEntity_s::snapshotCounter, server_t::state, sv, SV_AddEntToSnapshot(), SV_GentityNum(), SV_SvEntityForGentity(), svEntity_t, entityShared_t::svFlags, vec3_t, VectorLengthSquared(), and VectorSubtract. Referenced by SV_BuildClientSnapshot(). { int e, i; sharedEntity_t *ent; svEntity_t *svEnt; int l; int clientarea, clientcluster; int leafnum; int c_fullsend; byte *clientpvs; byte *bitvector; // during an error shutdown message we may need to transmit // the shutdown message after the server has shutdown, so // specfically check for it if ( !sv.state ) { return; } leafnum = CM_PointLeafnum (origin); clientarea = CM_LeafArea (leafnum); clientcluster = CM_LeafCluster (leafnum); // calculate the visible areas frame->areabytes = CM_WriteAreaBits( frame->areabits, clientarea ); clientpvs = CM_ClusterPVS (clientcluster); c_fullsend = 0; for ( e = 0 ; e < sv.num_entities ; e++ ) { ent = SV_GentityNum(e); // never send entities that aren't linked in if ( !ent->r.linked ) { continue; } if (ent->s.number != e) { Com_DPrintf ("FIXING ENT->S.NUMBER!!!\n"); ent->s.number = e; } // entities can be flagged to explicitly not be sent to the client if ( ent->r.svFlags & SVF_NOCLIENT ) { continue; } // entities can be flagged to be sent to only one client if ( ent->r.svFlags & SVF_SINGLECLIENT ) { if ( ent->r.singleClient != frame->ps.clientNum ) { continue; } } // entities can be flagged to be sent to everyone but one client if ( ent->r.svFlags & SVF_NOTSINGLECLIENT ) { if ( ent->r.singleClient == frame->ps.clientNum ) { continue; } } // entities can be flagged to be sent to a given mask of clients if ( ent->r.svFlags & SVF_CLIENTMASK ) { if (frame->ps.clientNum >= 32) Com_Error( ERR_DROP, "SVF_CLIENTMASK: cientNum > 32\n" ); if (~ent->r.singleClient & (1 << frame->ps.clientNum)) continue; } svEnt = SV_SvEntityForGentity( ent ); // don't double add an entity through portals if ( svEnt->snapshotCounter == sv.snapshotCounter ) { continue; } // broadcast entities are always sent if ( ent->r.svFlags & SVF_BROADCAST ) { SV_AddEntToSnapshot( svEnt, ent, eNums ); continue; } // ignore if not touching a PV leaf // check area if ( !CM_AreasConnected( clientarea, svEnt->areanum ) ) { // doors can legally straddle two areas, so // we may need to check another one if ( !CM_AreasConnected( clientarea, svEnt->areanum2 ) ) { continue; // blocked by a door } } bitvector = clientpvs; // check individual leafs if ( !svEnt->numClusters ) { continue; } l = 0; for ( i=0 ; i < svEnt->numClusters ; i++ ) { l = svEnt->clusternums[i]; if ( bitvector[l >> 3] & (1 << (l&7) ) ) { break; } } // if we haven't found it to be visible, // check overflow clusters that coudln't be stored if ( i == svEnt->numClusters ) { if ( svEnt->lastCluster ) { for ( ; l <= svEnt->lastCluster ; l++ ) { if ( bitvector[l >> 3] & (1 << (l&7) ) ) { break; } } if ( l == svEnt->lastCluster ) { continue; // not visible } } else { continue; } } // add it SV_AddEntToSnapshot( svEnt, ent, eNums ); // if its a portal entity, add everything visible from its camera position if ( ent->r.svFlags & SVF_PORTAL ) { if ( ent->s.generic1 ) { vec3_t dir; VectorSubtract(ent->s.origin, origin, dir); if ( VectorLengthSquared(dir) > (float) ent->s.generic1 * ent->s.generic1 ) { continue; } } SV_AddEntitiesVisibleFromPoint( ent->s.origin2, frame, eNums, qtrue ); } } }

Here is the call graph for this function:

void SV_AddEntToSnapshot (  svEntity_t *  svEnt, sharedEntity_t *  gEnt, snapshotEntityNumbers_t *  eNums )  [static]

Definition at line 262 of file sv_snapshot.c. References entityState_s::number, snapshotEntityNumbers_t::numSnapshotEntities, sharedEntity_t::s, server_t::snapshotCounter, svEntity_s::snapshotCounter, snapshotEntityNumbers_t::snapshotEntities, sv, and svEntity_t. Referenced by SV_AddEntitiesVisibleFromPoint(). { // if we have already added this entity to this snapshot, don't add again if ( svEnt->snapshotCounter == sv.snapshotCounter ) { return; } svEnt->snapshotCounter = sv.snapshotCounter; // if we are full, silently discard entities if ( eNums->numSnapshotEntities == MAX_SNAPSHOT_ENTITIES ) { return; } eNums->snapshotEntities[ eNums->numSnapshotEntities ] = gEnt->s.number; eNums->numSnapshotEntities++; }

void SV_BuildClientSnapshot (  client_t *  client  )  [static]

Definition at line 436 of file sv_snapshot.c. References clientSnapshot_t::areabits, client_t, playerState_s::clientNum, serverStatic_t::clients, Com_Error(), Com_Memset(), entityState_t, ERR_DROP, ERR_FATAL, clientSnapshot_t::first_entity, client_s::frames, client_s::gentity, i, MAX_MAP_AREA_BYTES, client_s::netchan, serverStatic_t::nextSnapshotEntities, clientSnapshot_t::num_entities, serverStatic_t::numSnapshotEntities, snapshotEntityNumbers_t::numSnapshotEntities, playerState_s::origin, netchan_t::outgoingSequence, playerState_t, clientSnapshot_t::ps, qfalse, qsort(), sharedEntity_t::s, svEntity_s::snapshotCounter, server_t::snapshotCounter, serverStatic_t::snapshotEntities, snapshotEntityNumbers_t::snapshotEntities, state, client_s::state, sv, SV_AddEntitiesVisibleFromPoint(), SV_GameClientNum(), SV_GentityNum(), SV_QsortEntityNumbers(), server_t::svEntities, svEntity_t, svs, vec3_t, VectorCopy, and playerState_s::viewheight. Referenced by SV_SendClientSnapshot(). { vec3_t org; clientSnapshot_t *frame; snapshotEntityNumbers_t entityNumbers; int i; sharedEntity_t *ent; entityState_t *state; svEntity_t *svEnt; sharedEntity_t *clent; int clientNum; playerState_t *ps; // bump the counter used to prevent double adding sv.snapshotCounter++; // this is the frame we are creating frame = &client->frames[ client->netchan.outgoingSequence & PACKET_MASK ]; // clear everything in this snapshot entityNumbers.numSnapshotEntities = 0; Com_Memset( frame->areabits, 0, sizeof( frame->areabits ) ); // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=62 frame->num_entities = 0; clent = client->gentity; if ( !clent || client->state == CS_ZOMBIE ) { return; } // grab the current playerState_t ps = SV_GameClientNum( client - svs.clients ); frame->ps = *ps; // never send client's own entity, because it can // be regenerated from the playerstate clientNum = frame->ps.clientNum; if ( clientNum < 0 || clientNum >= MAX_GENTITIES ) { Com_Error( ERR_DROP, "SV_SvEntityForGentity: bad gEnt" ); } svEnt = &sv.svEntities[ clientNum ]; svEnt->snapshotCounter = sv.snapshotCounter; // find the client's viewpoint VectorCopy( ps->origin, org ); org[2] += ps->viewheight; // add all the entities directly visible to the eye, which // may include portal entities that merge other viewpoints SV_AddEntitiesVisibleFromPoint( org, frame, &entityNumbers, qfalse ); // if there were portals visible, there may be out of order entities // in the list which will need to be resorted for the delta compression // to work correctly. This also catches the error condition // of an entity being included twice. qsort( entityNumbers.snapshotEntities, entityNumbers.numSnapshotEntities, sizeof( entityNumbers.snapshotEntities[0] ), SV_QsortEntityNumbers ); // now that all viewpoint's areabits have been OR'd together, invert // all of them to make it a mask vector, which is what the renderer wants for ( i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++ ) { ((int *)frame->areabits)[i] = ((int *)frame->areabits)[i] ^ -1; } // copy the entity states out frame->num_entities = 0; frame->first_entity = svs.nextSnapshotEntities; for ( i = 0 ; i < entityNumbers.numSnapshotEntities ; i++ ) { ent = SV_GentityNum(entityNumbers.snapshotEntities[i]); state = &svs.snapshotEntities[svs.nextSnapshotEntities % svs.numSnapshotEntities]; *state = ent->s; svs.nextSnapshotEntities++; // this should never hit, map should always be restarted first in SV_Frame if ( svs.nextSnapshotEntities >= 0x7FFFFFFE ) { Com_Error(ERR_FATAL, "svs.nextSnapshotEntities wrapped"); } frame->num_entities++; } }

Here is the call graph for this function:

void SV_EmitPacketEntities (  clientSnapshot_t *  from, clientSnapshot_t *  to, msg_t *  msg )  [static]

Definition at line 55 of file sv_snapshot.c. References svEntity_s::baseline, entityState_t, clientSnapshot_t::first_entity, GENTITYNUM_BITS, MAX_GENTITIES, MSG_WriteBits(), MSG_WriteDeltaEntity(), NULL, clientSnapshot_t::num_entities, entityState_s::number, serverStatic_t::numSnapshotEntities, qfalse, qtrue, serverStatic_t::snapshotEntities, sv, server_t::svEntities, and svs. Referenced by SV_WriteSnapshotToClient(). { entityState_t *oldent, *newent; int oldindex, newindex; int oldnum, newnum; int from_num_entities; // generate the delta update if ( !from ) { from_num_entities = 0; } else { from_num_entities = from->num_entities; } newent = NULL; oldent = NULL; newindex = 0; oldindex = 0; while ( newindex < to->num_entities || oldindex < from_num_entities ) { if ( newindex >= to->num_entities ) { newnum = 9999; } else { newent = &svs.snapshotEntities[(to->first_entity+newindex) % svs.numSnapshotEntities]; newnum = newent->number; } if ( oldindex >= from_num_entities ) { oldnum = 9999; } else { oldent = &svs.snapshotEntities[(from->first_entity+oldindex) % svs.numSnapshotEntities]; oldnum = oldent->number; } if ( newnum == oldnum ) { // delta update from old position // because the force parm is qfalse, this will not result // in any bytes being emited if the entity has not changed at all MSG_WriteDeltaEntity (msg, oldent, newent, qfalse ); oldindex++; newindex++; continue; } if ( newnum < oldnum ) { // this is a new entity, send it from the baseline MSG_WriteDeltaEntity (msg, &sv.svEntities[newnum].baseline, newent, qtrue ); newindex++; continue; } if ( newnum > oldnum ) { // the old entity isn't present in the new message MSG_WriteDeltaEntity (msg, oldent, NULL, qtrue ); oldindex++; continue; } } MSG_WriteBits( msg, (MAX_GENTITIES-1), GENTITYNUM_BITS ); // end of packetentities }

Here is the call graph for this function:

int QDECL SV_QsortEntityNumbers (  const void *  a, const void *  b )  [static]

Definition at line 239 of file sv_snapshot.c. References Com_Error(), ERR_DROP, and QDECL. Referenced by SV_BuildClientSnapshot(). { int *ea, *eb; ea = (int *)a; eb = (int *)b; if ( *ea == *eb ) { Com_Error( ERR_DROP, "SV_QsortEntityStates: duplicated entity" ); } if ( *ea < *eb ) { return -1; } return 1; }

Here is the call graph for this function:

int SV_RateMsec (  client_t *  client, int  messageSize )  [static]

Definition at line 527 of file sv_snapshot.c. References client_t, Cvar_Set(), cvar_s::integer, client_s::rate, and sv_maxRate. Referenced by SV_SendClientMessages(), and SV_SendMessageToClient(). { int rate; int rateMsec; // individual messages will never be larger than fragment size if ( messageSize > 1500 ) { messageSize = 1500; } rate = client->rate; if ( sv_maxRate->integer ) { if ( sv_maxRate->integer < 1000 ) { Cvar_Set( "sv_MaxRate", "1000" ); } if ( sv_maxRate->integer < rate ) { rate = sv_maxRate->integer; } } rateMsec = ( messageSize + HEADER_RATE_BYTES ) * 1000 / rate; return rateMsec; }

Here is the call graph for this function:

void SV_SendClientMessages (  void   )

Definition at line 655 of file sv_snapshot.c. References c, client_t, serverStatic_t::clients, i, cvar_s::integer, client_s::netchan, client_s::nextSnapshotTime, client_s::state, sv_maxclients, SV_Netchan_TransmitNextFragment(), SV_RateMsec(), SV_SendClientSnapshot(), svs, serverStatic_t::time, netchan_t::unsentFragments, netchan_t::unsentFragmentStart, and netchan_t::unsentLength. Referenced by SV_Frame(). { 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 ); continue; } // generate and send a new message SV_SendClientSnapshot( c ); } }

Here is the call graph for this function:

void SV_SendClientSnapshot (  client_t *  client  )

Definition at line 610 of file sv_snapshot.c. References msg_t::allowoverflow, byte, client_t, Com_Printf(), client_s::gentity, client_s::lastClientCommand, MSG_Clear(), MSG_Init(), MSG_WriteLong(), client_s::name, msg_t::overflowed, sharedEntity_t::r, SV_BuildClientSnapshot(), SV_SendMessageToClient(), SV_UpdateServerCommandsToClient(), SV_WriteDownloadToClient(), SV_WriteSnapshotToClient(), and entityShared_t::svFlags. Referenced by SV_FinalMessage(), SV_SendClientMessages(), and SV_VerifyPaks_f(). { byte msg_buf[MAX_MSGLEN]; msg_t msg; // 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 SV_WriteDownloadToClient( client, &msg ); // check for overflow if ( msg.overflowed ) { Com_Printf ("WARNING: msg overflowed for %s\n", client->name); MSG_Clear (&msg); } SV_SendMessageToClient( &msg, client ); }

Here is the call graph for this function:

void SV_SendMessageToClient (  msg_t *  msg, client_t *  client )

Definition at line 556 of file sv_snapshot.c. References client_t, msg_t::cursize, client_s::downloadName, client_s::frames, cvar_s::integer, clientSnapshot_t::messageAcked, clientSnapshot_t::messageSent, clientSnapshot_t::messageSize, NA_LOOPBACK, client_s::netchan, client_s::nextSnapshotTime, netchan_t::outgoingSequence, client_s::rateDelayed, netchan_t::remoteAddress, client_s::snapshotMsec, client_s::state, sv_lanForceRate, SV_Netchan_Transmit(), SV_RateMsec(), svs, Sys_IsLANAddress(), serverStatic_t::time, and netadr_t::type. Referenced by SV_SendClientGameState(), and SV_SendClientSnapshot(). { int rateMsec; // 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 // TTimo - https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=491 // added sv_lanForceRate check if ( client->netchan.remoteAddress.type == NA_LOOPBACK || (sv_lanForceRate->integer && 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 if ( !*client->downloadName && client->nextSnapshotTime < svs.time + 1000 ) { client->nextSnapshotTime = svs.time + 1000; } } }

Here is the call graph for this function:

void SV_UpdateServerCommandsToClient (  client_t *  client, msg_t *  msg )

Definition at line 208 of file sv_snapshot.c. References client_t, i, MAX_RELIABLE_COMMANDS, MSG_WriteByte(), MSG_WriteLong(), MSG_WriteString(), client_s::reliableAcknowledge, client_s::reliableCommands, client_s::reliableSent, client_s::reliableSequence, and svc_serverCommand. Referenced by SV_SendClientGameState(), and SV_SendClientSnapshot(). { int i; // write any unacknowledged serverCommands for ( i = client->reliableAcknowledge + 1 ; i <= client->reliableSequence ; i++ ) { MSG_WriteByte( msg, svc_serverCommand ); MSG_WriteLong( msg, i ); MSG_WriteString( msg, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] ); } client->reliableSent = client->reliableSequence; }

Here is the call graph for this function:

void SV_WriteSnapshotToClient (  client_t *  client, msg_t *  msg )  [static]

Definition at line 122 of file sv_snapshot.c. References clientSnapshot_t::areabits, clientSnapshot_t::areabytes, client_t, Com_DPrintf(), client_s::deltaMessage, clientSnapshot_t::first_entity, client_s::frames, i, cvar_s::integer, MSG_WriteByte(), MSG_WriteData(), MSG_WriteDeltaPlayerstate(), MSG_WriteLong(), client_s::name, client_s::netchan, serverStatic_t::nextSnapshotEntities, NULL, serverStatic_t::numSnapshotEntities, netchan_t::outgoingSequence, PACKET_BACKUP, clientSnapshot_t::ps, client_s::rateDelayed, serverStatic_t::snapFlagServerBit, client_s::state, SV_EmitPacketEntities(), sv_padPackets, svc_nop, svc_snapshot, svs, and serverStatic_t::time. Referenced by SV_SendClientSnapshot(). { clientSnapshot_t *frame, *oldframe; int lastframe; int i; int snapFlags; // this is the snapshot we are creating frame = &client->frames[ client->netchan.outgoingSequence & PACKET_MASK ]; // try to use a previous frame as the source for delta compressing the snapshot if ( client->deltaMessage <= 0 || client->state != CS_ACTIVE ) { // client is asking for a retransmit oldframe = NULL; lastframe = 0; } else if ( client->netchan.outgoingSequence - client->deltaMessage >= (PACKET_BACKUP - 3) ) { // client hasn't gotten a good message through in a long time Com_DPrintf ("%s: Delta request from out of date packet.\n", client->name); oldframe = NULL; lastframe = 0; } else { // we have a valid snapshot to delta from oldframe = &client->frames[ client->deltaMessage & PACKET_MASK ]; lastframe = client->netchan.outgoingSequence - client->deltaMessage; // the snapshot's entities may still have rolled off the buffer, though if ( oldframe->first_entity <= svs.nextSnapshotEntities - svs.numSnapshotEntities ) { Com_DPrintf ("%s: Delta request from out of date entities.\n", client->name); oldframe = NULL; lastframe = 0; } } MSG_WriteByte (msg, svc_snapshot); // NOTE, MRE: now sent at the start of every message from server to client // let the client know which reliable clientCommands we have received //MSG_WriteLong( msg, client->lastClientCommand ); // send over the current server time so the client can drift // its view of time to try to match MSG_WriteLong (msg, svs.time); // what we are delta'ing from MSG_WriteByte (msg, lastframe); snapFlags = svs.snapFlagServerBit; if ( client->rateDelayed ) { snapFlags |= SNAPFLAG_RATE_DELAYED; } if ( client->state != CS_ACTIVE ) { snapFlags |= SNAPFLAG_NOT_ACTIVE; } MSG_WriteByte (msg, snapFlags); // send over the areabits MSG_WriteByte (msg, frame->areabytes); MSG_WriteData (msg, frame->areabits, frame->areabytes); // delta encode the playerstate if ( oldframe ) { MSG_WriteDeltaPlayerstate( msg, &oldframe->ps, &frame->ps ); } else { MSG_WriteDeltaPlayerstate( msg, NULL, &frame->ps ); } // delta encode the entities SV_EmitPacketEntities (oldframe, frame, msg); // padding for rate debugging if ( sv_padPackets->integer ) { for ( i = 0 ; i < sv_padPackets->integer ; i++ ) { MSG_WriteByte (msg, svc_nop); } } }

Here is the call graph for this function:

---