X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=protocol.c;h=3ae47c56564cdb05b709a3a80b31d68f56db520f;hb=bd172244c077be2f4f13caf8cabd022fcad4bd33;hp=31c2e54c6eeb6b32487706ea6e608c54820afb4f;hpb=79d25017219944e264aadc7ab556c86d3955e4b2;p=xonotic%2Fdarkplaces.git

diff --git a/protocol.c b/protocol.c
index 31c2e54c..3ae47c56 100644
--- a/protocol.c
+++ b/protocol.c
@@ -7,14 +7,7 @@
 	if(developer_networkentities.integer >= 2) \
 	{ \
 		prvm_edict_t *ed = prog->edicts + num; \
-		const char *cname = "(no classname)"; \
-		if(prog->fieldoffsets.classname >= 0) \
-		{ \
-			string_t handle =  PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.classname)->string; \
-			if (handle) \
-				cname = PRVM_GetString(handle); \
-		} \
-		Con_Printf("sent entity update of size %d for a %s\n", (msg->cursize - entityprofiling_startsize), cname); \
+		Con_Printf("sent entity update of size %d for a %s\n", (msg->cursize - entityprofiling_startsize), PRVM_serveredictstring(ed, classname) ? PRVM_GetString(PRVM_serveredictstring(ed, classname)) : "(no classname)"); \
 	}
 
 // this is 88 bytes (must match entity_state_t in protocol.h)
@@ -51,8 +44,6 @@ entity_state_t defaultstate =
 	0,//unsigned char tagindex;
 	{32, 32, 32},//unsigned char colormod[3];
 	{32, 32, 32},//unsigned char glowmod[3];
-	// padding to a multiple of 8 bytes (to align the double time)
-	{0,0}//unsigned char unused[2]; // !
 };
 
 // LordHavoc: I own protocol ranges 96, 97, 3500-3599
@@ -60,54 +51,62 @@ entity_state_t defaultstate =
 struct protocolversioninfo_s
 {
 	int number;
+	protocolversion_t version;
 	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"},
-	{28, "QW"},
-	{10000, "NEHAHRABJP"},
-	{10001, "NEHAHRABJP2"},
-	{10002, "NEHAHRABJP3"},
-	{0, NULL}
+	{ 3504, PROTOCOL_DARKPLACES7 , "DP7"},
+	{ 3503, PROTOCOL_DARKPLACES6 , "DP6"},
+	{ 3502, PROTOCOL_DARKPLACES5 , "DP5"},
+	{ 3501, PROTOCOL_DARKPLACES4 , "DP4"},
+	{ 3500, PROTOCOL_DARKPLACES3 , "DP3"},
+	{   97, PROTOCOL_DARKPLACES2 , "DP2"},
+	{   96, PROTOCOL_DARKPLACES1 , "DP1"},
+	{   15, PROTOCOL_QUAKEDP     , "QUAKEDP"},
+	{   15, PROTOCOL_QUAKE       , "QUAKE"},
+	{   28, PROTOCOL_QUAKEWORLD  , "QW"},
+	{  250, PROTOCOL_NEHAHRAMOVIE, "NEHAHRAMOVIE"},
+	{10000, PROTOCOL_NEHAHRABJP  , "NEHAHRABJP"},
+	{10001, PROTOCOL_NEHAHRABJP2 , "NEHAHRABJP2"},
+	{10002, PROTOCOL_NEHAHRABJP3 , "NEHAHRABJP3"},
+	{    0, PROTOCOL_UNKNOWN     , NULL}
 };
 
 protocolversion_t Protocol_EnumForName(const char *s)
 {
 	int i;
-	for (i = 1;protocolversioninfo[i].name;i++)
+	for (i = 0;protocolversioninfo[i].name;i++)
 		if (!strcasecmp(s, protocolversioninfo[i].name))
-			return (protocolversion_t)i;
+			return protocolversioninfo[i].version;
 	return PROTOCOL_UNKNOWN;
 }
 
 const char *Protocol_NameForEnum(protocolversion_t p)
 {
-	return protocolversioninfo[p].name;
+	int i;
+	for (i = 0;protocolversioninfo[i].name;i++)
+		if (protocolversioninfo[i].version == p)
+			return protocolversioninfo[i].name;
+	return "UNKNOWN";
 }
 
 protocolversion_t Protocol_EnumForNumber(int n)
 {
 	int i;
-	for (i = 1;protocolversioninfo[i].name;i++)
+	for (i = 0;protocolversioninfo[i].name;i++)
 		if (protocolversioninfo[i].number == n)
-			return (protocolversion_t)i;
+			return protocolversioninfo[i].version;
 	return PROTOCOL_UNKNOWN;
 }
 
 int Protocol_NumberForEnum(protocolversion_t p)
 {
-	return protocolversioninfo[p].number;
+	int i;
+	for (i = 0;protocolversioninfo[i].name;i++)
+		if (protocolversioninfo[i].version == p)
+			return protocolversioninfo[i].number;
+	return 0;
 }
 
 void Protocol_Names(char *buffer, size_t buffersize)
