254,//unsigned char glowcolor;
0,//unsigned char flags;
0,//unsigned char tagindex;
- 255,//unsigned char colormod;
+ {32, 32, 32},//unsigned char colormod[3];
// padding to a multiple of 8 bytes (to align the double time)
- {0,0,0,0}//unsigned char unused[4]; // !
+ {0,0}//unsigned char unused[2]; // !
};
-double entityframequake_mtime = 0;
+// LordHavoc: I own protocol ranges 96, 97, 3500-3599
+
+struct protocolversioninfo_s
+{
+ int number;
+ const char *name;
+}
+protocolversioninfo[] =
+{
+ {0, "UNKNOWN"},
+ {3504, "DP7"},
+ {3503, "DP6"},
+ {3502, "DP5"},
+ {3501, "DP4"},
+ {3500, "DP3"},
+ {97, "DP2"},
+ {96, "DP1"},
+ {15, "QUAKEDP"},
+ {250, "NEHAHRAMOVIE"},
+ {15, "QUAKE"},
+ {0, NULL}
+};
+
+protocolversion_t Protocol_EnumForName(const char *s)
+{
+ int i;
+ for (i = 1;protocolversioninfo[i].name;i++)
+ if (!strcasecmp(s, protocolversioninfo[i].name))
+ return (protocolversion_t)i;
+ return PROTOCOL_UNKNOWN;
+}
+
+const char *Protocol_NameForEnum(protocolversion_t p)
+{
+ return protocolversioninfo[p].name;
+}
+
+protocolversion_t Protocol_EnumForNumber(int n)
+{
+ int i;
+ for (i = 1;protocolversioninfo[i].name;i++)
+ if (protocolversioninfo[i].number == n)
+ return (protocolversion_t)i;
+ return PROTOCOL_UNKNOWN;
+}
+
+int Protocol_NumberForEnum(protocolversion_t p)
+{
+ return protocolversioninfo[p].number;
+}
+
+void Protocol_Names(char *buffer, size_t buffersize)
+{
+ int i;
+ if (buffersize < 1)
+ return;
+ buffer[0] = 0;
+ for (i = 1;protocolversioninfo[i].name;i++)
+ {
+ if (i > 1)
+ strlcat(buffer, " ", sizeof(buffer));
+ strlcat(buffer, protocolversioninfo[i].name, sizeof(buffer));
+ }
+}
+
+// keep track of quake entities because they need to be killed if they get stale
+int cl_lastquakeentity = 0;
+unsigned char cl_isquakeentity[MAX_EDICTS];
void EntityFrameQuake_ReadEntity(int bits)
{
entity_t *ent;
entity_state_t s;
- entityframequake_mtime = cl.mtime[0];
-
if (bits & U_MOREBITS)
bits |= (MSG_ReadByte()<<8);
if ((bits & U_EXTEND1) && cl.protocol != PROTOCOL_NEHAHRAMOVIE)
if (num < 1)
Host_Error("EntityFrameQuake_ReadEntity: invalid entity number (%i)\n", num);
+ if (cl_num_entities <= num)
+ {
+ cl_num_entities = num + 1;
+ if (num >= cl_max_entities)
+ CL_ExpandEntities(num);
+ }
+
ent = cl_entities + num;
// note: this inherits the 'active' state of the baseline chosen
s.active = true;
}
+ 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_ReadCoord13i();
- if (bits & U_ANGLE1) s.angles[0] = MSG_ReadAngle8i();
- if (bits & U_ORIGIN2) s.origin[1] = MSG_ReadCoord13i();
- if (bits & U_ANGLE2) s.angles[1] = MSG_ReadAngle8i();
- if (bits & U_ORIGIN3) s.origin[2] = MSG_ReadCoord13i();
- if (bits & U_ANGLE3) s.angles[2] = MSG_ReadAngle8i();
+ 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_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) s.colormod = MSG_ReadByte();
+ 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);
void EntityFrameQuake_ISeeDeadEntities(void)
{
- int i;
- for (i = 0;i < cl_max_entities;i++)
+ int num, lastentity;
+ if (cl_lastquakeentity == 0)
+ return;
+ lastentity = cl_lastquakeentity;
+ cl_lastquakeentity = 0;
+ for (num = 0;num <= lastentity;num++)
{
- if (cl_entities_active[i] && cl_entities[i].state_current.time != cl.mtime[0])
+ if (cl_isquakeentity[num])
{
- cl_entities_active[i] = false;
- cl_entities[i].state_current = defaultstate;
- cl_entities[i].state_current.number = i;
+ 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;
+ }
}
}
}
entity_state_t baseline;
int i, bits;
sizebuf_t buf;
- qbyte data[128];
+ unsigned char data[128];
// prepare the buffer
memset(&buf, 0, sizeof(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])
bits |= U_GLOWCOLOR;
// if extensions are disabled, clear the relevant update flags
- if (sv.netquakecompatible)
+ if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
bits &= 0x7FFF;
+ if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
+ if (s->alpha != 255 || s->effects & EF_FULLBRIGHT)
+ bits |= U_EXTEND1;
// write the message
if (bits >= 16777216)
if (bits & U_COLORMAP) MSG_WriteByte(&buf, s->colormap);
if (bits & U_SKIN) MSG_WriteByte(&buf, s->skin);
if (bits & U_EFFECTS) MSG_WriteByte(&buf, s->effects);
- if (bits & U_ORIGIN1) MSG_WriteCoord13i(&buf, s->origin[0]);
- if (bits & U_ANGLE1) MSG_WriteAngle8i(&buf, s->angles[0]);
- if (bits & U_ORIGIN2) MSG_WriteCoord13i(&buf, s->origin[1]);
- if (bits & U_ANGLE2) MSG_WriteAngle8i(&buf, s->angles[1]);
- if (bits & U_ORIGIN3) MSG_WriteCoord13i(&buf, s->origin[2]);
- if (bits & U_ANGLE3) MSG_WriteAngle8i(&buf, s->angles[2]);
+ if (bits & U_ORIGIN1) MSG_WriteCoord(&buf, s->origin[0], sv.protocol);
+ if (bits & U_ANGLE1) MSG_WriteAngle(&buf, s->angles[0], sv.protocol);
+ if (bits & U_ORIGIN2) MSG_WriteCoord(&buf, s->origin[1], sv.protocol);
+ if (bits & U_ANGLE2) MSG_WriteAngle(&buf, s->angles[1], sv.protocol);
+ if (bits & U_ORIGIN3) MSG_WriteCoord(&buf, s->origin[2], sv.protocol);
+ if (bits & U_ANGLE3) MSG_WriteAngle(&buf, s->angles[2], sv.protocol);
if (bits & U_ALPHA) MSG_WriteByte(&buf, s->alpha);
if (bits & U_SCALE) MSG_WriteByte(&buf, s->scale);
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) MSG_WriteByte(&buf, s->colormod);
+ 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_FRAME2) MSG_WriteByte(&buf, s->frame >> 8);
if (bits & U_MODEL2) MSG_WriteByte(&buf, s->modelindex >> 8);
+ // the nasty protocol
+ if ((bits & U_EXTEND1) && sv.protocol == PROTOCOL_NEHAHRAMOVIE)
+ {
+ if (s->effects & EF_FULLBRIGHT)
+ {
+ MSG_WriteFloat(&buf, 2); // QSG protocol version
+ MSG_WriteFloat(&buf, s->alpha <= 0 ? 0 : (s->alpha >= 255 ? 1 : s->alpha * (1.0f / 255.0f))); // alpha
+ MSG_WriteFloat(&buf, 1); // fullbright
+ }
+ else
+ {
+ MSG_WriteFloat(&buf, 1); // QSG protocol version
+ MSG_WriteFloat(&buf, s->alpha <= 0 ? 0 : (s->alpha >= 255 ? 1 : s->alpha * (1.0f / 255.0f))); // alpha
+ }
+ }
+
// if the commit is full, we're done this frame
if (msg->cursize + buf.cursize > msg->maxsize)
{
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;
if (bits & E_ORIGIN3)
MSG_WriteCoord16i(msg, ent->origin[2]);
}
- else if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
+ else
{
// LordHavoc: have to write flags first, as they can modify protocol
if (bits & E_FLAGS)
MSG_WriteCoord32f(msg, ent->origin[2]);
}
}
- if (sv.protocol == PROTOCOL_DARKPLACES5 && !(ent->flags & RENDER_LOWPRECISION))
+ if ((sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4) && (ent->flags & RENDER_LOWPRECISION))
{
if (bits & E_ANGLE1)
- MSG_WriteAngle16i(msg, ent->angles[0]);
+ MSG_WriteAngle8i(msg, ent->angles[0]);
if (bits & E_ANGLE2)
- MSG_WriteAngle16i(msg, ent->angles[1]);
+ MSG_WriteAngle8i(msg, ent->angles[1]);
if (bits & E_ANGLE3)
- MSG_WriteAngle16i(msg, ent->angles[2]);
+ MSG_WriteAngle8i(msg, ent->angles[2]);
}
else
{
if (bits & E_ANGLE1)
- MSG_WriteAngle8i(msg, ent->angles[0]);
+ MSG_WriteAngle16i(msg, ent->angles[0]);
if (bits & E_ANGLE2)
- MSG_WriteAngle8i(msg, ent->angles[1]);
+ MSG_WriteAngle16i(msg, ent->angles[1]);
if (bits & E_ANGLE3)
- MSG_WriteAngle8i(msg, ent->angles[2]);
+ MSG_WriteAngle16i(msg, ent->angles[2]);
}
if (bits & E_MODEL1)
MSG_WriteByte(msg, ent->modelindex & 0xFF);
if (bits & E_ORIGIN3)
e->origin[2] = MSG_ReadCoord16i();
}
- else if (cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5)
+ else
{
if (bits & E_FLAGS)
e->flags = MSG_ReadByte();
e->origin[2] = MSG_ReadCoord32f();
}
}
- if (cl.protocol == PROTOCOL_DARKPLACES5 && !(e->flags & RENDER_LOWPRECISION))
+ if ((cl.protocol == PROTOCOL_DARKPLACES5 || cl.protocol == PROTOCOL_DARKPLACES6) && !(e->flags & RENDER_LOWPRECISION))
{
if (bits & E_ANGLE1)
e->angles[0] = MSG_ReadAngle16i();
Con_Printf(" E_GLOWSIZE %i", e->glowsize * 4);
if (bits & E_GLOWCOLOR)
Con_Printf(" E_GLOWCOLOR %i", e->glowcolor);
-
+
if (bits & E_LIGHT)
Con_Printf(" E_LIGHT %i:%i:%i:%i", e->light[0], e->light[1], e->light[2], e->light[3]);
- if (bits & E_LIGHTPFLAGS)
+ if (bits & E_LIGHTPFLAGS)
Con_Printf(" E_LIGHTPFLAGS %i", e->lightpflags);
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
void EntityFrame_AckFrame(entityframe_database_t *d, int frame)
{
int i;
- if (d->ackframenum < frame)
- d->ackframenum = frame;
+ d->ackframenum = frame;
for (i = 0;i < d->numframes && d->frames[i].framenum < frame;i++);
// ignore outdated frame acks (out of order packets)
if (i == 0)
EntityFrame_AddFrame(d, eye, d->latestframenum, numstates, states);
- EntityFrame_FetchFrame(d, d->ackframenum > 0 ? d->ackframenum : -1, o);
+ EntityFrame_FetchFrame(d, d->ackframenum, o);
MSG_WriteByte (msg, svc_entities);
MSG_WriteLong (msg, o->framenum);
entity_t *ent;
entityframe_database_t *d;
if (!cl.entitydatabase)
- cl.entitydatabase = EntityFrame_AllocDatabase(cl_entities_mempool);
+ cl.entitydatabase = EntityFrame_AllocDatabase(cl_mempool);
d = cl.entitydatabase;
EntityFrame_Clear(f, NULL, -1);
// read the frame header info
f->time = cl.mtime[0];
number = MSG_ReadLong();
- f->framenum = MSG_ReadLong();
+ for (i = 0;i < LATESTFRAMENUMS-1;i++)
+ cl.latestframenums[i] = cl.latestframenums[i+1];
+ cl.latestframenums[LATESTFRAMENUMS-1] = f->framenum = MSG_ReadLong();
f->eye[0] = MSG_ReadFloat();
f->eye[1] = MSG_ReadFloat();
f->eye[2] = MSG_ReadFloat();
*e = defaultstate;
}
+ if (cl_num_entities <= number)
+ {
+ cl_num_entities = number + 1;
+ if (number >= cl_max_entities)
+ CL_ExpandEntities(number);
+ }
cl_entities_active[number] = true;
e->active = true;
e->time = cl.mtime[0];
}
EntityFrame_AddFrame(d, f->eye, f->framenum, f->numentities, f->entitydata);
- memset(cl_entities_active, 0, cl_max_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++)
+ for (;number < f->entitydata[i].number && number < cl_num_entities;number++)
{
if (cl_entities_active[number])
{
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;
cl_entities_active[number] = true;
number++;
}
- for (;number < cl_max_entities;number++)
+ for (;number < cl_num_entities;number++)
{
if (cl_entities_active[number])
{
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);
- d->ackframenum = -1;
return d;
}
void EntityFrame4_ResetDatabase(entityframe4_database_t *d)
{
int i;
- d->ackframenum = -1;
d->referenceframenum = -1;
for (i = 0;i < MAX_ENTITY_HISTORY;i++)
d->commit[i].numentities = 0;
d->referenceentity[i] = defaultstate;
}
-int EntityFrame4_AckFrame(entityframe4_database_t *d, int framenum)
+int EntityFrame4_AckFrame(entityframe4_database_t *d, int framenum, int servermode)
{
int i, j, found;
entity_database4_commit_t *commit;
d->referenceframenum = -1;
for (i = 0;i < d->maxreferenceentities;i++)
d->referenceentity[i] = defaultstate;
+ // if this is the server, remove commits
+ for (i = 0, commit = d->commit;i < MAX_ENTITY_HISTORY;i++, commit++)
+ commit->numentities = 0;
found = true;
}
else if (d->referenceframenum == framenum)
entity_state_t *s;
entityframe4_database_t *d;
if (!cl.entitydatabase4)
- cl.entitydatabase4 = EntityFrame4_AllocDatabase(cl_entities_mempool);
+ cl.entitydatabase4 = EntityFrame4_AllocDatabase(cl_mempool);
d = cl.entitydatabase4;
// read the number of the frame this refers to
referenceframenum = MSG_ReadLong();
// read the number of this frame
- framenum = MSG_ReadLong();
+ for (i = 0;i < LATESTFRAMENUMS-1;i++)
+ cl.latestframenums[i] = cl.latestframenums[i+1];
+ cl.latestframenums[LATESTFRAMENUMS-1] = framenum = MSG_ReadLong();
// read the start number
enumber = (unsigned short) MSG_ReadShort();
if (developer_networkentities.integer >= 1)
Con_Printf(" %i", d->commit[i].framenum);
Con_Print("\n");
}
- if (!EntityFrame4_AckFrame(d, referenceframenum))
+ if (!EntityFrame4_AckFrame(d, referenceframenum, false))
{
Con_Print("EntityFrame4_CL_ReadFrame: reference frame invalid (VERY BAD ERROR), this update will be skipped\n");
skip = true;
if (!d->commit[i].numentities)
{
d->currentcommit = d->commit + i;
- d->currentcommit->framenum = d->ackframenum = framenum;
+ d->currentcommit->framenum = framenum;
d->currentcommit->numentities = 0;
}
}
}
// 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))
+ {
+ cl_num_entities = cnumber + 1;
+ if (cnumber >= cl_max_entities)
+ CL_ExpandEntities(cnumber);
+ }
// add one (the changed one) if not done
stopnumber = cnumber + !done;
// process entities in range from the last one to the changed one
for (;enumber < stopnumber;enumber++)
{
- if (skip)
+ if (skip || enumber >= cl_num_entities)
{
if (enumber == cnumber && (n & 0x8000) == 0)
{
entity_state_t inactiveentitystate;
int i, n, startnumber;
sizebuf_t buf;
- qbyte data[128];
+ unsigned char data[128];
// 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++)
{
// find the old state to delta from
e = EntityFrame4_GetReferenceEntity(d, n);
entityframe5_database_t *EntityFrame5_AllocDatabase(mempool_t *pool)
{
entityframe5_database_t *d;
- d = Mem_Alloc(pool, sizeof(*d));
+ d = (entityframe5_database_t *)Mem_Alloc(pool, sizeof(*d));
EntityFrame5_ResetDatabase(d);
return d;
}
void EntityFrame5_FreeDatabase(entityframe5_database_t *d)
{
+ // all the [maxedicts] memory is allocated at once, so there's only one
+ // thing to free
+ if (d->maxedicts)
+ Mem_Free(d->deltabits);
Mem_Free(d);
}
int i;
memset(d, 0, sizeof(*d));
d->latestframenum = 0;
- d->ackframenum = -1;
- for (i = 0;i < MAX_EDICTS;i++)
+ for (i = 0;i < d->maxedicts;i++)
d->states[i] = defaultstate;
}
+void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
+{
+ if (d->maxedicts < newmax)
+ {
+ unsigned char *data;
+ int oldmaxedicts = d->maxedicts;
+ int *olddeltabits = d->deltabits;
+ unsigned char *oldpriorities = d->priorities;
+ int *oldupdateframenum = d->updateframenum;
+ entity_state_t *oldstates = d->states;
+ unsigned char *oldvisiblebits = d->visiblebits;
+ d->maxedicts = newmax;
+ 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(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(unsigned char));
+ // the previous buffers were a single allocation, so just one free
+ Mem_Free(olddeltabits);
+ }
+ }
+}
-int EntityState5_Priority(entityframe5_database_t *d, entity_state_t *view, entity_state_t *s, int changedbits, int age)
+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 (!s->active/* && changedbits & E5_FULLUPDATE*/)
+ if (!d->states[stateindex].active/* && changedbits & E5_FULLUPDATE*/)
return E5_PROTOCOL_PRIORITYLEVELS - 1;
// check whole attachment chain to judge relevance to player
+ view = d->states + d->viewentnum;
lowprecision = false;
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;
break;
}
- s = d->states + s->tagentity;
+ stateindex = s->tagentity;
}
if (limit >= 256)
- Con_Printf("Protocol: Runaway loop recursing tagentity links on entity %i\n", s->number);
+ {
+ 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);
else
{
bits = changedbits;
- if ((bits & E5_ORIGIN) && (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_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))
bits |= E5_ORIGIN32;
if ((bits & E5_ANGLES) && !(s->flags & RENDER_LOWPRECISION))
bits |= E5_ANGLES16;
MSG_WriteByte(msg, s->glowsize);
MSG_WriteByte(msg, s->glowcolor);
}
+ if (bits & E5_COLORMOD)
+ {
+ MSG_WriteByte(msg, s->colormod[0]);
+ MSG_WriteByte(msg, s->colormod[1]);
+ MSG_WriteByte(msg, s->colormod[2]);
+ }
}
}
{
if (bits & E5_ANGLES16)
{
- s->angles[0] = MSG_ReadAngle16i();
- s->angles[1] = MSG_ReadAngle16i();
- s->angles[2] = MSG_ReadAngle16i();
+ s->angles[0] = MSG_ReadAngle16i();
+ s->angles[1] = MSG_ReadAngle16i();
+ s->angles[2] = MSG_ReadAngle16i();
}
else
{
- s->angles[0] = MSG_ReadAngle8i();
- s->angles[1] = MSG_ReadAngle8i();
- s->angles[2] = MSG_ReadAngle8i();
+ s->angles[0] = MSG_ReadAngle8i();
+ s->angles[1] = MSG_ReadAngle8i();
+ s->angles[2] = MSG_ReadAngle8i();
}
}
if (bits & E5_MODEL)
s->glowsize = MSG_ReadByte();
s->glowcolor = MSG_ReadByte();
}
+ if (bits & E5_COLORMOD)
+ {
+ s->colormod[0] = MSG_ReadByte();
+ s->colormod[1] = MSG_ReadByte();
+ s->colormod[2] = MSG_ReadByte();
+ }
if (developer_networkentities.integer >= 2)
Con_Printf(" E5_LIGHT %i:%i:%i:%i %i:%i", s->light[0], s->light[1], s->light[2], s->light[3], s->lightstyle, s->lightpflags);
if (bits & E5_GLOW)
Con_Printf(" E5_GLOW %i:%i", s->glowsize * 4, s->glowcolor);
+ if (bits & E5_COLORMOD)
+ Con_Printf(" E5_COLORMOD %f:%f:%f", s->colormod[0] / 32.0f, s->colormod[1] / 32.0f, s->colormod[2] / 32.0f);
Con_Print("\n");
}
}
bits |= E5_LIGHT;
if (o->glowsize != n->glowsize || o->glowcolor != n->glowcolor)
bits |= E5_GLOW;
+ if (o->colormod[0] != n->colormod[0] || o->colormod[1] != n->colormod[1] || o->colormod[2] != n->colormod[2])
+ bits |= E5_COLORMOD;
}
else
if (o->active)
void EntityFrame5_CL_ReadFrame(void)
{
- int n, enumber;
+ int i, n, enumber;
entity_t *ent;
entity_state_t *s;
// read the number of this frame to echo back in next input packet
- cl.latestframenum = MSG_ReadLong();
+ 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();
// 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)
{
- // get the entity number and look it up
+ // get the entity number
enumber = n & 0x7FFF;
+ // we may need to expand the array
+ if (cl_num_entities <= enumber)
+ {
+ cl_num_entities = enumber + 1;
+ if (enumber >= cl_max_entities)
+ CL_ExpandEntities(enumber);
+ }
+ // look up the entity
ent = cl_entities + enumber;
// slide the current into the previous slot
ent->state_previous = ent->state_current;
}
}
-void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum, int viewentnum)
+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;
- if (framenum <= d->ackframenum)
- return;
- d->ackframenum = framenum;
- // scan for packets made obsolete by this ack
+ 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++)
{
- // skip packets that are empty or in the future
- if (p->packetnumber == 0 || p->packetnumber > framenum)
- continue;
- // if the packetnumber matches it is deleted without any processing
- // (since it was received).
- // if the packet number is less than this ack it was lost and its
- // important information will be repeated in this update if it is not
- // already obsolete due to a later update.
- if (p->packetnumber < framenum)
+ if (p->packetnumber && p->packetnumber <= framenum)
{
// packet was lost - merge deltabits into the main array so they
// will be re-sent, but only if there is no newer update of that
{
if (p2->packetnumber > framenum)
{
- for (l = 0, s2 = p2->states;l < p2->numstates;l++, p2++)
+ for (l = 0, s2 = p2->states;l < p2->numstates;l++, s2++)
{
if (s2->number == s->number)
{
// 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, d->states + viewentnum, d->states + s->number, d->deltabits[s->number], d->latestframenum - d->updateframenum[s->number]);
- }
}
+ // 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];
+ 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];
+ }
+ // delete this packet log as it is now obsolete
+ p->packetnumber = 0;
}
- // delete this packet log as it is now obsolete
- p->packetnumber = 0;
}
}
+void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum)
+{
+ int i;
+ // scan for packets made obsolete by this ack and delete them
+ for (i = 0;i < ENTITYFRAME5_MAXPACKETLOGS;i++)
+ if (d->packetlog[i].packetnumber <= 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)
+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 (prog->max_edicts > d->maxedicts)
+ EntityFrame5_ExpandEdicts(d, prog->max_edicts);
+
framenum = d->latestframenum + 1;
+ d->viewentnum = viewentnum;
+
+ // if packet log is full, mark all frames as lost, this will cause
+ // it to send the lost data again
+ for (packetlognumber = 0;packetlognumber < ENTITYFRAME5_MAXPACKETLOGS;packetlognumber++)
+ if (d->packetlog[packetlognumber].packetnumber == 0)
+ break;
+ if (packetlognumber == ENTITYFRAME5_MAXPACKETLOGS)
+ {
+ Con_DPrintf("EntityFrame5_WriteFrame: packetlog overflow for a client, resetting\n");
+ EntityFrame5_LostFrame(d, framenum);
+ packetlognumber = 0;
+ }
// prepare the buffer
memset(&buf, 0, sizeof(buf));
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;
for (i = 0, n = states;i < numstates;i++, n++)
{
CLEARPVSBIT(d->visiblebits, num);
d->deltabits[num] = E5_FULLUPDATE;
- d->priorities[num] = EntityState5_Priority(d, d->states + viewentnum, d->states + num, d->deltabits[num], framenum - d->updateframenum[num]);
+ d->priorities[num] = EntityState5_Priority(d, num);
d->states[num] = defaultstate;
d->states[num].number = num;
}
}
SETPVSBIT(d->visiblebits, num);
d->deltabits[num] |= EntityState5_DeltaBits(d->states + num, n);
- d->priorities[num] = EntityState5_Priority(d, d->states + viewentnum, d->states + num, d->deltabits[num], framenum - d->updateframenum[num]);
+ d->priorities[num] = EntityState5_Priority(d, num);
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
- for (;num < 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, d->states + viewentnum, d->states + num, d->deltabits[num], framenum - d->updateframenum[num]);
+ d->priorities[num] = EntityState5_Priority(d, num);
d->states[num] = defaultstate;
d->states[num].number = num;
}
}
+ // if there isn't at least enough room for an empty svc_entities,
+ // don't bother trying...
+ if (buf.cursize + 11 > buf.maxsize)
+ return;
+
// build lists of entities by priority level
memset(entityframe5_prioritychaincounts, 0, sizeof(entityframe5_prioritychaincounts));
l = 0;
- for (num = 0;num < MAX_EDICTS;num++)
+ for (num = 0;num < d->maxedicts;num++)
{
if (d->priorities[num])
{
}
}
- // return early if there are no entities to send this time
- if (l == 0)
- return;
-
+ // add packetlog entry
+ packetlog = d->packetlog + packetlognumber;
+ packetlog->packetnumber = framenum;
+ packetlog->numstates = 0;
+ // 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 && msg->cursize + 6 + 11 <= msg->maxsize;i++)
+ {
+ if (d->statsdeltabits[i>>3] & (1<<(i&7)))
+ {
+ d->statsdeltabits[i>>3] &= ~(1<<(i&7));
+ packetlog->statsdeltabits[i>>3] |= (1<<(i&7));
+ if (d->stats[i] >= 0 && d->stats[i] < 256)
+ {
+ MSG_WriteByte(msg, svc_updatestatubyte);
+ MSG_WriteByte(msg, i);
+ MSG_WriteByte(msg, d->stats[i]);
+ }
+ else
+ {
+ MSG_WriteByte(msg, svc_updatestat);
+ MSG_WriteByte(msg, i);
+ MSG_WriteLong(msg, d->stats[i]);
+ }
+ }
+ }
+ }
+ // write state updates
d->latestframenum = framenum;
MSG_WriteByte(msg, svc_entities);
MSG_WriteLong(msg, framenum);
-
- // if packet log is full, an empty update is still written
- // (otherwise the client might have nothing to ack to remove packetlogs)
- for (packetlognumber = 0, packetlog = d->packetlog;packetlognumber < ENTITYFRAME5_MAXPACKETLOGS;packetlognumber++, packetlog++)
- if (packetlog->packetnumber == 0)
- break;
- if (packetlognumber < ENTITYFRAME5_MAXPACKETLOGS)
+ 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 && sv.protocol != PROTOCOL_DARKPLACES6)
+ MSG_WriteLong(msg, movesequence);
+ for (priority = E5_PROTOCOL_PRIORITYLEVELS - 1;priority >= 0 && packetlog->numstates < ENTITYFRAME5_MAXSTATES;priority--)
{
- // write to packet and log
- packetlog->packetnumber = framenum;
- packetlog->numstates = 0;
- for (priority = E5_PROTOCOL_PRIORITYLEVELS - 1;priority >= 0 && packetlog->numstates < ENTITYFRAME5_MAXSTATES;priority--)
+ for (i = 0;i < entityframe5_prioritychaincounts[priority] && packetlog->numstates < ENTITYFRAME5_MAXSTATES;i++)
{
- for (i = 0;i < entityframe5_prioritychaincounts[priority] && packetlog->numstates < ENTITYFRAME5_MAXSTATES;i++)
- {
- num = entityframe5_prioritychains[priority][i];
- n = d->states + num;
- if (d->deltabits[num] & E5_FULLUPDATE)
- d->deltabits[num] = E5_FULLUPDATE | EntityState5_DeltaBits(&defaultstate, n);
- buf.cursize = 0;
- EntityState5_WriteUpdate(num, n, d->deltabits[num], &buf);
- // if the entity won't fit, try the next one
- if (msg->cursize + buf.cursize + 2 > msg->maxsize)
- continue;
- // write entity to the packet
- SZ_Write(msg, buf.data, buf.cursize);
- // mark age on entity for prioritization
- d->updateframenum[num] = framenum;
- // log entity so deltabits can be restored later if lost
- packetlog->states[packetlog->numstates].number = num;
- packetlog->states[packetlog->numstates].bits = d->deltabits[num];
- packetlog->numstates++;
- // clear deltabits and priority so it won't be sent again
- d->deltabits[num] = 0;
- d->priorities[num] = 0;
- }
+ num = entityframe5_prioritychains[priority][i];
+ n = d->states + num;
+ if (d->deltabits[num] & E5_FULLUPDATE)
+ d->deltabits[num] = E5_FULLUPDATE | EntityState5_DeltaBits(&defaultstate, n);
+ buf.cursize = 0;
+ EntityState5_WriteUpdate(num, n, d->deltabits[num], &buf);
+ // if the entity won't fit, try the next one
+ if (msg->cursize + buf.cursize + 2 > msg->maxsize)
+ continue;
+ // write entity to the packet
+ SZ_Write(msg, buf.data, buf.cursize);
+ // mark age on entity for prioritization
+ d->updateframenum[num] = framenum;
+ // log entity so deltabits can be restored later if lost
+ packetlog->states[packetlog->numstates].number = num;
+ packetlog->states[packetlog->numstates].bits = d->deltabits[num];
+ packetlog->numstates++;
+ // clear deltabits and priority so it won't be sent again
+ d->deltabits[num] = 0;
+ d->priorities[num] = 0;
}
}
-
MSG_WriteShort(msg, 0x8000);
}
projects / xonotic / darkplaces.git / blobdiff