-
#include "quakedef.h"
#define ENTITYSIZEPROFILING_START(msg, num) \
}
}
-// FIXME FIXME FIXME: at this time the CSQC entity writing does not store
-// packet logs and thus if an update is lost it is never repeated, this makes
-// csqc entities useless at the moment.
+// NOTE: this only works with DP5 protocol and upwards. For lower protocols
+// (including QUAKE), no packet loss handling for CSQC is done, which makes
+// CSQC basically useless.
+// Always use the DP5 protocol, or a higher one, when using CSQC entities.
+static void EntityFrameCSQC_LostAllFrames(client_t *client)
+{
+ // mark ALL csqc entities as requiring a FULL resend!
+ // I know this is a bad workaround, but better than nothing.
+ int i, n;
+ prvm_eval_t *val;
+ prvm_edict_t *ed;
+
+ if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
+ return;
+
+ n = client->csqcnumedicts;
+ for(i = 0; i < n; ++i)
+ {
+ if(client->csqcentityglobalhistory[i])
+ {
+ ed = prog->edicts + i;
+ val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
+ if (val->function)
+ client->csqcentitysendflags[i] |= 0xFFFFFF; // FULL RESEND
+ else // if it was ever sent to that client as a CSQC entity
+ {
+ client->csqcentityscope[i] = 1; // REMOVE
+ client->csqcentitysendflags[i] |= 0xFFFFFF;
+ }
+ }
+ }
+}
+void EntityFrameCSQC_LostFrame(client_t *client, int framenum)
+{
+ // marks a frame as lost
+ int i, j, n;
+ qboolean valid;
+ int ringfirst, ringlast;
+ int recoversendflags[MAX_EDICTS];
+ csqcentityframedb_t *d;
+
+ n = client->csqcnumedicts;
+
+ // is our frame out of history?
+ ringfirst = client->csqcentityframehistory_next; // oldest entry
+ ringlast = (ringfirst + NUM_CSQCENTITYDB_FRAMES - 1) % NUM_CSQCENTITYDB_FRAMES; // most recently added entry
+
+ valid = false;
+
+ for(j = 0; j < NUM_CSQCENTITYDB_FRAMES; ++j)
+ {
+ d = &client->csqcentityframehistory[(ringfirst + j) % NUM_CSQCENTITYDB_FRAMES];
+ if(d->framenum < 0)
+ continue;
+ if(d->framenum == framenum)
+ break;
+ else if(d->framenum < framenum)
+ valid = true;
+ }
+ if(j == NUM_CSQCENTITYDB_FRAMES)
+ {
+ if(valid) // got beaten, i.e. there is a frame < framenum
+ {
+ // a non-csqc frame got lost... great
+ return;
+ }
+ else
+ {
+ // a too old frame got lost... sorry, cannot handle this
+ Con_DPrintf("CSQC entity DB: lost a frame too early to do any handling (resending ALL)...\n");
+ Con_DPrintf("Lost frame = %d\n", framenum);
+ Con_DPrintf("Entity DB = %d to %d\n", client->csqcentityframehistory[ringfirst].framenum, client->csqcentityframehistory[ringlast].framenum);
+ EntityFrameCSQC_LostAllFrames(client);
+ }
+ return;
+ }
+
+ // so j is the frame that got lost
+ // ringlast is the frame that we have to go to
+ ringfirst = (ringfirst + j) % NUM_CSQCENTITYDB_FRAMES;
+ if(ringlast < ringfirst)
+ ringlast += NUM_CSQCENTITYDB_FRAMES;
+
+ memset(recoversendflags, 0, sizeof(recoversendflags));
+
+ for(j = ringfirst; j <= ringlast; ++j)
+ {
+ d = &client->csqcentityframehistory[j % NUM_CSQCENTITYDB_FRAMES];
+ if(d->framenum < 0)
+ {
+ // deleted frame
+ }
+ else if(d->framenum < framenum)
+ {
+ // a frame in the past... should never happen
+ Con_Printf("CSQC entity DB encountered a frame from the past when recovering from PL...?\n");
+ }
+ else if(d->framenum == framenum)
+ {
+ // handling the actually lost frame now
+ for(i = 0; i < d->num; ++i)
+ {
+ int sf = d->sendflags[i];
+ int ent = d->entno[i];
+ if(sf < 0) // remove
+ recoversendflags[ent] |= -1; // all bits, including sign
+ else if(sf > 0)
+ recoversendflags[ent] |= sf;
+ }
+ }
+ else
+ {
+ // handling the frames that followed it now
+ for(i = 0; i < d->num; ++i)
+ {
+ int sf = d->sendflags[i];
+ int ent = d->entno[i];
+ if(sf < 0) // remove
+ {
+ recoversendflags[ent] = 0; // no need to update, we got a more recent remove (and will fix it THEN)
+ break; // no flags left to remove...
+ }
+ else if(sf > 0)
+ recoversendflags[ent] &= ~sf; // no need to update these bits, we already got them later
+ }
+ }
+ }
+
+ for(i = 0; i < client->csqcnumedicts; ++i)
+ {
+ if(recoversendflags[i] < 0)
+ {
+ // a remove got lost, then either send a remove or - if it was
+ // recreated later - a FULL update to make totally sure
+ client->csqcentityscope[i] = 1;
+ client->csqcentitysendflags[i] = 0xFFFFFF;
+ }
+ else
+ client->csqcentitysendflags[i] |= recoversendflags[i];
+ }
+}
+static int EntityFrameCSQC_AllocFrame(client_t *client, int framenum)
+{
+ int ringfirst = client->csqcentityframehistory_next; // oldest entry
+ client->csqcentityframehistory_next += 1;
+ client->csqcentityframehistory_next %= NUM_CSQCENTITYDB_FRAMES;
+ client->csqcentityframehistory[ringfirst].framenum = framenum;
+ client->csqcentityframehistory[ringfirst].num = 0;
+ return ringfirst;
+}
+static void EntityFrameCSQC_DeallocFrame(client_t *client, int framenum)
+{
+ int ringfirst = client->csqcentityframehistory_next; // oldest entry
+ int ringlast = (ringfirst + NUM_CSQCENTITYDB_FRAMES - 1) % NUM_CSQCENTITYDB_FRAMES; // most recently added entry
+ if(framenum == client->csqcentityframehistory[ringlast].framenum)
+ {
+ client->csqcentityframehistory[ringlast].framenum = -1;
+ client->csqcentityframehistory[ringlast].num = 0;
+ client->csqcentityframehistory_next = ringlast;
+ }
+ else
+ Con_Printf("Trying to dealloc the wrong entity frame\n");
+}
//[515]: we use only one array per-client for SendEntity feature
-void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numstates, const entity_state_t *states)
+// TODO: add some handling for entity send priorities, to better deal with huge
+// amounts of csqc networked entities
+qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numstates, const entity_state_t *states, int framenum)
{
int num, number, end, sendflags;
qboolean sectionstarted = false;
prvm_edict_t *ed;
prvm_eval_t *val;
client_t *client = svs.clients + sv.writeentitiestoclient_clientnumber;
+ int dbframe = EntityFrameCSQC_AllocFrame(client, framenum);
+ csqcentityframedb_t *db = &client->csqcentityframehistory[dbframe];
+
+ maxsize -= 24; // always fit in an empty svc_entities message (for packet loss detection!)
// if this server progs is not CSQC-aware, return early
if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
- return;
+ return false;
// make sure there is enough room to store the svc_csqcentities byte,
// the terminator (0x0000) and at least one entity update
if (msg->cursize + 32 >= maxsize)
- return;
+ return false;
if (client->csqcnumedicts < prog->num_edicts)
client->csqcnumedicts = prog->num_edicts;
sendflags = client->csqcentitysendflags[number];
if (!sendflags)
continue;
+ if(db->num >= NUM_CSQCENTITIES_PER_FRAME)
+ break;
ed = prog->edicts + number;
// entity scope is either update (2) or remove (1)
if (client->csqcentityscope[number] == 1)
MSG_WriteShort(msg, (unsigned short)number | 0x8000);
client->csqcentityscope[number] = 0;
client->csqcentitysendflags[number] = 0xFFFFFF; // resend completely if it becomes active again
+ db->entno[db->num] = number;
+ db->sendflags[db->num] = -1;
+ db->num += 1;
+ client->csqcentityglobalhistory[number] = 1;
ENTITYSIZEPROFILING_END(msg, number);
}
if (msg->cursize + 17 >= maxsize)
val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
if (val->function)
{
- ENTITYSIZEPROFILING_START(msg, number);
if(!sectionstarted)
MSG_WriteByte(msg, svc_csqcentities);
- MSG_WriteShort(msg, number);
- msg->allowoverflow = true;
- PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
- PRVM_G_FLOAT(OFS_PARM1) = sendflags;
- prog->globals.server->self = number;
- PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
- msg->allowoverflow = false;
- if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
{
- // an update has been successfully written
- client->csqcentitysendflags[number] = 0;
- // and take note that we have begun the svc_csqcentities
- // section of the packet
- sectionstarted = 1;
- if (msg->cursize + 17 >= maxsize)
- break;
- ENTITYSIZEPROFILING_END(msg, number);
- continue;
+ ENTITYSIZEPROFILING_START(msg, number);
+ MSG_WriteShort(msg, number);
+ msg->allowoverflow = true;
+ PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
+ PRVM_G_FLOAT(OFS_PARM1) = sendflags;
+ prog->globals.server->self = number;
+ PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
+ msg->allowoverflow = false;
+ if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
+ {
+ // an update has been successfully written
+ client->csqcentitysendflags[number] = 0;
+ db->entno[db->num] = number;
+ db->sendflags[db->num] = sendflags;
+ db->num += 1;
+ client->csqcentityglobalhistory[number] = 1;
+ // and take note that we have begun the svc_csqcentities
+ // section of the packet
+ sectionstarted = 1;
+ ENTITYSIZEPROFILING_END(msg, number);
+ if (msg->cursize + 17 >= maxsize)
+ break;
+ continue;
+ }
}
}
// self.SendEntity returned false (or does not exist) or the
// write index 0 to end the update (0 is never used by real entities)
MSG_WriteShort(msg, 0);
}
+
+ if(db->num == 0)
+ // if no single ent got added, remove the frame from the DB again, to allow
+ // for a larger history
+ EntityFrameCSQC_DeallocFrame(client, framenum);
+
+ return sectionstarted;
}
void Protocol_UpdateClientStats(const int *stats)
for (i = 0, s = states;i < numstates;i++, s++)
{
+ ENTITYSIZEPROFILING_START(msg, s->number);
val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity);
if(val && val->function)
continue;
SZ_Clear(&buf);
// send an update
- ENTITYSIZEPROFILING_START(msg, s->number);
bits = 0;
if (s->number >= 256)
bits |= U_LONGENTITY;
Mem_Free(d);
}
-void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
+static void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
{
if (d->maxedicts < newmax)
{
}
}
-int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
+static int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
{
int limit, priority;
entity_state_t *s;
void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbits, sizebuf_t *msg)
{
unsigned int bits = 0;
- int startsize;
+ //dp_model_t *model;
ENTITYSIZEPROFILING_START(msg, s->number);
prvm_eval_t *val;
else
{
bits = changedbits;
- if ((bits & E5_ORIGIN) && ((s->flags & RENDER_EXTERIORMODEL) || s->origin[0] <= -4096.0625 || s->origin[0] >= 4095.9375 || s->origin[1] <= -4096.0625 || s->origin[1] >= 4095.9375 || s->origin[2] <= -4096.0625 || s->origin[2] >= 4095.9375))
+ if ((bits & E5_ORIGIN) && (s->exteriormodelforclient || s->tagentity || s->viewmodelforclient || (s->number >= 1 && s->number <= svs.maxclients) || s->origin[0] <= -4096.0625 || s->origin[0] >= 4095.9375 || s->origin[1] <= -4096.0625 || s->origin[1] >= 4095.9375 || s->origin[2] <= -4096.0625 || s->origin[2] >= 4095.9375))
+ // maybe also add: ((model = sv.models[s->modelindex]) != NULL && model->name[0] == '*')
bits |= E5_ORIGIN32;
// possible values:
// negative origin:
ENTITYSIZEPROFILING_END(msg, s->number);
}
-void EntityState5_ReadUpdate(entity_state_t *s, int number)
+static void EntityState5_ReadUpdate(entity_state_t *s, int number)
{
int bits;
bits = MSG_ReadByte();
}
}
-int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t *n)
+static int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t *n)
{
unsigned int bits = 0;
if (n->active)
d->packetlog[i].packetnumber = 0;
}
-void EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int movesequence)
+void EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int movesequence, qboolean need_empty)
{
const entity_state_t *n;
int i, num, l, framenum, packetlognumber, priority;
}
}
- // add packetlog entry
- packetlog = d->packetlog + packetlognumber;
- packetlog->packetnumber = framenum;
- packetlog->numstates = 0;
+ packetlog = NULL;
// write stat updates
if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3 && sv.protocol != PROTOCOL_DARKPLACES1 && sv.protocol != PROTOCOL_DARKPLACES2 && sv.protocol != PROTOCOL_DARKPLACES3 && sv.protocol != PROTOCOL_DARKPLACES4 && sv.protocol != PROTOCOL_DARKPLACES5)
{
if (host_client->statsdeltabits[i>>3] & (1<<(i&7)))
{
host_client->statsdeltabits[i>>3] &= ~(1<<(i&7));
+ // add packetlog entry now that we have something for it
+ if (!packetlog)
+ {
+ packetlog = d->packetlog + packetlognumber;
+ packetlog->packetnumber = framenum;
+ packetlog->numstates = 0;
+ }
packetlog->statsdeltabits[i>>3] |= (1<<(i&7));
if (host_client->stats[i] >= 0 && host_client->stats[i] < 256)
{
MSG_WriteByte(msg, svc_updatestatubyte);
MSG_WriteByte(msg, i);
MSG_WriteByte(msg, host_client->stats[i]);
+ l = 1;
}
else
{
MSG_WriteByte(msg, svc_updatestat);
MSG_WriteByte(msg, i);
MSG_WriteLong(msg, host_client->stats[i]);
+ l = 1;
}
}
}
}
+
+ // only send empty svc_entities frame if needed
+ if(!l && !need_empty)
+ return;
+
+ // add packetlog entry now that we have something for it
+ if (!packetlog)
+ {
+ packetlog = d->packetlog + packetlognumber;
+ packetlog->packetnumber = framenum;
+ packetlog->numstates = 0;
+ }
+
// write state updates
if (developer_networkentities.integer >= 10)
Con_Printf("send: svc_entities %i\n", framenum);