@@ -116,7 +115,7 @@ void Protocol_Names(char *buffer, size_t buffersize)
 	if (buffersize < 1)
 		return;
 	buffer[0] = 0;
-	for (i = 1;protocolversioninfo[i].name;i++)
+	for (i = 0;protocolversioninfo[i].name;i++)
 	{
 		if (i > 1)
 			strlcat(buffer, " ", buffersize);
@@ -273,20 +272,15 @@ static void EntityFrameCSQC_LostAllFrames(client_t *client)
 	// mark ALL csqc entities as requiring a FULL resend!
 	// I know this is a bad workaround, but better than nothing.
 	int i, n;
-	prvm_eval_t *val;
 	prvm_edict_t *ed;
 
-	if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
-		return;
-
 	n = client->csqcnumedicts;
 	for(i = 0; i < n; ++i)
 	{
 		if(client->csqcentityglobalhistory[i])
 		{
 			ed = prog->edicts + i;
-			val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
-			if (val->function)
+			if (PRVM_serveredictfunction(ed, SendEntity))
 				client->csqcentitysendflags[i] |= 0xFFFFFF; // FULL RESEND
 			else // if it was ever sent to that client as a CSQC entity
 			{
@@ -299,13 +293,16 @@ static void EntityFrameCSQC_LostAllFrames(client_t *client)
 void EntityFrameCSQC_LostFrame(client_t *client, int framenum)
 {
 	// marks a frame as lost
-	int i, j, n;
+	int i, j;
 	qboolean valid;
 	int ringfirst, ringlast;
 	static int recoversendflags[MAX_EDICTS];
 	csqcentityframedb_t *d;
 
-	n = client->csqcnumedicts;
+	if(client->csqcentityframe_lastreset < 0)
+		return;
+	if(framenum < client->csqcentityframe_lastreset)
+		return; // no action required, as we resent that data anyway
 
 	// is our frame out of history?
 	ringfirst = client->csqcentityframehistory_next; // oldest entry
@@ -337,6 +334,7 @@ void EntityFrameCSQC_LostFrame(client_t *client, int framenum)
 			Con_DPrintf("Lost frame = %d\n", framenum);
 			Con_DPrintf("Entity DB = %d to %d\n", client->csqcentityframehistory[ringfirst].framenum, client->csqcentityframehistory[ringlast].framenum);
 			EntityFrameCSQC_LostAllFrames(client);
+			client->csqcentityframe_lastreset = -1;
 		}
 		return;
 	}
@@ -437,16 +435,14 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
 	qboolean sectionstarted = false;
 	const unsigned short *n;
 	prvm_edict_t *ed;
-	prvm_eval_t *val;
 	client_t *client = svs.clients + sv.writeentitiestoclient_clientnumber;
 	int dbframe = EntityFrameCSQC_AllocFrame(client, framenum);
 	csqcentityframedb_t *db = &client->csqcentityframehistory[dbframe];
 
-	maxsize -= 24; // always fit in an empty svc_entities message (for packet loss detection!)
+	if(client->csqcentityframe_lastreset < 0)
+		client->csqcentityframe_lastreset = framenum;
 
-	// if this server progs is not CSQC-aware, return early
-	if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
-		return false;
+	maxsize -= 24; // always fit in an empty svc_entities message (for packet loss detection!)
 
 	// make sure there is enough room to store the svc_csqcentities byte,
 	// the terminator (0x0000) and at least one entity update
@@ -469,8 +465,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
 			}
 		}
 		ed = prog->edicts + number;
-		val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
-		if (val->function)
+		if (PRVM_serveredictfunction(ed, SendEntity))
 			client->csqcentityscope[number] = 2;
 		else if (client->csqcentityscope[number])
 		{
@@ -499,8 +494,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
 	{
 		number = *n;
 		ed = prog->edicts + number;
-		val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
-		if (val->function)
+		if (PRVM_serveredictfunction(ed, SendEntity))
 			client->csqcentityscope[number] = 2;
 	}
 	*/
@@ -549,8 +543,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
 			// save the cursize value in case we overflow and have to rollback
 			int oldcursize = msg->cursize;
 			client->csqcentityscope[number] = 1;
-			val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
-			if (val->function)
+			if (PRVM_serveredictfunction(ed, SendEntity))
 			{
 				if(!sectionstarted)
 					MSG_WriteByte(msg, svc_csqcentities);
@@ -561,7 +554,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
 					PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
 					PRVM_G_FLOAT(OFS_PARM1) = sendflags;
 					prog->globals.server->self = number;
-					PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
+					PRVM_ExecuteProgram(PRVM_serveredictfunction(ed, SendEntity), "Null SendEntity\n");
 					msg->allowoverflow = false;
 					if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
 					{
@@ -681,14 +674,13 @@ void Protocol_WriteStatsReliable(void)
 }
 
 
-qboolean EntityFrameQuake_WriteFrame(sizebuf_t *msg, int maxsize, int numstates, const entity_state_t *states)
+qboolean EntityFrameQuake_WriteFrame(sizebuf_t *msg, int maxsize, int numstates, const entity_state_t **states)
 {
 	const entity_state_t *s;
 	entity_state_t baseline;
 	int i, bits;
 	sizebuf_t buf;
 	unsigned char data[128];
-	prvm_eval_t *val;
 	qboolean success = false;
 
 	// prepare the buffer
@@ -696,11 +688,11 @@ qboolean EntityFrameQuake_WriteFrame(sizebuf_t *msg, int maxsize, int numstates,
 	buf.data = data;
 	buf.maxsize = sizeof(data);
 
-	for (i = 0, s = states;i < numstates;i++, s++)
+	for (i = 0;i < numstates;i++)
 	{
-		ENTITYSIZEPROFILING_START(msg, s->number);
-		val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity);
-		if(val && val->function)
+		ENTITYSIZEPROFILING_START(msg, states[i]->number);
+		s = states[i];
+		if(PRVM_serveredictfunction((&prog->edicts[s->number]), SendEntity))
 			continue;
 
 		// prepare the buffer
@@ -1217,6 +1209,8 @@ void EntityState_ReadFields(entity_state_t *e, unsigned int bits)
 	}
 }
 
+extern void CL_NewFrameReceived(int num);
+
 // (client and server) allocates a new empty database
 entityframe_database_t *EntityFrame_AllocDatabase(mempool_t *mempool)
 {
@@ -1282,8 +1276,60 @@ void EntityFrame_FetchFrame(entityframe_database_t *d, int framenum, entity_fram
 	}
 }
 
-// (server and client) adds a entity_frame to the database, for future reference
-void EntityFrame_AddFrame(entityframe_database_t *d, vec3_t eye, int framenum, int numentities, const entity_state_t *entitydata)
+// (client) adds a entity_frame to the database, for future reference
+void EntityFrame_AddFrame_Client(entityframe_database_t *d, vec3_t eye, int framenum, int numentities, const entity_state_t *entitydata)
+{
+	int n, e;
+	entity_frameinfo_t *info;
+
+	VectorCopy(eye, d->eye);
+
+	// figure out how many entity slots are used already
+	if (d->numframes)
+	{
+		n = d->frames[d->numframes - 1].endentity - d->frames[0].firstentity;
+		if (n + numentities > MAX_ENTITY_DATABASE || d->numframes >= MAX_ENTITY_HISTORY)
+		{
+			// ran out of room, dump database
+			EntityFrame_ClearDatabase(d);
+		}
+	}
+
+	info = &d->frames[d->numframes];
+	info->framenum = framenum;
+	e = -1000;
+	// make sure we check the newly added frame as well, but we haven't incremented numframes yet
+	for (n = 0;n <= d->numframes;n++)
+	{
+		if (e >= d->frames[n].framenum)
+		{
+			if (e == framenum)
+				Con_Print("EntityFrame_AddFrame: tried to add out of sequence frame to database\n");
+			else
+				Con_Print("EntityFrame_AddFrame: out of sequence frames in database\n");
+			return;
+		}
+		e = d->frames[n].framenum;
+	}
+	// if database still has frames after that...
+	if (d->numframes)
+		info->firstentity = d->frames[d->numframes - 1].endentity;
+	else
+		info->firstentity = 0;
+	info->endentity = info->firstentity + numentities;
+	d->numframes++;
+
+	n = info->firstentity % MAX_ENTITY_DATABASE;
+	e = MAX_ENTITY_DATABASE - n;
+	if (e > numentities)
+		e = numentities;
+	memcpy(d->entitydata + n, entitydata, sizeof(entity_state_t) * e);
+	if (numentities > e)
+		memcpy(d->entitydata, entitydata + e, sizeof(entity_state_t) * (numentities - e));
+}
+
+// (server) adds a entity_frame to the database, for future reference
+void EntityFrame_AddFrame_Server(entityframe_database_t *d, vec3_t eye, int framenum, int numentities, const entity_state_t **entitydata)
 {
 	int n, e;
 	entity_frameinfo_t *info;
@@ -1335,27 +1381,27 @@ void EntityFrame_AddFrame(entityframe_database_t *d, vec3_t eye, int framenum, i
 }
 
 // (server) writes a frame to network stream
-qboolean EntityFrame_WriteFrame(sizebuf_t *msg, int maxsize, entityframe_database_t *d, int numstates, const entity_state_t *states, int viewentnum)
+qboolean EntityFrame_WriteFrame(sizebuf_t *msg, int maxsize, entityframe_database_t *d, int numstates, const entity_state_t **states, int viewentnum)
 {
 	int i, onum, number;
 	entity_frame_t *o = &d->deltaframe;
 	const entity_state_t *ent, *delta;
 	vec3_t eye;
-	prvm_eval_t *val;
 
 	d->latestframenum++;
 
 	VectorClear(eye);
 	for (i = 0;i < numstates;i++)
 	{
-		if (states[i].number == viewentnum)
+		ent = states[i];
+		if (ent->number == viewentnum)
 		{
-			VectorSet(eye, states[i].origin[0], states[i].origin[1], states[i].origin[2] + 22);
+			VectorSet(eye, ent->origin[0], ent->origin[1], ent->origin[2] + 22);
 			break;
 		}
 	}
 
-	EntityFrame_AddFrame(d, eye, d->latestframenum, numstates, states);
+	EntityFrame_AddFrame_Server(d, eye, d->latestframenum, numstates, states);
 
 	EntityFrame_FetchFrame(d, d->ackframenum, o);
 
@@ -1369,11 +1415,10 @@ qboolean EntityFrame_WriteFrame(sizebuf_t *msg, int maxsize, entityframe_databas
 	onum = 0;
 	for (i = 0;i < numstates;i++)
 	{
-		ent = states + i;
+		ent = states[i];
 		number = ent->number;
 
-		val = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.SendEntity);
-		if(val && val->function)
+		if (PRVM_serveredictfunction((&prog->edicts[number]), SendEntity))
 			continue;
 		for (;onum < o->numentities && o->entitydata[onum].number < number;onum++)
 		{
@@ -1423,9 +1468,8 @@ void EntityFrame_CL_ReadFrame(void)
 	// read the frame header info
 	f->time = cl.mtime[0];
 	number = 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->framenum = MSG_ReadLong();
+	CL_NewFrameReceived(f->framenum);
 	f->eye[0] = MSG_ReadFloat();
 	f->eye[1] = MSG_ReadFloat();
 	f->eye[2] = MSG_ReadFloat();
@@ -1497,7 +1541,7 @@ void EntityFrame_CL_ReadFrame(void)
 		f->entitydata[f->numentities] = *old++;
 		f->entitydata[f->numentities++].time = cl.mtime[0];
 	}
-	EntityFrame_AddFrame(d, f->eye, f->framenum, f->numentities, f->entitydata);
+	EntityFrame_AddFrame_Client(d, f->eye, f->framenum, f->numentities, f->entitydata);
 
 	memset(cl.entities_active, 0, cl.num_entities * sizeof(unsigned char));
 	number = 1;
@@ -1690,9 +1734,8 @@ void EntityFrame4_CL_ReadFrame(void)
 	// read the number of the frame this refers to
 	referenceframenum = MSG_ReadLong();
 	// read the number of this frame
-	for (i = 0;i < LATESTFRAMENUMS-1;i++)
-		cl.latestframenums[i] = cl.latestframenums[i+1];
-	cl.latestframenums[LATESTFRAMENUMS-1] = framenum = MSG_ReadLong();
+	framenum = MSG_ReadLong();
+	CL_NewFrameReceived(framenum);
 	// read the start number
 	enumber = (unsigned short) MSG_ReadShort();
 	if (developer_networkentities.integer >= 10)
@@ -1813,14 +1856,13 @@ void EntityFrame4_CL_ReadFrame(void)
 		EntityFrame4_ResetDatabase(d);
 }
 
-qboolean EntityFrame4_WriteFrame(sizebuf_t *msg, int maxsize, entityframe4_database_t *d, int numstates, const entity_state_t *states)
+qboolean EntityFrame4_WriteFrame(sizebuf_t *msg, int maxsize, entityframe4_database_t *d, int numstates, const entity_state_t **states)
 {
 	const entity_state_t *e, *s;
 	entity_state_t inactiveentitystate;
 	int i, n, startnumber;
 	sizebuf_t buf;
 	unsigned char data[128];
-	prvm_eval_t *val;
 
 	// if there isn't enough space to accomplish anything, skip it
 	if (msg->cursize + 24 > maxsize)
@@ -1865,8 +1907,7 @@ qboolean EntityFrame4_WriteFrame(sizebuf_t *msg, int maxsize, entityframe4_datab
 	d->currententitynumber = 1;
 	for (i = 0, n = startnumber;n < prog->max_edicts;n++)
 	{
-		val = PRVM_EDICTFIELDVALUE((&prog->edicts[n]), prog->fieldoffsets.SendEntity);
-		if(val && val->function)
+		if (PRVM_serveredictfunction((&prog->edicts[n]), SendEntity))
 			continue;
 		// find the old state to delta from
 		e = EntityFrame4_GetReferenceEntity(d, n);
@@ -1874,9 +1915,9 @@ qboolean EntityFrame4_WriteFrame(sizebuf_t *msg, int maxsize, entityframe4_datab
 		SZ_Clear(&buf);
 		// entity exists, build an update (if empty there is no change)
 		// find the state in the list
-		for (;i < numstates && states[i].number < n;i++);
+		for (;i < numstates && states[i]->number < n;i++);
 		// make the message
-		s = states + i;
+		s = states[i];
 		if (s->number == n)
 		{
 			// build the update
@@ -1976,7 +2017,7 @@ static void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
 static int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
 {
 	int limit, priority;
-	entity_state_t *s;
+	entity_state_t *s = NULL; // hush compiler warning by initializing this
 	// if it is the player, update urgently
 	if (stateindex == d->viewentnum)
 		return ENTITYFRAME5_PRIORITYLEVELS - 1;
@@ -2022,9 +2063,7 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi
 	//dp_model_t *model;
 	ENTITYSIZEPROFILING_START(msg, s->number);
 
-	prvm_eval_t *val;
-	val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity);
-	if(val && val->function)
+	if (PRVM_serveredictfunction((&prog->edicts[s->number]), SendEntity))
 		return;
 
 	if (s->active != ACTIVE_NETWORK)
@@ -2165,11 +2204,80 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi
 			MSG_WriteByte(msg, s->glowmod[1]);
 			MSG_WriteByte(msg, s->glowmod[2]);
 		}
+		if (bits & E5_COMPLEXANIMATION)
+		{
+			if (s->skeletonobject.model && s->skeletonobject.relativetransforms)
+			{
+				int numbones = s->skeletonobject.model->num_bones;
+				int bonenum;
+				short pose6s[6];
+				MSG_WriteByte(msg, 4);
+				MSG_WriteShort(msg, s->modelindex);
+				MSG_WriteByte(msg, numbones);
+				for (bonenum = 0;bonenum < numbones;bonenum++)
+				{
+					Matrix4x4_ToBonePose6s(s->skeletonobject.relativetransforms + bonenum, 64, pose6s);
+					MSG_WriteShort(msg, pose6s[0]);
+					MSG_WriteShort(msg, pose6s[1]);
+					MSG_WriteShort(msg, pose6s[2]);
+					MSG_WriteShort(msg, pose6s[3]);
+					MSG_WriteShort(msg, pose6s[4]);
+					MSG_WriteShort(msg, pose6s[5]);
+				}
+			}
+			else if (s->framegroupblend[3].lerp > 0)
+			{
+				MSG_WriteByte(msg, 3);
+				MSG_WriteShort(msg, s->framegroupblend[0].frame);
+				MSG_WriteShort(msg, s->framegroupblend[1].frame);
+				MSG_WriteShort(msg, s->framegroupblend[2].frame);
+				MSG_WriteShort(msg, s->framegroupblend[3].frame);
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[0].start) * 1000.0));
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[1].start) * 1000.0));
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[2].start) * 1000.0));
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[3].start) * 1000.0));
+				MSG_WriteByte(msg, s->framegroupblend[0].lerp * 255.0f);
+				MSG_WriteByte(msg, s->framegroupblend[1].lerp * 255.0f);
+				MSG_WriteByte(msg, s->framegroupblend[2].lerp * 255.0f);
+				MSG_WriteByte(msg, s->framegroupblend[3].lerp * 255.0f);
+			}
+			else if (s->framegroupblend[2].lerp > 0)
+			{
+				MSG_WriteByte(msg, 2);
+				MSG_WriteShort(msg, s->framegroupblend[0].frame);
+				MSG_WriteShort(msg, s->framegroupblend[1].frame);
+				MSG_WriteShort(msg, s->framegroupblend[2].frame);
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[0].start) * 1000.0));
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[1].start) * 1000.0));
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[2].start) * 1000.0));
+				MSG_WriteByte(msg, s->framegroupblend[0].lerp * 255.0f);
+				MSG_WriteByte(msg, s->framegroupblend[1].lerp * 255.0f);
+				MSG_WriteByte(msg, s->framegroupblend[2].lerp * 255.0f);
+			}
+			else if (s->framegroupblend[1].lerp > 0)
+			{
+				MSG_WriteByte(msg, 1);
+				MSG_WriteShort(msg, s->framegroupblend[0].frame);
+				MSG_WriteShort(msg, s->framegroupblend[1].frame);
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[0].start) * 1000.0));
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[1].start) * 1000.0));
+				MSG_WriteByte(msg, s->framegroupblend[0].lerp * 255.0f);
+				MSG_WriteByte(msg, s->framegroupblend[1].lerp * 255.0f);
+			}
+			else
+			{
+				MSG_WriteByte(msg, 0);
+				MSG_WriteShort(msg, s->framegroupblend[0].frame);
+				MSG_WriteShort(msg, (int)((sv.time - s->framegroupblend[0].start) * 1000.0));
+			}
+		}
 	}
 
 	ENTITYSIZEPROFILING_END(msg, s->number);
 }
 
