#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,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;
0,//unsigned char tagindex;
{32, 32, 32},//unsigned char colormod[3];
// padding to a multiple of 8 bytes (to align the double time)
- {0,0}//unsigned char unused[2]; // !
+ {0,0,0,0,0,0}//unsigned char unused[6]; // !
};
// LordHavoc: I own protocol ranges 96, 97, 3500-3599
-struct
+struct protocolversioninfo_s
{
int number;
const char *name;
{15, "QUAKEDP"},
{250, "NEHAHRAMOVIE"},
{15, "QUAKE"},
+ {28, "QUAKEWORLD"},
{0, NULL}
};
+static mempool_t *sv2csqc = NULL;
+int csqc_clent = 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;
}
int i;
for (i = 1;protocolversioninfo[i].name;i++)
if (protocolversioninfo[i].number == n)
- return i;
+ return (protocolversion_t)i;
return PROTOCOL_UNKNOWN;
}
}
}
-// 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;
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)
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
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;
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);
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;
}
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])
+ 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] = true;
- cl_lastquakeentity = num;
+ 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);
+}
+
+//[515]: we use only one array per-client for SendEntity feature
+void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states)
+{
+ sizebuf_t buf;
+ unsigned char data[2048];
+ const entity_state_t *s;
+ unsigned short i, t, t2, t0;
+ prvm_eval_t *val, *val2;
+ int csqcents = 0;
+
+ if(!eval_SendEntity || !eval_Version)
+ return;
+ --csqc_clent;
+ if(!sv2csqcents_version[csqc_clent])
+ EntityFrameCSQC_InitClientVersions(csqc_clent, false);
+
+ for (csqcents = i = 0, s = states;i < numstates;i++, s++)
+ {
+ //[515]: entities remove
+ if(i+1 >= numstates)
+ t2 = prog->num_edicts;
+ else
+ t2 = states[i+1].number;
+ if(!i)
+ {
+ t0 = 1;
+ t2 = s->number;
+ }
+ else
+ t0 = s->number+1;
+ for(t=t0; t<t2 ;t++)
+ if(sv2csqcents_version[csqc_clent][t])
+ {
+ if(!csqcents)
+ {
+ csqcents = 1;
+ memset(&buf, 0, sizeof(buf));
+ buf.data = data;
+ buf.maxsize = sizeof(data);
+ sv2csqcbuf = &buf;
+ SZ_Clear(&buf);
+ MSG_WriteByte(&buf, svc_csqcentities);
+ }
+ sv2csqcents_version[csqc_clent][t] = 0;
+ MSG_WriteShort(&buf, (unsigned short)t | 0x8000);
+ csqcents++;
+ }
+ //[515]: entities remove
+
+// if(!s->active)
+// continue;
+ val = PRVM_GETEDICTFIELDVALUE((&prog->edicts[s->number]), eval_SendEntity);
+ if(val->function)
+ {
+ val2 = PRVM_GETEDICTFIELDVALUE((&prog->edicts[s->number]), eval_Version);
+ if(sv2csqcents_version[csqc_clent][s->number] == (unsigned char)val2->_float)
+ continue;
+ if(!csqcents)
+ {
+ csqcents = 1;
+ memset(&buf, 0, sizeof(buf));
+ buf.data = data;
+ buf.maxsize = sizeof(data);
+ sv2csqcbuf = &buf;
+ SZ_Clear(&buf);
+ MSG_WriteByte(&buf, svc_csqcentities);
+ }
+ if((unsigned char)val2->_float == 0)
+ val2->_float = 1;
+ MSG_WriteShort(&buf, s->number);
+ ((int *)prog->globals.generic)[OFS_PARM0] = csqc_clent+1;
+ prog->globals.server->self = s->number;
+ PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
+ if(!prog->globals.generic[OFS_RETURN])
+ {
+ buf.cursize -= 2;
+ if(sv2csqcents_version[csqc_clent][s->number])
+ {
+ sv2csqcents_version[csqc_clent][s->number] = 0;
+ MSG_WriteShort(&buf, (unsigned short)s->number | 0x8000);
+ csqcents++;
+ }
}
else
{
- cl_isquakeentity[num] = false;
- cl_entities_active[num] = false;
- cl_entities[num].state_current = defaultstate;
- cl_entities[num].state_current.number = num;
+ sv2csqcents_version[csqc_clent][s->number] = (unsigned char)val2->_float;
+ csqcents++;
}
+ if (msg->cursize + buf.cursize > msg->maxsize)
+ break;
+ }
+ }
+ if(csqcents)
+ {
+ if(csqcents > 1)
+ {
+ MSG_WriteShort(&buf, 0);
+ SZ_Write(msg, buf.data, buf.cursize);
}
+ sv2csqcbuf = NULL;
}
}
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));
for (i = 0, s = states;i < numstates;i++, s++)
{
+ val = PRVM_GETEDICTFIELDVALUE((&prog->edicts[s->number]), eval_SendEntity);
+ if(val && val->function)
+ continue;
+
// prepare the buffer
SZ_Clear(&buf);
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])
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);
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;
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();
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();
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)
// (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
}
// (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++;
{
ent = states + i;
number = ent->number;
+
+ val = PRVM_GETEDICTFIELDVALUE((&prog->edicts[number]), eval_SendEntity);
+ if(val && val->function)
+ continue;
for (;onum < o->numentities && o->entitydata[onum].number < number;onum++)
{
// write remove message
}
// (client) reads a frame from network stream
-static entity_frame_t framedata; // FIXME?
void EntityFrame_CL_ReadFrame(void)
{
int i, number, removed;
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);
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];
}
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++;
*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;
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;
}
}
}
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));
{
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));
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;
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();
// 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
// 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)
{
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)
{
}
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);
}
}
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)
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_GETEDICTFIELDVALUE((&prog->edicts[n]), eval_SendEntity);
+ if(val && val->function)
+ continue;
// find the old state to delta from
e = EntityFrame4_GetReferenceEntity(d, n);
// prepare the buffer
-#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;
}
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);
}
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_GETEDICTFIELDVALUE((&prog->edicts[s->number]), eval_SendEntity);
+ if(val && val->function)
+ return;
+
if (!s->active)
MSG_WriteShort(msg, number | 0x8000);
else
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)
+ if (developer_networkentities.integer)
+ 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)
cl.servermovesequence = MSG_ReadLong();
// read entity numbers until we find a 0x8000
// (which would be remove world entity, but is actually a terminator)
// 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
// update entity
EntityState5_ReadUpdate(s);
}
- // 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);
}
}
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++)
{
// 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;
+ d->priorities[s->number] = EntityState5_Priority(d, s->number);
+ }
}
// mark lost stats
for (j = 0;j < MAX_CL_STATS;j++)
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)
{
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;
break;
if (packetlognumber == ENTITYFRAME5_MAXPACKETLOGS)
{
+ Con_DPrintf("EntityFrame5_WriteFrame: packetlog overflow for a client, resetting\n");
EntityFrame5_LostFrame(d, framenum);
packetlognumber = 0;
}
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))
{
// 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])
{
}
}
// write state updates
+ if (developer_networkentities.integer)
+ Con_Printf("send: svc_entities %i\n", framenum);
d->latestframenum = framenum;
MSG_WriteByte(msg, svc_entities);
MSG_WriteLong(msg, framenum);
MSG_WriteShort(msg, 0x8000);
}
+
+static int QW_TranslateEffects(int qweffects, int number)
+{
+ int effects = 0;
+ if (qweffects & QW_EF_BRIGHTFIELD)
+ effects |= EF_BRIGHTFIELD;
+ if (qweffects & QW_EF_MUZZLEFLASH)
+ effects |= EF_MUZZLEFLASH;
+ if (qweffects & QW_EF_FLAG1)
+ {
+ // mimic FTEQW's interpretation of EF_FLAG1 as EF_NODRAW on non-player entities
+ if (number > cl.maxclients)
+ effects |= EF_NODRAW;
+ else
+ effects |= EF_FLAG1QW;
+ }
+ if (qweffects & QW_EF_FLAG2)
+ {
+ // mimic FTEQW's interpretation of EF_FLAG2 as EF_ADDITIVE on non-player entities
+ if (number > cl.maxclients)
+ effects |= EF_ADDITIVE;
+ else
+ effects |= EF_FLAG2QW;
+ }
+ if (qweffects & QW_EF_RED)
+ {
+ if (qweffects & QW_EF_BLUE)
+ effects |= EF_RED | EF_BLUE;
+ else
+ effects |= EF_RED;
+ }
+ else if (qweffects & QW_EF_BLUE)
+ effects |= EF_BLUE;
+ else if (qweffects & QW_EF_BRIGHTLIGHT)
+ effects |= EF_BRIGHTLIGHT;
+ else if (qweffects & QW_EF_DIMLIGHT)
+ effects |= EF_DIMLIGHT;
+ return effects;
+}
+
+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->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)
+ s->effects = QW_TranslateEffects(MSG_ReadByte(), enumber);
+ 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
+ // 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]);
+}
+
+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)
+ s->effects = QW_TranslateEffects(qweffects = MSG_ReadByte(), s->number);
+ 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;
+
+ newsnapindex = cls.netcon->qw.incoming_sequence & 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.netcon->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;
+ }
+
+ // read the number of this frame to echo back in next input packet
+ cl.qw_validsequence = cls.netcon->qw.incoming_sequence;
+ 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++;
+ }
+}