X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=protocol.c;h=aa40970e1e18b8cf76f58693562ccc73c3adf3c7;hp=8367824d98eb3514d0f75060413b6c5a6a715731;hb=397530aecdd5492236e3dc5620ee7126078c07f3;hpb=eca922f8d360b2f8022bf6ccbec2f19cf5250eb2 diff --git a/protocol.c b/protocol.c index 8367824d..aa40970e 100644 --- a/protocol.c +++ b/protocol.c @@ -1,15 +1,19 @@ #include "quakedef.h" -// this is 80 bytes +#define E5_PROTOCOL_PRIORITYLEVELS 32 + +// this is 88 bytes (must match entity_state_t in protocol.h) entity_state_t defaultstate = { // ! means this is not sent to client 0,//double time; // ! time this state was built (used on client for interpolation) + {0,0,0},//float netcenter[3]; // ! for network prioritization, this is the center of the bounding box (which may differ from the origin) {0,0,0},//float origin[3]; {0,0,0},//float angles[3]; 0,//int number; // entity number this state is for 0,//int effects; + 0,//unsigned int customizeentityforclient; // ! 0,//unsigned short modelindex; 0,//unsigned short frame; 0,//unsigned short tagentity; @@ -31,13 +35,14 @@ entity_state_t defaultstate = 0,//unsigned char flags; 0,//unsigned char tagindex; {32, 32, 32},//unsigned char colormod[3]; + 0,//unsigned char internaleffects; // INTEF_FLAG1QW and so on // padding to a multiple of 8 bytes (to align the double time) - {0,0}//unsigned char unused[2]; // ! + 0//unsigned char unused; // ! }; // LordHavoc: I own protocol ranges 96, 97, 3500-3599 -struct +struct protocolversioninfo_s { int number; const char *name; @@ -55,15 +60,27 @@ protocolversioninfo[] = {15, "QUAKEDP"}, {250, "NEHAHRAMOVIE"}, {15, "QUAKE"}, + {28, "QUAKEWORLD"}, {0, NULL} }; +static mempool_t *sv2csqc = NULL; +int csqc_clientnum = 0; +sizebuf_t *sv2csqcbuf = NULL; +static unsigned char *sv2csqcents_version[MAX_SCOREBOARD]; + +static entity_frame_t deltaframe; // FIXME? +static entity_frame_t framedata; // FIXME? + +int entityframe5_prioritychaincounts[E5_PROTOCOL_PRIORITYLEVELS]; +unsigned short entityframe5_prioritychains[E5_PROTOCOL_PRIORITYLEVELS][ENTITYFRAME5_MAXSTATES]; + protocolversion_t Protocol_EnumForName(const char *s) { int i; for (i = 1;protocolversioninfo[i].name;i++) if (!strcasecmp(s, protocolversioninfo[i].name)) - return i; + return (protocolversion_t)i; return PROTOCOL_UNKNOWN; } @@ -77,7 +94,7 @@ protocolversion_t Protocol_EnumForNumber(int n) int i; for (i = 1;protocolversioninfo[i].name;i++) if (protocolversioninfo[i].number == n) - return i; + return (protocolversion_t)i; return PROTOCOL_UNKNOWN; } @@ -100,10 +117,6 @@ void Protocol_Names(char *buffer, size_t buffersize) } } -// keep track of quake entities because they need to be killed if they get stale -int cl_lastquakeentity = 0; -qbyte cl_isquakeentity[MAX_EDICTS]; - void EntityFrameQuake_ReadEntity(int bits) { int num; @@ -112,7 +125,7 @@ void EntityFrameQuake_ReadEntity(int bits) if (bits & U_MOREBITS) bits |= (MSG_ReadByte()<<8); - if ((bits & U_EXTEND1) && cl.protocol != PROTOCOL_NEHAHRAMOVIE) + if ((bits & U_EXTEND1) && cls.protocol != PROTOCOL_NEHAHRAMOVIE) { bits |= MSG_ReadByte() << 16; if (bits & U_EXTEND2) @@ -125,18 +138,18 @@ void EntityFrameQuake_ReadEntity(int bits) num = MSG_ReadByte (); if (num >= MAX_EDICTS) - Host_Error("EntityFrameQuake_ReadEntity: entity number (%i) >= MAX_EDICTS (%i)\n", num, MAX_EDICTS); + Host_Error("EntityFrameQuake_ReadEntity: entity number (%i) >= MAX_EDICTS (%i)", num, MAX_EDICTS); if (num < 1) - Host_Error("EntityFrameQuake_ReadEntity: invalid entity number (%i)\n", num); + Host_Error("EntityFrameQuake_ReadEntity: invalid entity number (%i)", num); - if (cl_num_entities <= num) + if (cl.num_entities <= num) { - cl_num_entities = num + 1; - if (num >= cl_max_entities) + cl.num_entities = num + 1; + if (num >= cl.max_entities) CL_ExpandEntities(num); } - ent = cl_entities + num; + ent = cl.entities + num; // note: this inherits the 'active' state of the baseline chosen // (state_baseline is always active, state_current may not be active if @@ -149,9 +162,9 @@ void EntityFrameQuake_ReadEntity(int bits) s.active = true; } - cl_isquakeentity[num] = true; - if (cl_lastquakeentity < num) - cl_lastquakeentity = num; + cl.isquakeentity[num] = true; + if (cl.lastquakeentity < num) + cl.lastquakeentity = num; s.number = num; s.time = cl.mtime[0]; s.flags = 0; @@ -160,19 +173,19 @@ void EntityFrameQuake_ReadEntity(int bits) if (bits & U_COLORMAP) s.colormap = MSG_ReadByte(); if (bits & U_SKIN) s.skin = MSG_ReadByte(); if (bits & U_EFFECTS) s.effects = (s.effects & 0xFF00) | MSG_ReadByte(); - if (bits & U_ORIGIN1) s.origin[0] = MSG_ReadCoord(cl.protocol); - if (bits & U_ANGLE1) s.angles[0] = MSG_ReadAngle(cl.protocol); - if (bits & U_ORIGIN2) s.origin[1] = MSG_ReadCoord(cl.protocol); - if (bits & U_ANGLE2) s.angles[1] = MSG_ReadAngle(cl.protocol); - if (bits & U_ORIGIN3) s.origin[2] = MSG_ReadCoord(cl.protocol); - if (bits & U_ANGLE3) s.angles[2] = MSG_ReadAngle(cl.protocol); + if (bits & U_ORIGIN1) s.origin[0] = MSG_ReadCoord(cls.protocol); + if (bits & U_ANGLE1) s.angles[0] = MSG_ReadAngle(cls.protocol); + if (bits & U_ORIGIN2) s.origin[1] = MSG_ReadCoord(cls.protocol); + if (bits & U_ANGLE2) s.angles[1] = MSG_ReadAngle(cls.protocol); + if (bits & U_ORIGIN3) s.origin[2] = MSG_ReadCoord(cls.protocol); + if (bits & U_ANGLE3) s.angles[2] = MSG_ReadAngle(cls.protocol); if (bits & U_STEP) s.flags |= RENDER_STEP; if (bits & U_ALPHA) s.alpha = MSG_ReadByte(); if (bits & U_SCALE) s.scale = MSG_ReadByte(); if (bits & U_EFFECTS2) s.effects = (s.effects & 0x00FF) | (MSG_ReadByte() << 8); if (bits & U_GLOWSIZE) s.glowsize = MSG_ReadByte(); if (bits & U_GLOWCOLOR) s.glowcolor = MSG_ReadByte(); - if (bits & U_COLORMOD) {int c = MSG_ReadByte();s.colormod[0] = (qbyte)(((c >> 5) & 7) * (32.0f / 7.0f));s.colormod[1] = (qbyte)(((c >> 2) & 7) * (32.0f / 7.0f));s.colormod[2] = (qbyte)((c & 3) * (32.0f / 3.0f));} + if (bits & U_COLORMOD) {int c = MSG_ReadByte();s.colormod[0] = (unsigned char)(((c >> 5) & 7) * (32.0f / 7.0f));s.colormod[1] = (unsigned char)(((c >> 2) & 7) * (32.0f / 7.0f));s.colormod[2] = (unsigned char)((c & 3) * (32.0f / 3.0f));} if (bits & U_GLOWTRAIL) s.flags |= RENDER_GLOWTRAIL; if (bits & U_FRAME2) s.frame = (s.frame & 0x00FF) | (MSG_ReadByte() << 8); if (bits & U_MODEL2) s.modelindex = (s.modelindex & 0x00FF) | (MSG_ReadByte() << 8); @@ -180,14 +193,14 @@ void EntityFrameQuake_ReadEntity(int bits) if (bits & U_EXTERIORMODEL) s.flags |= RENDER_EXTERIORMODEL; // LordHavoc: to allow playback of the Nehahra movie - if (cl.protocol == PROTOCOL_NEHAHRAMOVIE && (bits & U_EXTEND1)) + if (cls.protocol == PROTOCOL_NEHAHRAMOVIE && (bits & U_EXTEND1)) { // LordHavoc: evil format - int i = MSG_ReadFloat(); - int j = MSG_ReadFloat() * 255.0f; + int i = (int)MSG_ReadFloat(); + int j = (int)(MSG_ReadFloat() * 255.0f); if (i == 2) { - i = MSG_ReadFloat(); + i = (int)MSG_ReadFloat(); if (i) s.effects |= EF_FULLBRIGHT; } @@ -204,47 +217,267 @@ void EntityFrameQuake_ReadEntity(int bits) if (ent->state_current.active) { CL_MoveLerpEntityStates(ent); - cl_entities_active[ent->state_current.number] = true; + cl.entities_active[ent->state_current.number] = true; } if (msg_badread) - Host_Error("EntityFrameQuake_ReadEntity: read error\n"); + Host_Error("EntityFrameQuake_ReadEntity: read error"); } void EntityFrameQuake_ISeeDeadEntities(void) { int num, lastentity; - if (cl_lastquakeentity == 0) + if (cl.lastquakeentity == 0) return; - lastentity = cl_lastquakeentity; - cl_lastquakeentity = 0; + lastentity = cl.lastquakeentity; + cl.lastquakeentity = 0; for (num = 0;num <= lastentity;num++) { - if (cl_isquakeentity[num]) + if (cl.isquakeentity[num]) + { + if (cl.entities_active[num] && cl.entities[num].state_current.time == cl.mtime[0]) + { + cl.isquakeentity[num] = true; + cl.lastquakeentity = num; + } + else + { + cl.isquakeentity[num] = false; + cl.entities_active[num] = false; + cl.entities[num].state_current = defaultstate; + cl.entities[num].state_current.number = num; + } + } + } +} + +void EntityFrameCSQC_ClearVersions (void) +{ + if(sv2csqc) + { + Mem_FreePool(&sv2csqc); + sv2csqc = NULL; + } + memset(sv2csqcents_version, 0, MAX_SCOREBOARD*sizeof(unsigned char *)); +} + +void EntityFrameCSQC_InitClientVersions (int client, qboolean clear) +{ + if(!sv2csqc) + sv2csqc = Mem_AllocPool("SV2CSQC", 0, NULL); + if(sv2csqcents_version[client]) + { + Mem_Free(sv2csqcents_version[client]); + sv2csqcents_version[client] = NULL; + } + sv2csqcents_version[client] = (unsigned char *)Mem_Alloc(sv2csqc, MAX_EDICTS); + memset(sv2csqcents_version[client], 0, MAX_EDICTS); +} + +// 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. + +void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, qboolean *sectionstarted) +{ + int version; + prvm_eval_t *val, *val2; + version = 0; + if (doupdate) + { + if (msg->cursize + !*sectionstarted + 2 + 1 + 2 > msg->maxsize) + return; + val2 = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.Version); + version = (int)val2->_float; + // LordHavoc: do some validity checks on self.Version + // if Version reaches 8388608, it has already exhausted half of the + // reliable integer space in a 32bit float, and should be reset to 1 + // FIXME: we should set all client versions of this entity to -1 + // so that it will not be skipped accidentally in some cases after + // the reset + if (version < 0) + val2->_float = 0; + if (version >= 8388608) + { + int i; + val2->_float = 1; + // since we just reset the Version field to 1, it may accidentally + // end up being equal to an existing client version now or in the + // future, so to fix this situation we have to loop over all + // clients and change their versions for this entity to be -1 + // which never matches, thus causing them to receive the update + // soon, as they should + for (i = 0;i < svs.maxclients;i++) + if (sv2csqcents_version[i] && sv2csqcents_version[i][number]) + sv2csqcents_version[i][number] = -1; + } + } + // if the version already matches, we don't need to do anything as the + // latest version has already been sent. + if (sv2csqcents_version[csqc_clientnum][number] == version) + return; + if (version) + { + // if there's no SendEntity function, treat it as a remove + val = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.SendEntity); + if (val->function) + { + // there is a function to call, save the cursize value incase we + // have to do a rollback due to overflow + int oldcursize = msg->cursize; + if(!*sectionstarted) + MSG_WriteByte(msg, svc_csqcentities); + MSG_WriteShort(msg, number); + ((int *)prog->globals.generic)[OFS_PARM0] = csqc_clientnum+1; + prog->globals.server->self = number; + PRVM_ExecuteProgram(val->function, "Null SendEntity\n"); + if(prog->globals.generic[OFS_RETURN]) + { + if (msg->cursize + 2 > msg->maxsize) + { + // if the packet no longer has enough room to write the + // final index code that ends the message, rollback to the + // state before we tried to write anything and then return + msg->cursize = oldcursize; + msg->overflowed = false; + return; + } + // an update has been successfully written, update the version + sv2csqcents_version[csqc_clientnum][number] = version; + // and take note that we have begun the svc_csqcentities + // section of the packet + *sectionstarted = 1; + return; + } + else + { + // rollback the buffer to its state before the writes + msg->cursize = oldcursize; + // if the function returned FALSE, simply write a remove + // this is done by falling through to the remove code below + version = 0; + } + } + } + // write a remove message if needed + // if already removed, do nothing + if (!sv2csqcents_version[csqc_clientnum][number]) + return; + // if there isn't enough room to write the remove message, just return, as + // it will be handled in a later packet + if (msg->cursize + !*sectionstarted + 2 + 2 > msg->maxsize) + return; + // first write the message identifier if needed + if(!*sectionstarted) + { + *sectionstarted = 1; + MSG_WriteByte(msg, svc_csqcentities); + } + // write the remove message + MSG_WriteShort(msg, (unsigned short)number | 0x8000); + sv2csqcents_version[csqc_clientnum][number] = 0; +} + +//[515]: we use only one array per-client for SendEntity feature +void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states) +{ + int i, num; + qboolean sectionstarted = false; + const entity_state_t *n; + + // if this server progs is not CSQC-aware, return early + if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0) + return; + // 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 >= msg->maxsize) + return; + if(!sv2csqcents_version[csqc_clientnum]) + EntityFrameCSQC_InitClientVersions(csqc_clientnum, false); + + sv2csqcbuf = msg; + num = 1; + for (i = 0, n = states;i < numstates;i++, n++) + { + // all entities between the previous entity state and this one are dead + for (;num < n->number;num++) + if(sv2csqcents_version[csqc_clientnum][num]) + EntityFrameCSQC_WriteState(msg, num, false, §ionstarted); + // update this entity + EntityFrameCSQC_WriteState(msg, num, true, §ionstarted); + // advance to next entity so the next iteration doesn't immediately remove it + num++; + } + // all remaining entities are dead + for (;num < prog->num_edicts;num++) + if(sv2csqcents_version[csqc_clientnum][num]) + EntityFrameCSQC_WriteState(msg, num, false, §ionstarted); + if (sectionstarted) + { + // write index 0 to end the update (0 is never used by real entities) + MSG_WriteShort(msg, 0); + } + sv2csqcbuf = NULL; +} + +void Protocol_UpdateClientStats(const int *stats) +{ + int i; + // update the stats array and set deltabits for any changed stats + for (i = 0;i < MAX_CL_STATS;i++) + { + if (host_client->stats[i] != stats[i]) { - if (cl_entities_active[num] && cl_entities[num].state_current.time == cl.mtime[0]) + host_client->statsdeltabits[i >> 3] |= 1 << (i & 7); + host_client->stats[i] = stats[i]; + } + } +} + +void Protocol_WriteStatsReliable(void) +{ + int i; + if (!host_client->netconnection) + return; + // detect changes in stats and write reliable messages + for (i = 0;i < MAX_CL_STATS;i++) + { + // quickly skip zero bytes + if (!host_client->statsdeltabits[i >> 3]) + { + i |= 7; + continue; + } + // check if this bit is set + if (host_client->statsdeltabits[i >> 3] & (1 << (i & 7))) + { + host_client->statsdeltabits[i >> 3] -= (1 << (i & 7)); + // send the stat as a byte if possible + if (host_client->stats[i] >= 0 && host_client->stats[i] < 256) { - cl_isquakeentity[num] = true; - cl_lastquakeentity = num; + MSG_WriteByte(&host_client->netconnection->message, svc_updatestatubyte); + MSG_WriteByte(&host_client->netconnection->message, i); + MSG_WriteByte(&host_client->netconnection->message, host_client->stats[i]); } else { - cl_isquakeentity[num] = false; - cl_entities_active[num] = false; - cl_entities[num].state_current = defaultstate; - cl_entities[num].state_current.number = num; + MSG_WriteByte(&host_client->netconnection->message, svc_updatestat); + MSG_WriteByte(&host_client->netconnection->message, i); + MSG_WriteLong(&host_client->netconnection->message, host_client->stats[i]); } } } } + void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_state_t *states) { const entity_state_t *s; entity_state_t baseline; int i, bits; sizebuf_t buf; - qbyte data[128]; + unsigned char data[128]; + prvm_eval_t *val; // prepare the buffer memset(&buf, 0, sizeof(buf)); @@ -253,6 +486,10 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta for (i = 0, s = states;i < numstates;i++, s++) { + val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity); + if(val && val->function) + continue; + // prepare the buffer SZ_Clear(&buf); @@ -270,7 +507,7 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta bits |= U_EXTERIORMODEL; // LordHavoc: old stuff, but rewritten to have more exact tolerances - baseline = sv.edicts[s->number].e->baseline; + baseline = prog->edicts[s->number].priv.server->baseline; if (baseline.origin[0] != s->origin[0]) bits |= U_ORIGIN1; if (baseline.origin[1] != s->origin[1]) @@ -353,7 +590,7 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta if (bits & U_EFFECTS2) MSG_WriteByte(&buf, s->effects >> 8); if (bits & U_GLOWSIZE) MSG_WriteByte(&buf, s->glowsize); if (bits & U_GLOWCOLOR) MSG_WriteByte(&buf, s->glowcolor); - if (bits & U_COLORMOD) {int c = ((int)bound(0, s->colormod[0] * (7.0f / 32.0f), 7) << 5) | ((int)bound(0, s->colormod[0] * (7.0f / 32.0f), 7) << 2) | ((int)bound(0, s->colormod[0] * (3.0f / 32.0f), 3) << 0);MSG_WriteByte(&buf, c);} + if (bits & U_COLORMOD) {int c = ((int)bound(0, s->colormod[0] * (7.0f / 32.0f), 7) << 5) | ((int)bound(0, s->colormod[1] * (7.0f / 32.0f), 7) << 2) | ((int)bound(0, s->colormod[2] * (3.0f / 32.0f), 3) << 0);MSG_WriteByte(&buf, c);} if (bits & U_FRAME2) MSG_WriteByte(&buf, s->frame >> 8); if (bits & U_MODEL2) MSG_WriteByte(&buf, s->modelindex >> 8); @@ -397,11 +634,11 @@ int EntityState_DeltaBits(const entity_state_t *o, const entity_state_t *n) bits |= E_ORIGIN2; if (fabs(n->origin[2] - o->origin[2]) > (1.0f / 256.0f)) bits |= E_ORIGIN3; - if ((qbyte) (n->angles[0] * (256.0f / 360.0f)) != (qbyte) (o->angles[0] * (256.0f / 360.0f))) + if ((unsigned char) (n->angles[0] * (256.0f / 360.0f)) != (unsigned char) (o->angles[0] * (256.0f / 360.0f))) bits |= E_ANGLE1; - if ((qbyte) (n->angles[1] * (256.0f / 360.0f)) != (qbyte) (o->angles[1] * (256.0f / 360.0f))) + if ((unsigned char) (n->angles[1] * (256.0f / 360.0f)) != (unsigned char) (o->angles[1] * (256.0f / 360.0f))) bits |= E_ANGLE2; - if ((qbyte) (n->angles[2] * (256.0f / 360.0f)) != (qbyte) (o->angles[2] * (256.0f / 360.0f))) + if ((unsigned char) (n->angles[2] * (256.0f / 360.0f)) != (unsigned char) (o->angles[2] * (256.0f / 360.0f))) bits |= E_ANGLE3; if ((n->modelindex ^ o->modelindex) & 0x00FF) bits |= E_MODEL1; @@ -607,7 +844,7 @@ int EntityState_ReadExtendBits(void) void EntityState_ReadFields(entity_state_t *e, unsigned int bits) { - if (cl.protocol == PROTOCOL_DARKPLACES2) + if (cls.protocol == PROTOCOL_DARKPLACES2) { if (bits & E_ORIGIN1) e->origin[0] = MSG_ReadCoord16i(); @@ -639,23 +876,23 @@ void EntityState_ReadFields(entity_state_t *e, unsigned int bits) e->origin[2] = MSG_ReadCoord32f(); } } - if ((cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4) && (e->flags & RENDER_LOWPRECISION)) + if ((cls.protocol == PROTOCOL_DARKPLACES5 || cls.protocol == PROTOCOL_DARKPLACES6) && !(e->flags & RENDER_LOWPRECISION)) { if (bits & E_ANGLE1) - e->angles[0] = MSG_ReadAngle8i(); + e->angles[0] = MSG_ReadAngle16i(); if (bits & E_ANGLE2) - e->angles[1] = MSG_ReadAngle8i(); + e->angles[1] = MSG_ReadAngle16i(); if (bits & E_ANGLE3) - e->angles[2] = MSG_ReadAngle8i(); + e->angles[2] = MSG_ReadAngle16i(); } else { if (bits & E_ANGLE1) - e->angles[0] = MSG_ReadAngle16i(); + e->angles[0] = MSG_ReadAngle8i(); if (bits & E_ANGLE2) - e->angles[1] = MSG_ReadAngle16i(); + e->angles[1] = MSG_ReadAngle8i(); if (bits & E_ANGLE3) - e->angles[2] = MSG_ReadAngle16i(); + e->angles[2] = MSG_ReadAngle8i(); } if (bits & E_MODEL1) e->modelindex = (e->modelindex & 0xFF00) | (unsigned int) MSG_ReadByte(); @@ -681,7 +918,7 @@ void EntityState_ReadFields(entity_state_t *e, unsigned int bits) e->glowsize = MSG_ReadByte(); if (bits & E_GLOWCOLOR) e->glowcolor = MSG_ReadByte(); - if (cl.protocol == PROTOCOL_DARKPLACES2) + if (cls.protocol == PROTOCOL_DARKPLACES2) if (bits & E_FLAGS) e->flags = MSG_ReadByte(); if (bits & E_TAGATTACHMENT) @@ -754,7 +991,7 @@ void EntityState_ReadFields(entity_state_t *e, unsigned int bits) // (client and server) allocates a new empty database entityframe_database_t *EntityFrame_AllocDatabase(mempool_t *mempool) { - return Mem_Alloc(mempool, sizeof(entityframe_database_t)); + return (entityframe_database_t *)Mem_Alloc(mempool, sizeof(entityframe_database_t)); } // (client and server) frees the database @@ -869,13 +1106,13 @@ void EntityFrame_AddFrame(entityframe_database_t *d, vec3_t eye, int framenum, i } // (server) writes a frame to network stream -static entity_frame_t deltaframe; // FIXME? void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numstates, const entity_state_t *states, int viewentnum) { int i, onum, number; entity_frame_t *o = &deltaframe; const entity_state_t *ent, *delta; vec3_t eye; + prvm_eval_t *val; d->latestframenum++; @@ -905,6 +1142,10 @@ void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numst { ent = states + i; number = ent->number; + + val = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.SendEntity); + if(val && val->function) + continue; for (;onum < o->numentities && o->entitydata[onum].number < number;onum++) { // write remove message @@ -933,7 +1174,6 @@ void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numst } // (client) reads a frame from network stream -static entity_frame_t framedata; // FIXME? void EntityFrame_CL_ReadFrame(void) { int i, number, removed; @@ -942,7 +1182,7 @@ void EntityFrame_CL_ReadFrame(void) entity_t *ent; entityframe_database_t *d; if (!cl.entitydatabase) - cl.entitydatabase = EntityFrame_AllocDatabase(cl_mempool); + cl.entitydatabase = EntityFrame_AllocDatabase(cls.levelmempool); d = cl.entitydatabase; EntityFrame_Clear(f, NULL, -1); @@ -964,17 +1204,17 @@ void EntityFrame_CL_ReadFrame(void) while ((number = (unsigned short) MSG_ReadShort()) != 0xFFFF && !msg_badread) { if (msg_badread) - Host_Error("EntityFrame_Read: read error\n"); + Host_Error("EntityFrame_Read: read error"); removed = number & 0x8000; number &= 0x7FFF; if (number >= MAX_EDICTS) - Host_Error("EntityFrame_Read: number (%i) >= MAX_EDICTS (%i)\n", number, MAX_EDICTS); + Host_Error("EntityFrame_Read: number (%i) >= MAX_EDICTS (%i)", number, MAX_EDICTS); // seek to entity, while copying any skipped entities (assume unchanged) while (old < oldend && old->number < number) { if (f->numentities >= MAX_ENTITY_DATABASE) - Host_Error("EntityFrame_Read: entity list too big\n"); + Host_Error("EntityFrame_Read: entity list too big"); f->entitydata[f->numentities] = *old++; f->entitydata[f->numentities++].time = cl.mtime[0]; } @@ -988,7 +1228,7 @@ void EntityFrame_CL_ReadFrame(void) else { if (f->numentities >= MAX_ENTITY_DATABASE) - Host_Error("EntityFrame_Read: entity list too big\n"); + Host_Error("EntityFrame_Read: entity list too big"); // reserve this slot e = f->entitydata + f->numentities++; @@ -1004,13 +1244,13 @@ void EntityFrame_CL_ReadFrame(void) *e = defaultstate; } - if (cl_num_entities <= number) + if (cl.num_entities <= number) { - cl_num_entities = number + 1; - if (number >= cl_max_entities) + cl.num_entities = number + 1; + if (number >= cl.max_entities) CL_ExpandEntities(number); } - cl_entities_active[number] = true; + cl.entities_active[number] = true; e->active = true; e->time = cl.mtime[0]; e->number = number; @@ -1020,41 +1260,41 @@ void EntityFrame_CL_ReadFrame(void) while (old < oldend) { if (f->numentities >= MAX_ENTITY_DATABASE) - Host_Error("EntityFrame_Read: entity list too big\n"); + Host_Error("EntityFrame_Read: entity list too big"); f->entitydata[f->numentities] = *old++; f->entitydata[f->numentities++].time = cl.mtime[0]; } EntityFrame_AddFrame(d, f->eye, f->framenum, f->numentities, f->entitydata); - memset(cl_entities_active, 0, cl_num_entities * sizeof(qbyte)); + memset(cl.entities_active, 0, cl.num_entities * sizeof(unsigned char)); number = 1; for (i = 0;i < f->numentities;i++) { - for (;number < f->entitydata[i].number && number < cl_num_entities;number++) + for (;number < f->entitydata[i].number && number < cl.num_entities;number++) { - if (cl_entities_active[number]) + if (cl.entities_active[number]) { - cl_entities_active[number] = false; - cl_entities[number].state_current.active = false; + cl.entities_active[number] = false; + cl.entities[number].state_current.active = false; } } - if (number >= cl_num_entities) + if (number >= cl.num_entities) break; // update the entity - ent = &cl_entities[number]; + ent = &cl.entities[number]; ent->state_previous = ent->state_current; ent->state_current = f->entitydata[i]; CL_MoveLerpEntityStates(ent); // the entity lives again... - cl_entities_active[number] = true; + cl.entities_active[number] = true; number++; } - for (;number < cl_num_entities;number++) + for (;number < cl.num_entities;number++) { - if (cl_entities_active[number]) + if (cl.entities_active[number]) { - cl_entities_active[number] = false; - cl_entities[number].state_current.active = false; + cl.entities_active[number] = false; + cl.entities[number].state_current.active = false; } } } @@ -1081,7 +1321,7 @@ entity_state_t *EntityFrame4_GetReferenceEntity(entityframe4_database_t *d, int int oldmax = d->maxreferenceentities; entity_state_t *oldentity = d->referenceentity; d->maxreferenceentities = (number + 15) & ~7; - d->referenceentity = Mem_Alloc(d->mempool, d->maxreferenceentities * sizeof(*d->referenceentity)); + d->referenceentity = (entity_state_t *)Mem_Alloc(d->mempool, d->maxreferenceentities * sizeof(*d->referenceentity)); if (oldentity) { memcpy(d->referenceentity, oldentity, oldmax * sizeof(*d->referenceentity)); @@ -1104,7 +1344,7 @@ void EntityFrame4_AddCommitEntity(entityframe4_database_t *d, const entity_state { entity_state_t *oldentity = d->currentcommit->entity; d->currentcommit->maxentities += 8; - d->currentcommit->entity = Mem_Alloc(d->mempool, d->currentcommit->maxentities * sizeof(*d->currentcommit->entity)); + d->currentcommit->entity = (entity_state_t *)Mem_Alloc(d->mempool, d->currentcommit->maxentities * sizeof(*d->currentcommit->entity)); if (oldentity) { memcpy(d->currentcommit->entity, oldentity, d->currentcommit->numentities * sizeof(*d->currentcommit->entity)); @@ -1117,7 +1357,7 @@ void EntityFrame4_AddCommitEntity(entityframe4_database_t *d, const entity_state entityframe4_database_t *EntityFrame4_AllocDatabase(mempool_t *pool) { entityframe4_database_t *d; - d = Mem_Alloc(pool, sizeof(*d)); + d = (entityframe4_database_t *)Mem_Alloc(pool, sizeof(*d)); d->mempool = pool; EntityFrame4_ResetDatabase(d); return d; @@ -1212,7 +1452,7 @@ void EntityFrame4_CL_ReadFrame(void) entity_state_t *s; entityframe4_database_t *d; if (!cl.entitydatabase4) - cl.entitydatabase4 = EntityFrame4_AllocDatabase(cl_mempool); + cl.entitydatabase4 = EntityFrame4_AllocDatabase(cls.levelmempool); d = cl.entitydatabase4; // read the number of the frame this refers to referenceframenum = MSG_ReadLong(); @@ -1222,7 +1462,7 @@ void EntityFrame4_CL_ReadFrame(void) cl.latestframenums[LATESTFRAMENUMS-1] = framenum = MSG_ReadLong(); // read the start number enumber = (unsigned short) MSG_ReadShort(); - if (developer_networkentities.integer >= 1) + if (developer_networkentities.integer >= 10) { Con_Printf("recv svc_entities num:%i ref:%i database: ref:%i commits:", framenum, referenceframenum, d->referenceframenum); for (i = 0;i < MAX_ENTITY_HISTORY;i++) @@ -1267,10 +1507,10 @@ void EntityFrame4_CL_ReadFrame(void) // high bit means it's a remove message cnumber = n & 0x7FFF; // if this is a live entity we may need to expand the array - if (cl_num_entities <= cnumber && !(n & 0x8000)) + if (cl.num_entities <= cnumber && !(n & 0x8000)) { - cl_num_entities = cnumber + 1; - if (cnumber >= cl_max_entities) + cl.num_entities = cnumber + 1; + if (cnumber >= cl.max_entities) CL_ExpandEntities(cnumber); } // add one (the changed one) if not done @@ -1278,7 +1518,7 @@ void EntityFrame4_CL_ReadFrame(void) // process entities in range from the last one to the changed one for (;enumber < stopnumber;enumber++) { - if (skip || enumber >= cl_num_entities) + if (skip || enumber >= cl.num_entities) { if (enumber == cnumber && (n & 0x8000) == 0) { @@ -1288,10 +1528,10 @@ void EntityFrame4_CL_ReadFrame(void) continue; } // slide the current into the previous slot - cl_entities[enumber].state_previous = cl_entities[enumber].state_current; + cl.entities[enumber].state_previous = cl.entities[enumber].state_current; // copy a new current from reference database - cl_entities[enumber].state_current = *EntityFrame4_GetReferenceEntity(d, enumber); - s = &cl_entities[enumber].state_current; + cl.entities[enumber].state_current = *EntityFrame4_GetReferenceEntity(d, enumber); + s = &cl.entities[enumber].state_current; // if this is the one to modify, read more data... if (enumber == cnumber) { @@ -1313,24 +1553,24 @@ void EntityFrame4_CL_ReadFrame(void) } else if (developer_networkentities.integer >= 4) Con_Printf("entity %i: copy\n", enumber); - // set the cl_entities_active flag - cl_entities_active[enumber] = s->active; + // set the cl.entities_active flag + cl.entities_active[enumber] = s->active; // set the update time s->time = cl.mtime[0]; // fix the number (it gets wiped occasionally by copying from defaultstate) s->number = enumber; // check if we need to update the lerp stuff if (s->active) - CL_MoveLerpEntityStates(&cl_entities[enumber]); + CL_MoveLerpEntityStates(&cl.entities[enumber]); // add this to the commit entry whether it is modified or not if (d->currentcommit) - EntityFrame4_AddCommitEntity(d, &cl_entities[enumber].state_current); + EntityFrame4_AddCommitEntity(d, &cl.entities[enumber].state_current); // print extra messages if desired - if (developer_networkentities.integer >= 2 && cl_entities[enumber].state_current.active != cl_entities[enumber].state_previous.active) + if (developer_networkentities.integer >= 2 && cl.entities[enumber].state_current.active != cl.entities[enumber].state_previous.active) { - if (cl_entities[enumber].state_current.active) + if (cl.entities[enumber].state_current.active) Con_Printf("entity #%i has become active\n", enumber); - else if (cl_entities[enumber].state_previous.active) + else if (cl.entities[enumber].state_previous.active) Con_Printf("entity #%i has become inactive\n", enumber); } } @@ -1346,7 +1586,8 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num entity_state_t inactiveentitystate; int i, n, startnumber; sizebuf_t buf; - qbyte data[128]; + unsigned char data[128]; + prvm_eval_t *val; // if there isn't enough space to accomplish anything, skip it if (msg->cursize + 24 > msg->maxsize) @@ -1373,7 +1614,7 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num MSG_WriteByte(msg, svc_entities); MSG_WriteLong(msg, d->referenceframenum); MSG_WriteLong(msg, d->currentcommit->framenum); - if (developer_networkentities.integer >= 1) + if (developer_networkentities.integer >= 10) { Con_Printf("send svc_entities num:%i ref:%i (database: ref:%i commits:", d->currentcommit->framenum, d->referenceframenum, d->referenceframenum); for (i = 0;i < MAX_ENTITY_HISTORY;i++) @@ -1381,16 +1622,19 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num Con_Printf(" %i", d->commit[i].framenum); Con_Print(")\n"); } - if (d->currententitynumber >= sv.max_edicts) + if (d->currententitynumber >= prog->max_edicts) startnumber = 1; else - startnumber = bound(1, d->currententitynumber, sv.max_edicts - 1); + startnumber = bound(1, d->currententitynumber, prog->max_edicts - 1); MSG_WriteShort(msg, startnumber); // reset currententitynumber so if the loop does not break it we will // start at beginning next frame (if it does break, it will set it) d->currententitynumber = 1; - for (i = 0, n = startnumber;n < sv.max_edicts;n++) + for (i = 0, n = startnumber;n < prog->max_edicts;n++) { + val = PRVM_EDICTFIELDVALUE((&prog->edicts[n]), prog->fieldoffsets.SendEntity); + if(val && val->function) + continue; // find the old state to delta from e = EntityFrame4_GetReferenceEntity(d, n); // prepare the buffer @@ -1443,13 +1687,14 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num -#define E5_PROTOCOL_PRIORITYLEVELS 32 - entityframe5_database_t *EntityFrame5_AllocDatabase(mempool_t *pool) { + int i; entityframe5_database_t *d; - d = Mem_Alloc(pool, sizeof(*d)); - EntityFrame5_ResetDatabase(d); + d = (entityframe5_database_t *)Mem_Alloc(pool, sizeof(*d)); + d->latestframenum = 0; + for (i = 0;i < d->maxedicts;i++) + d->states[i] = defaultstate; return d; } @@ -1462,40 +1707,31 @@ void EntityFrame5_FreeDatabase(entityframe5_database_t *d) Mem_Free(d); } -void EntityFrame5_ResetDatabase(entityframe5_database_t *d) -{ - int i; - memset(d, 0, sizeof(*d)); - d->latestframenum = 0; - for (i = 0;i < d->maxedicts;i++) - d->states[i] = defaultstate; -} - void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax) { if (d->maxedicts < newmax) { - qbyte *data; + unsigned char *data; int oldmaxedicts = d->maxedicts; int *olddeltabits = d->deltabits; - qbyte *oldpriorities = d->priorities; + unsigned char *oldpriorities = d->priorities; int *oldupdateframenum = d->updateframenum; entity_state_t *oldstates = d->states; - qbyte *oldvisiblebits = d->visiblebits; + unsigned char *oldvisiblebits = d->visiblebits; d->maxedicts = newmax; - data = Mem_Alloc(sv_mempool, d->maxedicts * sizeof(int) + d->maxedicts * sizeof(qbyte) + d->maxedicts * sizeof(int) + d->maxedicts * sizeof(entity_state_t) + (d->maxedicts+7)/8 * sizeof(qbyte)); - d->deltabits = (void *)data;data += d->maxedicts * sizeof(int); - d->priorities = (void *)data;data += d->maxedicts * sizeof(qbyte); - d->updateframenum = (void *)data;data += d->maxedicts * sizeof(int); - d->states = (void *)data;data += d->maxedicts * sizeof(entity_state_t); - d->visiblebits = (void *)data;data += (d->maxedicts+7)/8 * sizeof(qbyte); + data = (unsigned char *)Mem_Alloc(sv_mempool, d->maxedicts * sizeof(int) + d->maxedicts * sizeof(unsigned char) + d->maxedicts * sizeof(int) + d->maxedicts * sizeof(entity_state_t) + (d->maxedicts+7)/8 * sizeof(unsigned char)); + d->deltabits = (int *)data;data += d->maxedicts * sizeof(int); + d->priorities = (unsigned char *)data;data += d->maxedicts * sizeof(unsigned char); + d->updateframenum = (int *)data;data += d->maxedicts * sizeof(int); + d->states = (entity_state_t *)data;data += d->maxedicts * sizeof(entity_state_t); + d->visiblebits = (unsigned char *)data;data += (d->maxedicts+7)/8 * sizeof(unsigned char); if (oldmaxedicts) { memcpy(d->deltabits, olddeltabits, oldmaxedicts * sizeof(int)); - memcpy(d->priorities, oldpriorities, oldmaxedicts * sizeof(qbyte)); + memcpy(d->priorities, oldpriorities, oldmaxedicts * sizeof(unsigned char)); memcpy(d->updateframenum, oldupdateframenum, oldmaxedicts * sizeof(int)); memcpy(d->states, oldstates, oldmaxedicts * sizeof(entity_state_t)); - memcpy(d->visiblebits, oldvisiblebits, (oldmaxedicts+7)/8 * sizeof(qbyte)); + memcpy(d->visiblebits, oldvisiblebits, (oldmaxedicts+7)/8 * sizeof(unsigned char)); // the previous buffers were a single allocation, so just one free Mem_Free(olddeltabits); } @@ -1504,65 +1740,62 @@ void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax) int EntityState5_Priority(entityframe5_database_t *d, int stateindex) { - int lowprecision, limit, priority; - double distance; - int changedbits; - int age; - entity_state_t *view, *s; - changedbits = d->deltabits[stateindex]; - if (!changedbits) - return 0; - if (!d->states[stateindex].active/* && changedbits & E5_FULLUPDATE*/) + int limit, priority; + entity_state_t *s; + // if it is the player, update urgently + if (stateindex == d->viewentnum) return E5_PROTOCOL_PRIORITYLEVELS - 1; - // check whole attachment chain to judge relevance to player - view = d->states + d->viewentnum; - lowprecision = false; + // priority increases each frame no matter what happens + priority = d->priorities[stateindex] + 1; + // players get an extra priority boost + if (stateindex <= svs.maxclients) + priority++; + // remove dead entities very quickly because they are just 2 bytes + if (!d->states[stateindex].active) + { + priority++; + return bound(1, priority, E5_PROTOCOL_PRIORITYLEVELS - 1); + } + // certain changes are more noticable than others + if (d->deltabits[stateindex] & (E5_FULLUPDATE | E5_ATTACHMENT | E5_MODEL | E5_FLAGS | E5_COLORMAP)) + priority++; + // find the root entity this one is attached to, and judge relevance by it for (limit = 0;limit < 256;limit++) { - if (d->maxedicts < stateindex) - EntityFrame5_ExpandEdicts(d, (stateindex+256)&~255); s = d->states + stateindex; - if (s == view) - return E5_PROTOCOL_PRIORITYLEVELS - 1; if (s->flags & RENDER_VIEWMODEL) - return E5_PROTOCOL_PRIORITYLEVELS - 1; - if (s->flags & RENDER_LOWPRECISION) - lowprecision = true; - if (!s->tagentity) - { - if (VectorCompare(s->origin, view->origin)) - return E5_PROTOCOL_PRIORITYLEVELS - 1; + stateindex = d->viewentnum; + else if (s->tagentity) + stateindex = s->tagentity; + else break; - } - stateindex = s->tagentity; + if (d->maxedicts < stateindex) + EntityFrame5_ExpandEdicts(d, (stateindex+256)&~255); } if (limit >= 256) - { - Con_Printf("Protocol: Runaway loop recursing tagentity links on entity %i\n", stateindex); - return 0; - } - // it's not a viewmodel for this client - distance = VectorDistance(view->origin, s->origin); - age = d->latestframenum - d->updateframenum[stateindex]; - priority = (E5_PROTOCOL_PRIORITYLEVELS / 2) + age - (int)(distance * (E5_PROTOCOL_PRIORITYLEVELS / 16384.0f)); - if (lowprecision) - priority -= (E5_PROTOCOL_PRIORITYLEVELS / 4); - //if (changedbits & E5_FULLUPDATE) - // priority += 4; - //if (changedbits & (E5_ATTACHMENT | E5_MODEL | E5_FLAGS | E5_COLORMAP)) - // priority += 4; - return (int) bound(1, priority, E5_PROTOCOL_PRIORITYLEVELS - 1); + Con_DPrintf("Protocol: Runaway loop recursing tagentity links on entity %i\n", stateindex); + // now that we have the parent entity we can make some decisions based on + // distance from the player + if (VectorDistance(d->states[d->viewentnum].netcenter, s->netcenter) < 1024.0f) + priority++; + return bound(1, priority, E5_PROTOCOL_PRIORITYLEVELS - 1); } void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbits, sizebuf_t *msg) { unsigned int bits = 0; + + prvm_eval_t *val; + val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity); + if(val && val->function) + return; + if (!s->active) MSG_WriteShort(msg, number | 0x8000); else { bits = changedbits; - if ((bits & E5_ORIGIN) && (!(s->flags & RENDER_LOWPRECISION) || s->origin[0] < -4096 || s->origin[0] >= 4096 || s->origin[1] < -4096 || s->origin[1] >= 4096 || s->origin[2] < -4096 || s->origin[2] >= 4096)) + if ((bits & E5_ORIGIN) && ((s->flags & RENDER_EXTERIORMODEL) || s->origin[0] < -4096 || s->origin[0] >= 4096 || s->origin[1] < -4096 || s->origin[1] >= 4096 || s->origin[2] < -4096 || s->origin[2] >= 4096)) bits |= E5_ORIGIN32; if ((bits & E5_ANGLES) && !(s->flags & RENDER_LOWPRECISION)) bits |= E5_ANGLES16; @@ -1572,9 +1805,9 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi bits |= E5_FRAME16; if (bits & E5_EFFECTS) { - if (s->effects >= 65536) + if (s->effects & 0xFFFF0000) bits |= E5_EFFECTS32; - else if (s->effects >= 256) + else if (s->effects & 0xFFFFFF00) bits |= E5_EFFECTS16; } if (bits >= 256) @@ -1682,7 +1915,7 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi } } -void EntityState5_ReadUpdate(entity_state_t *s) +void EntityState5_ReadUpdate(entity_state_t *s, int number) { int bits; bits = MSG_ReadByte(); @@ -1793,7 +2026,7 @@ void EntityState5_ReadUpdate(entity_state_t *s) if (developer_networkentities.integer >= 2) { - Con_Printf("ReadFields e%i", s->number); + Con_Printf("ReadFields e%i", number); if (bits & E5_ORIGIN) Con_Printf(" E5_ORIGIN %f %f %f", s->origin[0], s->origin[1], s->origin[2]); @@ -1826,6 +2059,8 @@ void EntityState5_ReadUpdate(entity_state_t *s) Con_Print(" SHADOW"); if (s->flags & RENDER_LIGHT) Con_Print(" LIGHT"); + if (s->flags & RENDER_NOSELFSHADOW) + Con_Print(" NOSELFSHADOW"); Con_Print(")"); } if (bits & E5_ALPHA) @@ -1897,8 +2132,10 @@ void EntityFrame5_CL_ReadFrame(void) for (i = 0;i < LATESTFRAMENUMS-1;i++) cl.latestframenums[i] = cl.latestframenums[i+1]; cl.latestframenums[LATESTFRAMENUMS-1] = MSG_ReadLong(); - if (cl.protocol != PROTOCOL_QUAKE && cl.protocol != PROTOCOL_QUAKEDP && cl.protocol != PROTOCOL_NEHAHRAMOVIE && cl.protocol != PROTOCOL_DARKPLACES1 && cl.protocol != PROTOCOL_DARKPLACES2 && cl.protocol != PROTOCOL_DARKPLACES3 && cl.protocol != PROTOCOL_DARKPLACES4 && cl.protocol != PROTOCOL_DARKPLACES5 && cl.protocol != PROTOCOL_DARKPLACES6) - cl.servermovesequence = MSG_ReadLong(); + if (developer_networkentities.integer >= 10) + Con_Printf("recv: svc_entities %i\n", cl.latestframenums[LATESTFRAMENUMS-1]); + if (cls.protocol != PROTOCOL_QUAKE && cls.protocol != PROTOCOL_QUAKEDP && cls.protocol != PROTOCOL_NEHAHRAMOVIE && cls.protocol != PROTOCOL_DARKPLACES1 && cls.protocol != PROTOCOL_DARKPLACES2 && cls.protocol != PROTOCOL_DARKPLACES3 && cls.protocol != PROTOCOL_DARKPLACES4 && cls.protocol != PROTOCOL_DARKPLACES5 && cls.protocol != PROTOCOL_DARKPLACES6) + cls.servermovesequence = MSG_ReadLong(); // read entity numbers until we find a 0x8000 // (which would be remove world entity, but is actually a terminator) while ((n = (unsigned short)MSG_ReadShort()) != 0x8000 && !msg_badread) @@ -1906,14 +2143,14 @@ void EntityFrame5_CL_ReadFrame(void) // get the entity number enumber = n & 0x7FFF; // we may need to expand the array - if (cl_num_entities <= enumber) + if (cl.num_entities <= enumber) { - cl_num_entities = enumber + 1; - if (enumber >= cl_max_entities) + cl.num_entities = enumber + 1; + if (enumber >= cl.max_entities) CL_ExpandEntities(enumber); } // look up the entity - ent = cl_entities + enumber; + ent = cl.entities + enumber; // slide the current into the previous slot ent->state_previous = ent->state_current; // read the update @@ -1926,23 +2163,23 @@ void EntityFrame5_CL_ReadFrame(void) else { // update entity - EntityState5_ReadUpdate(s); + EntityState5_ReadUpdate(s, enumber); } - // set the cl_entities_active flag - cl_entities_active[enumber] = s->active; + // set the cl.entities_active flag + cl.entities_active[enumber] = s->active; // set the update time s->time = cl.mtime[0]; // fix the number (it gets wiped occasionally by copying from defaultstate) s->number = enumber; // check if we need to update the lerp stuff if (s->active) - CL_MoveLerpEntityStates(&cl_entities[enumber]); + CL_MoveLerpEntityStates(&cl.entities[enumber]); // print extra messages if desired - if (developer_networkentities.integer >= 2 && cl_entities[enumber].state_current.active != cl_entities[enumber].state_previous.active) + if (developer_networkentities.integer >= 2 && cl.entities[enumber].state_current.active != cl.entities[enumber].state_previous.active) { - if (cl_entities[enumber].state_current.active) + if (cl.entities[enumber].state_current.active) Con_Printf("entity #%i has become active\n", enumber); - else if (cl_entities[enumber].state_previous.active) + else if (cl.entities[enumber].state_previous.active) Con_Printf("entity #%i has become inactive\n", enumber); } } @@ -1953,7 +2190,7 @@ void EntityFrame5_LostFrame(entityframe5_database_t *d, int framenum) int i, j, k, l, bits; entityframe5_changestate_t *s, *s2; entityframe5_packetlog_t *p, *p2; - qbyte statsdeltabits[(MAX_CL_STATS+7)/8]; + unsigned char statsdeltabits[(MAX_CL_STATS+7)/8]; // scan for packets that were lost for (i = 0, p = d->packetlog;i < ENTITYFRAME5_MAXPACKETLOGS;i++, p++) { @@ -1985,19 +2222,26 @@ void EntityFrame5_LostFrame(entityframe5_database_t *d, int framenum) // if the bits haven't all been cleared, there were some bits // lost with this packet, so set them again now if (bits) + { d->deltabits[s->number] |= bits; + // if it was a very important update, set priority higher + if (bits & (E5_FULLUPDATE | E5_ATTACHMENT | E5_MODEL || E5_COLORMAP)) + d->priorities[s->number] = max(d->priorities[s->number], 4); + else + d->priorities[s->number] = max(d->priorities[s->number], 1); + } } // mark lost stats for (j = 0;j < MAX_CL_STATS;j++) { for (l = 0;l < (MAX_CL_STATS+7)/8;l++) - statsdeltabits[l] = p->statsdeltabits[l] & ~d->statsdeltabits[l]; + statsdeltabits[l] = p->statsdeltabits[l] & ~host_client->statsdeltabits[l]; for (k = 0, p2 = d->packetlog;k < ENTITYFRAME5_MAXPACKETLOGS;k++, p2++) if (p2->packetnumber > framenum) for (l = 0;l < (MAX_CL_STATS+7)/8;l++) statsdeltabits[l] = p->statsdeltabits[l] & ~p2->statsdeltabits[l]; for (l = 0;l < (MAX_CL_STATS+7)/8;l++) - d->statsdeltabits[l] |= statsdeltabits[l]; + host_client->statsdeltabits[l] |= statsdeltabits[l]; } // delete this packet log as it is now obsolete p->packetnumber = 0; @@ -2014,19 +2258,16 @@ void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum) d->packetlog[i].packetnumber = 0; } -int entityframe5_prioritychaincounts[E5_PROTOCOL_PRIORITYLEVELS]; -unsigned short entityframe5_prioritychains[E5_PROTOCOL_PRIORITYLEVELS][ENTITYFRAME5_MAXSTATES]; - -void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int *stats, int movesequence) +void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int movesequence) { const entity_state_t *n; int i, num, l, framenum, packetlognumber, priority; sizebuf_t buf; - qbyte data[128]; + unsigned char data[128]; entityframe5_packetlog_t *packetlog; - if (sv.max_edicts > d->maxedicts) - EntityFrame5_ExpandEdicts(d, (sv.max_edicts + 255) & ~255); + if (prog->max_edicts > d->maxedicts) + EntityFrame5_ExpandEdicts(d, prog->max_edicts); framenum = d->latestframenum + 1; d->viewentnum = viewentnum; @@ -2038,6 +2279,7 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num break; if (packetlognumber == ENTITYFRAME5_MAXPACKETLOGS) { + Con_DPrintf("EntityFrame5_WriteFrame: packetlog overflow for a client, resetting\n"); EntityFrame5_LostFrame(d, framenum); packetlognumber = 0; } @@ -2047,18 +2289,8 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num buf.data = data; buf.maxsize = sizeof(data); - // detect changes in stats - for (i = 0;i < MAX_CL_STATS;i++) - { - if (d->stats[i] != stats[i]) - { - d->statsdeltabits[i>>3] |= (1<<(i&7)); - d->stats[i] = stats[i]; - } - } - // detect changes in states - num = 0; + num = 1; for (i = 0, n = states;i < numstates;i++, n++) { // mark gaps in entity numbering as removed entities @@ -2069,7 +2301,7 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num { CLEARPVSBIT(d->visiblebits, num); d->deltabits[num] = E5_FULLUPDATE; - d->priorities[num] = EntityState5_Priority(d, num); + d->priorities[num] = max(d->priorities[num], 8); // removal is cheap d->states[num] = defaultstate; d->states[num].number = num; } @@ -2080,24 +2312,26 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num // entity just spawned in, don't let it completely hog priority // because of being ancient on the first frame d->updateframenum[num] = framenum; + // initial priority is a bit high to make projectiles send on the + // first frame, among other things + d->priorities[num] = max(d->priorities[num], 4); } SETPVSBIT(d->visiblebits, num); d->deltabits[num] |= EntityState5_DeltaBits(d->states + num, n); - d->priorities[num] = EntityState5_Priority(d, num); + d->priorities[num] = max(d->priorities[num], 1); d->states[num] = *n; d->states[num].number = num; // advance to next entity so the next iteration doesn't immediately remove it num++; } // all remaining entities are dead - // note: this must use sv.max_edicts, not sv.num_edicts, because sv.num_edicts can both increase and decrease, where as sv.max_edicts only increases (if sv.num_edicts is used, sometimes some entities are missed when the sv.num_edicts count goes back down after firing some shots) - for (;num < sv.max_edicts;num++) + for (;num < d->maxedicts;num++) { if (CHECKPVSBIT(d->visiblebits, num)) { CLEARPVSBIT(d->visiblebits, num); d->deltabits[num] = E5_FULLUPDATE; - d->priorities[num] = EntityState5_Priority(d, num); + d->priorities[num] = max(d->priorities[num], 8); // removal is cheap d->states[num] = defaultstate; d->states[num].number = num; } @@ -2111,14 +2345,21 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num // build lists of entities by priority level memset(entityframe5_prioritychaincounts, 0, sizeof(entityframe5_prioritychaincounts)); l = 0; - for (num = 0;num < sv.num_edicts;num++) + for (num = 0;num < d->maxedicts;num++) { if (d->priorities[num]) { - l = num; - priority = d->priorities[num]; - if (entityframe5_prioritychaincounts[priority] < ENTITYFRAME5_MAXSTATES) - entityframe5_prioritychains[priority][entityframe5_prioritychaincounts[priority]++] = num; + if (d->deltabits[num]) + { + if (d->priorities[num] < (E5_PROTOCOL_PRIORITYLEVELS - 1)) + d->priorities[num] = EntityState5_Priority(d, num); + l = num; + priority = d->priorities[num]; + if (entityframe5_prioritychaincounts[priority] < ENTITYFRAME5_MAXSTATES) + entityframe5_prioritychains[priority][entityframe5_prioritychaincounts[priority]++] = num; + } + else + d->priorities[num] = 0; } } @@ -2129,28 +2370,30 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num // write stat updates if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_DARKPLACES1 && sv.protocol != PROTOCOL_DARKPLACES2 && sv.protocol != PROTOCOL_DARKPLACES3 && sv.protocol != PROTOCOL_DARKPLACES4 && sv.protocol != PROTOCOL_DARKPLACES5) { - for (i = 0;i < MAX_CL_STATS && buf.cursize + 6 + 11 <= buf.maxsize;i++) + for (i = 0;i < MAX_CL_STATS && msg->cursize + 6 + 11 <= msg->maxsize;i++) { - if (d->statsdeltabits[i>>3] & (1<<(i&7))) + if (host_client->statsdeltabits[i>>3] & (1<<(i&7))) { - d->statsdeltabits[i>>3] &= ~(1<<(i&7)); + host_client->statsdeltabits[i>>3] &= ~(1<<(i&7)); packetlog->statsdeltabits[i>>3] |= (1<<(i&7)); - if (d->stats[i] >= 0 && d->stats[i] < 256) + if (host_client->stats[i] >= 0 && host_client->stats[i] < 256) { MSG_WriteByte(msg, svc_updatestatubyte); MSG_WriteByte(msg, i); - MSG_WriteByte(msg, d->stats[i]); + MSG_WriteByte(msg, host_client->stats[i]); } else { MSG_WriteByte(msg, svc_updatestat); MSG_WriteByte(msg, i); - MSG_WriteLong(msg, d->stats[i]); + MSG_WriteLong(msg, host_client->stats[i]); } } } } // write state updates + if (developer_networkentities.integer >= 10) + Con_Printf("send: svc_entities %i\n", framenum); d->latestframenum = framenum; MSG_WriteByte(msg, svc_entities); MSG_WriteLong(msg, framenum); @@ -2185,3 +2428,393 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num MSG_WriteShort(msg, 0x8000); } + +static void QW_TranslateEffects(entity_state_t *s, int qweffects) +{ + s->effects = 0; + s->internaleffects = 0; + if (qweffects & QW_EF_BRIGHTFIELD) + s->effects |= EF_BRIGHTFIELD; + if (qweffects & QW_EF_MUZZLEFLASH) + s->effects |= EF_MUZZLEFLASH; + if (qweffects & QW_EF_FLAG1) + { + // mimic FTEQW's interpretation of EF_FLAG1 as EF_NODRAW on non-player entities + if (s->number > cl.maxclients) + s->effects |= EF_NODRAW; + else + s->internaleffects |= INTEF_FLAG1QW; + } + if (qweffects & QW_EF_FLAG2) + { + // mimic FTEQW's interpretation of EF_FLAG2 as EF_ADDITIVE on non-player entities + if (s->number > cl.maxclients) + s->effects |= EF_ADDITIVE; + else + s->internaleffects |= INTEF_FLAG2QW; + } + if (qweffects & QW_EF_RED) + { + if (qweffects & QW_EF_BLUE) + s->effects |= EF_RED | EF_BLUE; + else + s->effects |= EF_RED; + } + else if (qweffects & QW_EF_BLUE) + s->effects |= EF_BLUE; + else if (qweffects & QW_EF_BRIGHTLIGHT) + s->effects |= EF_BRIGHTLIGHT; + else if (qweffects & QW_EF_DIMLIGHT) + s->effects |= EF_DIMLIGHT; +} + +void EntityStateQW_ReadPlayerUpdate(void) +{ + int slot = MSG_ReadByte(); + int enumber = slot + 1; + int weaponframe; + int msec; + int playerflags; + int bits; + entity_state_t *s; + // look up the entity + entity_t *ent = cl.entities + enumber; + vec3_t viewangles; + vec3_t velocity; + + // slide the current state into the previous + ent->state_previous = ent->state_current; + + // read the update + s = &ent->state_current; + *s = defaultstate; + s->active = true; + s->number = enumber; + s->colormap = enumber; + playerflags = MSG_ReadShort(); + MSG_ReadVector(s->origin, cls.protocol); + s->frame = MSG_ReadByte(); + + VectorClear(viewangles); + VectorClear(velocity); + + if (playerflags & QW_PF_MSEC) + { + // time difference between last update this player sent to the server, + // and last input we sent to the server (this packet is in response to + // our input, so msec is how long ago the last update of this player + // entity occurred, compared to our input being received) + msec = MSG_ReadByte(); + } + else + msec = 0; + if (playerflags & QW_PF_COMMAND) + { + bits = MSG_ReadByte(); + if (bits & QW_CM_ANGLE1) + viewangles[0] = MSG_ReadAngle16i(); // cmd->angles[0] + if (bits & QW_CM_ANGLE2) + viewangles[1] = MSG_ReadAngle16i(); // cmd->angles[1] + if (bits & QW_CM_ANGLE3) + viewangles[2] = MSG_ReadAngle16i(); // cmd->angles[2] + if (bits & QW_CM_FORWARD) + MSG_ReadShort(); // cmd->forwardmove + if (bits & QW_CM_SIDE) + MSG_ReadShort(); // cmd->sidemove + if (bits & QW_CM_UP) + MSG_ReadShort(); // cmd->upmove + if (bits & QW_CM_BUTTONS) + MSG_ReadByte(); // cmd->buttons + if (bits & QW_CM_IMPULSE) + MSG_ReadByte(); // cmd->impulse + MSG_ReadByte(); // cmd->msec + } + if (playerflags & QW_PF_VELOCITY1) + velocity[0] = MSG_ReadShort(); + if (playerflags & QW_PF_VELOCITY2) + velocity[1] = MSG_ReadShort(); + if (playerflags & QW_PF_VELOCITY3) + velocity[2] = MSG_ReadShort(); + if (playerflags & QW_PF_MODEL) + s->modelindex = MSG_ReadByte(); + else + s->modelindex = cl.qw_modelindex_player; + if (playerflags & QW_PF_SKINNUM) + s->skin = MSG_ReadByte(); + if (playerflags & QW_PF_EFFECTS) + QW_TranslateEffects(s, MSG_ReadByte()); + if (playerflags & QW_PF_WEAPONFRAME) + weaponframe = MSG_ReadByte(); + else + weaponframe = 0; + + if (enumber == cl.playerentity) + { + // if this is an update on our player, update the angles + VectorCopy(cl.viewangles, viewangles); + } + + // calculate the entity angles from the viewangles + s->angles[0] = viewangles[0] * -0.0333; + s->angles[1] = viewangles[1]; + s->angles[2] = 0; + s->angles[2] = V_CalcRoll(s->angles, velocity)*4; + + // if this is an update on our player, update interpolation state + if (enumber == cl.playerentity) + { + VectorCopy (cl.mpunchangle[0], cl.mpunchangle[1]); + VectorCopy (cl.mpunchvector[0], cl.mpunchvector[1]); + VectorCopy (cl.mvelocity[0], cl.mvelocity[1]); + cl.mviewzoom[1] = cl.mviewzoom[0]; + + cl.idealpitch = 0; + cl.mpunchangle[0][0] = 0; + cl.mpunchangle[0][1] = 0; + cl.mpunchangle[0][2] = 0; + cl.mpunchvector[0][0] = 0; + cl.mpunchvector[0][1] = 0; + cl.mpunchvector[0][2] = 0; + cl.mvelocity[0][0] = 0; + cl.mvelocity[0][1] = 0; + cl.mvelocity[0][2] = 0; + cl.mviewzoom[0] = 1; + + VectorCopy(velocity, cl.mvelocity[0]); + cl.stats[STAT_WEAPONFRAME] = weaponframe; + if (playerflags & QW_PF_GIB) + cl.stats[STAT_VIEWHEIGHT] = 8; + else if (playerflags & QW_PF_DEAD) + cl.stats[STAT_VIEWHEIGHT] = -16; + else + cl.stats[STAT_VIEWHEIGHT] = 22; + } + + // set the cl.entities_active flag + cl.entities_active[enumber] = s->active; + // set the update time + s->time = cl.mtime[0] - msec * 0.001; // qw has no clock + // check if we need to update the lerp stuff + if (s->active) + CL_MoveLerpEntityStates(&cl.entities[enumber]); +} + +static void EntityStateQW_ReadEntityUpdate(entity_state_t *s, int bits) +{ + int qweffects = 0; + s->active = true; + s->number = bits & 511; + bits &= ~511; + if (bits & QW_U_MOREBITS) + bits |= MSG_ReadByte(); + + // store the QW_U_SOLID bit here? + + if (bits & QW_U_MODEL) + s->modelindex = MSG_ReadByte(); + if (bits & QW_U_FRAME) + s->frame = MSG_ReadByte(); + if (bits & QW_U_COLORMAP) + s->colormap = MSG_ReadByte(); + if (bits & QW_U_SKIN) + s->skin = MSG_ReadByte(); + if (bits & QW_U_EFFECTS) + QW_TranslateEffects(s, qweffects = MSG_ReadByte()); + if (bits & QW_U_ORIGIN1) + s->origin[0] = MSG_ReadCoord13i(); + if (bits & QW_U_ANGLE1) + s->angles[0] = MSG_ReadAngle8i(); + if (bits & QW_U_ORIGIN2) + s->origin[1] = MSG_ReadCoord13i(); + if (bits & QW_U_ANGLE2) + s->angles[1] = MSG_ReadAngle8i(); + if (bits & QW_U_ORIGIN3) + s->origin[2] = MSG_ReadCoord13i(); + if (bits & QW_U_ANGLE3) + s->angles[2] = MSG_ReadAngle8i(); + + if (developer_networkentities.integer >= 2) + { + Con_Printf("ReadFields e%i", s->number); + if (bits & QW_U_MODEL) + Con_Printf(" U_MODEL %i", s->modelindex); + if (bits & QW_U_FRAME) + Con_Printf(" U_FRAME %i", s->frame); + if (bits & QW_U_COLORMAP) + Con_Printf(" U_COLORMAP %i", s->colormap); + if (bits & QW_U_SKIN) + Con_Printf(" U_SKIN %i", s->skin); + if (bits & QW_U_EFFECTS) + Con_Printf(" U_EFFECTS %i", qweffects); + if (bits & QW_U_ORIGIN1) + Con_Printf(" U_ORIGIN1 %f", s->origin[0]); + if (bits & QW_U_ANGLE1) + Con_Printf(" U_ANGLE1 %f", s->angles[0]); + if (bits & QW_U_ORIGIN2) + Con_Printf(" U_ORIGIN2 %f", s->origin[1]); + if (bits & QW_U_ANGLE2) + Con_Printf(" U_ANGLE2 %f", s->angles[1]); + if (bits & QW_U_ORIGIN3) + Con_Printf(" U_ORIGIN3 %f", s->origin[2]); + if (bits & QW_U_ANGLE3) + Con_Printf(" U_ANGLE3 %f", s->angles[2]); + if (bits & QW_U_SOLID) + Con_Printf(" U_SOLID"); + Con_Print("\n"); + } +} + +entityframeqw_database_t *EntityFrameQW_AllocDatabase(mempool_t *pool) +{ + entityframeqw_database_t *d; + d = (entityframeqw_database_t *)Mem_Alloc(pool, sizeof(*d)); + return d; +} + +void EntityFrameQW_FreeDatabase(entityframeqw_database_t *d) +{ + Mem_Free(d); +} + +void EntityFrameQW_CL_ReadFrame(qboolean delta) +{ + qboolean invalid = false; + int number, oldsnapindex, newsnapindex, oldindex, newindex, oldnum, newnum; + entity_t *ent; + entityframeqw_database_t *d; + entityframeqw_snapshot_t *oldsnap, *newsnap; + + if (!cl.entitydatabaseqw) + cl.entitydatabaseqw = EntityFrameQW_AllocDatabase(cls.levelmempool); + d = cl.entitydatabaseqw; + + // there is no cls.netcon in demos, so this reading code can't access + // cls.netcon-> at all... so cls.qw_incoming_sequence and + // cls.qw_outgoing_sequence are updated every time the corresponding + // cls.netcon->qw. variables are updated + // read the number of this frame to echo back in next input packet + cl.qw_validsequence = cls.qw_incoming_sequence; + newsnapindex = cl.qw_validsequence & QW_UPDATE_MASK; + newsnap = d->snapshot + newsnapindex; + memset(newsnap, 0, sizeof(*newsnap)); + oldsnapindex = -1; + oldsnap = NULL; + if (delta) + { + number = MSG_ReadByte(); + oldsnapindex = cl.qw_deltasequence[newsnapindex]; + if ((number & QW_UPDATE_MASK) != (oldsnapindex & QW_UPDATE_MASK)) + Con_DPrintf("WARNING: from mismatch\n"); + if (oldsnapindex != -1) + { + if (cls.qw_outgoing_sequence - oldsnapindex >= QW_UPDATE_BACKUP-1) + { + Con_DPrintf("delta update too old\n"); + newsnap->invalid = invalid = true; // too old + delta = false; + } + oldsnap = d->snapshot + (oldsnapindex & QW_UPDATE_MASK); + } + else + delta = false; + } + + // if we can't decode this frame properly, report that to the server + if (invalid) + cl.qw_validsequence = 0; + + // read entity numbers until we find a 0x0000 + // (which would be an empty update on world entity, but is actually a terminator) + newsnap->num_entities = 0; + oldindex = 0; + for (;;) + { + int word = (unsigned short)MSG_ReadShort(); + if (msg_badread) + return; // just return, the main parser will print an error + newnum = word == 0 ? 512 : (word & 511); + oldnum = delta ? (oldindex >= oldsnap->num_entities ? 9999 : oldsnap->entities[oldindex].number) : 9999; + + // copy unmodified oldsnap entities + while (newnum > oldnum) // delta only + { + if (developer_networkentities.integer >= 2) + Con_Printf("copy %i\n", oldnum); + // copy one of the old entities + if (newsnap->num_entities >= QW_MAX_PACKET_ENTITIES) + Host_Error("EntityFrameQW_CL_ReadFrame: newsnap->num_entities == MAX_PACKETENTITIES"); + newsnap->entities[newsnap->num_entities] = oldsnap->entities[oldindex++]; + newsnap->num_entities++; + oldnum = oldindex >= oldsnap->num_entities ? 9999 : oldsnap->entities[oldindex].number; + } + + if (word == 0) + break; + + if (developer_networkentities.integer >= 2) + { + if (word & QW_U_REMOVE) + Con_Printf("remove %i\n", newnum); + else if (newnum == oldnum) + Con_Printf("delta %i\n", newnum); + else + Con_Printf("baseline %i\n", newnum); + } + + if (word & QW_U_REMOVE) + { + if (newnum != oldnum && !delta && !invalid) + { + cl.qw_validsequence = 0; + Con_Printf("WARNING: U_REMOVE %i on full update\n", newnum); + } + } + else + { + if (newsnap->num_entities >= QW_MAX_PACKET_ENTITIES) + Host_Error("EntityFrameQW_CL_ReadFrame: newsnap->num_entities == MAX_PACKETENTITIES"); + newsnap->entities[newsnap->num_entities] = (newnum == oldnum) ? oldsnap->entities[oldindex] : cl.entities[newnum].state_baseline; + EntityStateQW_ReadEntityUpdate(newsnap->entities + newsnap->num_entities, word); + newsnap->num_entities++; + } + + if (newnum == oldnum) + oldindex++; + } + + // expand cl.num_entities to include every entity we've seen this game + newnum = newsnap->num_entities ? newsnap->entities[newsnap->num_entities - 1].number : 1; + if (cl.num_entities <= newnum) + { + cl.num_entities = newnum + 1; + if (cl.max_entities < newnum + 1) + CL_ExpandEntities(newnum); + } + + // now update the non-player entities from the snapshot states + number = cl.maxclients + 1; + for (newindex = 0;;newindex++) + { + newnum = newindex >= newsnap->num_entities ? cl.num_entities : newsnap->entities[newindex].number; + // kill any missing entities + for (;number < newnum;number++) + { + if (cl.entities_active[number]) + { + cl.entities_active[number] = false; + cl.entities[number].state_current.active = false; + } + } + if (number >= cl.num_entities) + break; + // update the entity + ent = &cl.entities[number]; + ent->state_previous = ent->state_current; + ent->state_current = newsnap->entities[newindex]; + ent->state_current.time = cl.mtime[0]; + CL_MoveLerpEntityStates(ent); + // the entity lives again... + cl.entities_active[number] = true; + number++; + } +}