+extern dp_model_t *CL_GetModelByIndex(int modelindex);
+
 static void EntityState5_ReadUpdate(entity_state_t *s, int number)
 {
 	int bits;
@@ -2283,6 +2391,107 @@ static void EntityState5_ReadUpdate(entity_state_t *s, int number)
 		s->glowmod[1] = MSG_ReadByte();
 		s->glowmod[2] = MSG_ReadByte();
 	}
+	if (bits & E5_COMPLEXANIMATION)
+	{
+		skeleton_t *skeleton;
+		const dp_model_t *model;
+		int modelindex;
+		int type;
+		int bonenum;
+		int numbones;
+		short pose6s[6];
+		type = MSG_ReadByte();
+		switch(type)
+		{
+		case 0:
+			s->framegroupblend[0].frame = MSG_ReadShort();
+			s->framegroupblend[1].frame = 0;
+			s->framegroupblend[2].frame = 0;
+			s->framegroupblend[3].frame = 0;
+			s->framegroupblend[0].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[1].start = 0;
+			s->framegroupblend[2].start = 0;
+			s->framegroupblend[3].start = 0;
+			s->framegroupblend[0].lerp = 1;
+			s->framegroupblend[1].lerp = 0;
+			s->framegroupblend[2].lerp = 0;
+			s->framegroupblend[3].lerp = 0;
+			break;
+		case 1:
+			s->framegroupblend[0].frame = MSG_ReadShort();
+			s->framegroupblend[1].frame = MSG_ReadShort();
+			s->framegroupblend[2].frame = 0;
+			s->framegroupblend[3].frame = 0;
+			s->framegroupblend[0].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[1].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[2].start = 0;
+			s->framegroupblend[3].start = 0;
+			s->framegroupblend[0].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[1].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[2].lerp = 0;
+			s->framegroupblend[3].lerp = 0;
+			break;
+		case 2:
+			s->framegroupblend[0].frame = MSG_ReadShort();
+			s->framegroupblend[1].frame = MSG_ReadShort();
+			s->framegroupblend[2].frame = MSG_ReadShort();
+			s->framegroupblend[3].frame = 0;
+			s->framegroupblend[0].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[1].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[2].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[3].start = 0;
+			s->framegroupblend[0].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[1].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[2].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[3].lerp = 0;
+			break;
+		case 3:
+			s->framegroupblend[0].frame = MSG_ReadShort();
+			s->framegroupblend[1].frame = MSG_ReadShort();
+			s->framegroupblend[2].frame = MSG_ReadShort();
+			s->framegroupblend[3].frame = MSG_ReadShort();
+			s->framegroupblend[0].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[1].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[2].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[3].start = cl.time - (short)MSG_ReadShort() * (1.0f / 1000.0f);
+			s->framegroupblend[0].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[1].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[2].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			s->framegroupblend[3].lerp = MSG_ReadByte() * (1.0f / 255.0f);
+			break;
+		case 4:
+			if (!cl.engineskeletonobjects)
+				cl.engineskeletonobjects = (skeleton_t *) Mem_Alloc(cls.levelmempool, sizeof(*cl.engineskeletonobjects) * MAX_EDICTS);
+			skeleton = &cl.engineskeletonobjects[number];
+			modelindex = MSG_ReadShort();
+			model = CL_GetModelByIndex(modelindex);
+			numbones = MSG_ReadByte();
+			if (model && numbones != model->num_bones)
+				Host_Error("E5_COMPLEXANIMATION: model has different number of bones than network packet describes\n");
+			if (!skeleton->relativetransforms || skeleton->model != model)
+			{
+				skeleton->model = model;
+				skeleton->relativetransforms = (matrix4x4_t *) Mem_Realloc(cls.levelmempool, skeleton->relativetransforms, sizeof(*skeleton->relativetransforms) * skeleton->model->num_bones);
+				for (bonenum = 0;bonenum < model->num_bones;bonenum++)
+					skeleton->relativetransforms[bonenum] = identitymatrix;
+			}
+			for (bonenum = 0;bonenum < numbones;bonenum++)
+			{
+				pose6s[0] = (short)MSG_ReadShort();
+				pose6s[1] = (short)MSG_ReadShort();
+				pose6s[2] = (short)MSG_ReadShort();
+				pose6s[3] = (short)MSG_ReadShort();
+				pose6s[4] = (short)MSG_ReadShort();
+				pose6s[5] = (short)MSG_ReadShort();
+				Matrix4x4_FromBonePose6s(skeleton->relativetransforms + bonenum, 1.0f / 64.0f, pose6s);
+			}
+			s->skeletonobject = *skeleton;
+			break;
+		default:
+			Host_Error("E5_COMPLEXANIMATION: Parse error - unknown type %i\n", type);
+			break;
+		}
+	}
 
 
 	if (developer_networkentities.integer >= 2)
@@ -2381,6 +2590,8 @@ static int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t
 			bits |= E5_COLORMOD;
 		if (o->glowmod[0] != n->glowmod[0] || o->glowmod[1] != n->glowmod[1] || o->glowmod[2] != n->glowmod[2])
 			bits |= E5_GLOWMOD;
+		if (n->flags & RENDER_COMPLEXANIMATION)
+			bits |= E5_COMPLEXANIMATION;
 	}
 	else
 		if (o->active == ACTIVE_NETWORK)
@@ -2390,15 +2601,12 @@ static int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t
 
 void EntityFrame5_CL_ReadFrame(void)
 {
-	int i, n, enumber;
+	int n, enumber, framenum;
 	entity_t *ent;
 	entity_state_t *s;
 	// read the number of this frame to echo back in next input packet
-	for (i = 0;i < LATESTFRAMENUMS-1;i++)
-		cl.latestframenums[i] = cl.latestframenums[i+1];
-	cl.latestframenums[LATESTFRAMENUMS-1] = MSG_ReadLong();
-	if (developer_networkentities.integer >= 10)
-		Con_Printf("recv: svc_entities %i\n", cl.latestframenums[LATESTFRAMENUMS-1]);
+	framenum = MSG_ReadLong();
+	CL_NewFrameReceived(framenum);
 	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
@@ -2450,68 +2658,72 @@ void EntityFrame5_CL_ReadFrame(void)
 	}
 }
 
+static int packetlog5cmp(const void *a_, const void *b_)
+{
+	const entityframe5_packetlog_t *a = (const entityframe5_packetlog_t *) a_;
+	const entityframe5_packetlog_t *b = (const entityframe5_packetlog_t *) b_;
+	return a->packetnumber - b->packetnumber;
+}
+
 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;
-	unsigned char statsdeltabits[(MAX_CL_STATS+7)/8];
-	// scan for packets that were lost
+	int i, j, l, bits;
+	entityframe5_changestate_t *s;
+	entityframe5_packetlog_t *p;
+	static unsigned char statsdeltabits[(MAX_CL_STATS+7)/8];
+	static int deltabits[MAX_EDICTS];
+	entityframe5_packetlog_t *packetlogs[ENTITYFRAME5_MAXPACKETLOGS];
+
 	for (i = 0, p = d->packetlog;i < ENTITYFRAME5_MAXPACKETLOGS;i++, p++)
+		packetlogs[i] = p;
+	qsort(packetlogs, sizeof(*packetlogs), ENTITYFRAME5_MAXPACKETLOGS, packetlog5cmp);
+
+	memset(deltabits, 0, sizeof(deltabits));
+	memset(statsdeltabits, 0, sizeof(statsdeltabits));
+	for (i = 0; i < ENTITYFRAME5_MAXPACKETLOGS; i++)
 	{
-		if (p->packetnumber && p->packetnumber <= framenum)
+		p = packetlogs[i];
+
+		if (!p->packetnumber)
+			continue;
+
+		if (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
-			// bit in the logs (as those will arrive before this update)
 			for (j = 0, s = p->states;j < p->numstates;j++, s++)
-			{
-				// check for any newer updates to this entity and mask off any
-				// overlapping bits (we don't need to send something again if
-				// it has already been sent more recently)
-				bits = s->bits & ~d->deltabits[s->number];
-				for (k = 0, p2 = d->packetlog;k < ENTITYFRAME5_MAXPACKETLOGS && bits;k++, p2++)
-				{
-					if (p2->packetnumber > framenum)
-					{
-						for (l = 0, s2 = p2->states;l < p2->numstates;l++, s2++)
-						{
-							if (s2->number == s->number)
-							{
-								bits &= ~s2->bits;
-								break;
-							}
-						}
-					}
-				}
-				// 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] & ~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++)
-					host_client->statsdeltabits[l] |= statsdeltabits[l];
-			}
-			// delete this packet log as it is now obsolete
+				deltabits[s->number] |= s->bits;
+
+			for (l = 0;l < (MAX_CL_STATS+7)/8;l++)
+				statsdeltabits[l] |= p->statsdeltabits[l];
+
 			p->packetnumber = 0;
 		}
+		else
+		{
+			for (j = 0, s = p->states;j < p->numstates;j++, s++)
+				deltabits[s->number] &= ~s->bits;
+			for (l = 0;l < (MAX_CL_STATS+7)/8;l++)
+				statsdeltabits[l] &= ~p->statsdeltabits[l];
+		}
 	}
+
+	for(i = 0; i < d->maxedicts; ++i)
+	{
+		bits = deltabits[i] & ~d->deltabits[i];
+		if(bits)
+		{
+			d->deltabits[i] |= bits;
+			// if it was a very important update, set priority higher
+			if (bits & (E5_FULLUPDATE | E5_ATTACHMENT | E5_MODEL | E5_COLORMAP))
+				d->priorities[i] = max(d->priorities[i], 4);
+			else
+				d->priorities[i] = max(d->priorities[i], 1);
+		}
+	}
+
+	for (l = 0;l < (MAX_CL_STATS+7)/8;l++)
+		host_client->statsdeltabits[l] |= statsdeltabits[l];
+		// no need to mask out the already-set bits here, as we do not
+		// do that priorities stuff
 }
 
 void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum)
@@ -2523,7 +2735,7 @@ void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum)
 			d->packetlog[i].packetnumber = 0;
 }
 
-qboolean EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int movesequence, qboolean need_empty)
+qboolean EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_database_t *d, int numstates, const entity_state_t **states, int viewentnum, int movesequence, qboolean need_empty)
 {
 	const entity_state_t *n;
 	int i, num, l, framenum, packetlognumber, priority;
@@ -2556,8 +2768,9 @@ qboolean EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_datab
 
 	// detect changes in states
 	num = 1;
-	for (i = 0, n = states;i < numstates;i++, n++)
+	for (i = 0;i < numstates;i++)
 	{
+		n = states[i];
 		// mark gaps in entity numbering as removed entities
 		for (;num < n->number;num++)
 		{
@@ -2810,10 +3023,10 @@ void EntityStateQW_ReadPlayerUpdate(void)
 		if (bits & QW_CM_UP)
 			MSG_ReadShort(); // cmd->upmove
 		if (bits & QW_CM_BUTTONS)
-			MSG_ReadByte(); // cmd->buttons
+			(void) MSG_ReadByte(); // cmd->buttons
 		if (bits & QW_CM_IMPULSE)
-			MSG_ReadByte(); // cmd->impulse
-		MSG_ReadByte(); // cmd->msec
+			(void) MSG_ReadByte(); // cmd->impulse
+		(void) MSG_ReadByte(); // cmd->msec
 	}
 	if (playerflags & QW_PF_VELOCITY1)
 		velocity[0] = MSG_ReadShort();