X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=protocol.c;h=d4931797b4aba6fedc29b87861bd0529af0e1972;hb=a01a9e9674ca2ebc42ff21b3d154cebfede90dab;hp=848ad7c7f2357bdab1682b6e501e413c6fdef396;hpb=9e883a148a3370e139b78a19d2ee645fba8db8d1;p=xonotic%2Fdarkplaces.git

diff --git a/protocol.c b/protocol.c
index 848ad7c7..d4931797 100644
--- a/protocol.c
+++ b/protocol.c
@@ -1,6 +1,22 @@
-
 #include "quakedef.h"
 
+#define ENTITYSIZEPROFILING_START(msg, num) \
+	int entityprofiling_startsize = msg->cursize
+
+#define ENTITYSIZEPROFILING_END(msg, num) \
+	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); \
+	}
+
 // this is 88 bytes (must match entity_state_t in protocol.h)
 entity_state_t defaultstate =
 {
@@ -9,11 +25,17 @@ entity_state_t defaultstate =
 	{0,0,0},//float netcenter[3]; // ! for network prioritization, this is the center of the bounding box (which may differ from the origin)
 	{0,0,0},//float origin[3];
 	{0,0,0},//float angles[3];
-	0,//int number; // entity number this state is for
 	0,//int effects;
+	0,//unsigned int customizeentityforclient; // !
+	0,//unsigned short number; // entity number this state is for
 	0,//unsigned short modelindex;
 	0,//unsigned short frame;
 	0,//unsigned short tagentity;
+	0,//unsigned short specialvisibilityradius; // ! larger if it has effects/light
+	0,//unsigned short viewmodelforclient; // !
+	0,//unsigned short exteriormodelforclient; // ! not shown if first person viewing from this entity, shown in all other cases
+	0,//unsigned short nodrawtoclient; // !
+	0,//unsigned short drawonlytoclient; // !
 	{0,0,0,0},//unsigned short light[4]; // color*256 (0.00 to 255.996), and radius*1
 	0,//unsigned char active; // true if a valid state
 	0,//unsigned char lightstyle;
@@ -29,7 +51,7 @@ entity_state_t defaultstate =
 	0,//unsigned char tagindex;
 	{32, 32, 32},//unsigned char colormod[3];
 	// padding to a multiple of 8 bytes (to align the double time)
-	0//unsigned char unused; // !
+	{0,0,0,0,0}//unsigned char unused[5]; // !
 };
 
 // LordHavoc: I own protocol ranges 96, 97, 3500-3599
@@ -52,7 +74,10 @@ protocolversioninfo[] =
 	{15, "QUAKEDP"},
 	{250, "NEHAHRAMOVIE"},
 	{15, "QUAKE"},
-	{28, "QUAKEWORLD"},
+	{28, "QW"},
+	{10000, "NEHAHRABJP"},
+	{10001, "NEHAHRABJP2"},
+	{10002, "NEHAHRABJP3"},
 	{0, NULL}
 };
 
@@ -93,8 +118,8 @@ void Protocol_Names(char *buffer, size_t buffersize)
 	for (i = 1;protocolversioninfo[i].name;i++)
 	{
 		if (i > 1)
-			strlcat(buffer, " ", sizeof(buffer));
-		strlcat(buffer, protocolversioninfo[i].name, sizeof(buffer));
+			strlcat(buffer, " ", buffersize);
+		strlcat(buffer, protocolversioninfo[i].name, buffersize);
 	}
 }
 
@@ -149,7 +174,13 @@ void EntityFrameQuake_ReadEntity(int bits)
 	s.number = num;
 	s.time = cl.mtime[0];
 	s.flags = 0;
-	if (bits & U_MODEL)		s.modelindex = (s.modelindex & 0xFF00) | MSG_ReadByte();
+	if (bits & U_MODEL)
+	{
+		if (cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3)
+							s.modelindex = (unsigned short) MSG_ReadShort();
+		else
+							s.modelindex = (s.modelindex & 0xFF00) | MSG_ReadByte();
+	}
 	if (bits & U_FRAME)		s.frame = (s.frame & 0xFF00) | MSG_ReadByte();
 	if (bits & U_COLORMAP)	s.colormap = MSG_ReadByte();
 	if (bits & U_SKIN)		s.skin = MSG_ReadByte();
@@ -232,145 +263,340 @@ void EntityFrameQuake_ISeeDeadEntities(void)
 	}
 }
 
-// FIXME FIXME FIXME: at this time the CSQC entity writing does not store
-// packet logs and thus if an update is lost it is never repeated, this makes
-// csqc entities useless at the moment.
+// NOTE: this only works with DP5 protocol and upwards. For lower protocols
+// (including QUAKE), no packet loss handling for CSQC is done, which makes
+// CSQC basically useless.
+// Always use the DP5 protocol, or a higher one, when using CSQC entities.
+static void EntityFrameCSQC_LostAllFrames(client_t *client)
+{
+	// mark ALL csqc entities as requiring a FULL resend!
+	// I know this is a bad workaround, but better than nothing.
+	int i, n;
+	prvm_eval_t *val;
+	prvm_edict_t *ed;
+
+	if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
+		return;
 
-void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, qboolean *sectionstarted)
+	n = client->csqcnumedicts;
+	for(i = 0; i < n; ++i)
+	{
+		if(client->csqcentityglobalhistory[i])
+		{
+			ed = prog->edicts + i;
+			val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
+			if (val->function)
+				client->csqcentitysendflags[i] |= 0xFFFFFF; // FULL RESEND
+			else // if it was ever sent to that client as a CSQC entity
+			{
+				client->csqcentityscope[i] = 1; // REMOVE
+				client->csqcentitysendflags[i] |= 0xFFFFFF;
+			}
+		}
+	}
+}
+void EntityFrameCSQC_LostFrame(client_t *client, int framenum)
 {
-	int version;
-	prvm_eval_t *val, *val2;
-	version = 0;
-	if (doupdate)
+	// marks a frame as lost
+	int i, j, n;
+	qboolean valid;
+	int ringfirst, ringlast;
+	int recoversendflags[MAX_EDICTS];
+	csqcentityframedb_t *d;
+
+	n = client->csqcnumedicts;
+
+	// is our frame out of history?
+	ringfirst = client->csqcentityframehistory_next; // oldest entry
+	ringlast = (ringfirst + NUM_CSQCENTITYDB_FRAMES - 1) % NUM_CSQCENTITYDB_FRAMES; // most recently added entry
+
+	valid = false;
+	
+	for(j = 0; j < NUM_CSQCENTITYDB_FRAMES; ++j)
 	{
-		if (msg->cursize + !*sectionstarted + 2 + 1 + 2 > msg->maxsize)
+		d = &client->csqcentityframehistory[(ringfirst + j) % NUM_CSQCENTITYDB_FRAMES];
+		if(d->framenum < 0)
+			continue;
+		if(d->framenum == framenum)
+			break;
+		else if(d->framenum < framenum)
+			valid = true;
+	}
+	if(j == NUM_CSQCENTITYDB_FRAMES)
+	{
+		if(valid) // got beaten, i.e. there is a frame < framenum
+		{
+			// a non-csqc frame got lost... great
 			return;
-		val2 = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.Version);
-		version = (int)val2->_float;
-		// LordHavoc: do some validity checks on self.Version
-		// if self.Version reaches 255, it will soon exceed the byte used to
-		// store an entity version in the client struct, so we need to reset
-		// all the version to 1 and force all the existing clients' version of
-		// it to 255 (which we're not allowing to actually occur)
-		if (version < 0)
-			val2->_float = 0;
-		if (version >= 255)
-		{
-			int i;
-			val2->_float = version = 1;
-			// since we just reset the Version field to 1, it may accidentally
-			// end up being equal to an existing client version now or in the
-			// future, so to fix this situation we have to loop over all
-			// clients and change their versions for this entity to be -1
-			// which never matches, thus causing them to receive the update
-			// soon, as they should
-			for (i = 0;i < svs.maxclients;i++)
-				if (svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number])
-					svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] = 255;
-		}
-	}
-	// if the version already matches, we don't need to do anything as the
-	// latest version has already been sent.
-	if (svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] == version)
+		}
+		else
+		{
+			// a too old frame got lost... sorry, cannot handle this
+			Con_DPrintf("CSQC entity DB: lost a frame too early to do any handling (resending ALL)...\n");
+			Con_DPrintf("Lost frame = %d\n", framenum);
+			Con_DPrintf("Entity DB = %d to %d\n", client->csqcentityframehistory[ringfirst].framenum, client->csqcentityframehistory[ringlast].framenum);
+			EntityFrameCSQC_LostAllFrames(client);
+		}
 		return;
-	if (version)
+	}
+
+	// so j is the frame that got lost
+	// ringlast is the frame that we have to go to
+	ringfirst = (ringfirst + j) % NUM_CSQCENTITYDB_FRAMES;
+	if(ringlast < ringfirst)
+		ringlast += NUM_CSQCENTITYDB_FRAMES;
+	
+	memset(recoversendflags, 0, sizeof(recoversendflags));
+
+	for(j = ringfirst; j <= ringlast; ++j)
 	{
-		// if there's no SendEntity function, treat it as a remove
-		val = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.SendEntity);
-		if (val->function)
+		d = &client->csqcentityframehistory[j % NUM_CSQCENTITYDB_FRAMES];
+		if(d->framenum < 0)
 		{
-			// there is a function to call, save the cursize value incase we
-			// have to do a rollback due to overflow
-			int oldcursize = msg->cursize;
-			if(!*sectionstarted)
-				MSG_WriteByte(msg, svc_csqcentities);
-			MSG_WriteShort(msg, number);
-			((int *)prog->globals.generic)[OFS_PARM0] = sv.writeentitiestoclient_cliententitynumber;
-			prog->globals.server->self = number;
-			PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
-			if(prog->globals.generic[OFS_RETURN])
+			// deleted frame
+		}
+		else if(d->framenum < framenum)
+		{
+			// a frame in the past... should never happen
+			Con_Printf("CSQC entity DB encountered a frame from the past when recovering from PL...?\n");
+		}
+		else if(d->framenum == framenum)
+		{
+			// handling the actually lost frame now
+			for(i = 0; i < d->num; ++i)
 			{
-				if (msg->cursize + 2 > msg->maxsize)
-				{
-					// if the packet no longer has enough room to write the
-					// final index code that ends the message, rollback to the
-					// state before we tried to write anything and then return
-					msg->cursize = oldcursize;
-					msg->overflowed = false;
-					return;
-				}
-				// an update has been successfully written, update the version
-				svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] = version;
-				// and take note that we have begun the svc_csqcentities
-				// section of the packet
-				*sectionstarted = 1;
-				return;
+				int sf = d->sendflags[i];
+				int ent = d->entno[i];
+				if(sf < 0) // remove
+					recoversendflags[ent] |= -1; // all bits, including sign
+				else if(sf > 0)
+					recoversendflags[ent] |= sf;
 			}
-			else
+		}
+		else
+		{
+			// handling the frames that followed it now
+			for(i = 0; i < d->num; ++i)
 			{
-				// rollback the buffer to its state before the writes
-				msg->cursize = oldcursize;
-				// if the function returned FALSE, simply write a remove
-				// this is done by falling through to the remove code below
-				version = 0;
+				int sf = d->sendflags[i];
+				int ent = d->entno[i];
+				if(sf < 0) // remove
+				{
+					recoversendflags[ent] = 0; // no need to update, we got a more recent remove (and will fix it THEN)
+					break; // no flags left to remove...
+				}
+				else if(sf > 0)
+					recoversendflags[ent] &= ~sf; // no need to update these bits, we already got them later
 			}
 		}
 	}
-	// write a remove message if needed
-	// if already removed, do nothing
-	if (!svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number])
-		return;
-	// if there isn't enough room to write the remove message, just return, as
-	// it will be handled in a later packet
-	if (msg->cursize + !*sectionstarted + 2 + 2 > msg->maxsize)
-		return;
-	// first write the message identifier if needed
-	if(!*sectionstarted)
+
+	for(i = 0; i < client->csqcnumedicts; ++i)
 	{
-		*sectionstarted = 1;
-		MSG_WriteByte(msg, svc_csqcentities);
+		if(recoversendflags[i] < 0)
+		{
+			// a remove got lost, then either send a remove or - if it was
+			// recreated later - a FULL update to make totally sure
+			client->csqcentityscope[i] = 1;
+			client->csqcentitysendflags[i] = 0xFFFFFF;
+		}
+		else
+			client->csqcentitysendflags[i] |= recoversendflags[i];
 	}
-	// write the remove message
-	MSG_WriteShort(msg, (unsigned short)number | 0x8000);
-	svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[number] = 0;
+}
+static int EntityFrameCSQC_AllocFrame(client_t *client, int framenum)
+{
+	int ringfirst = client->csqcentityframehistory_next; // oldest entry
+	client->csqcentityframehistory_next += 1;
+	client->csqcentityframehistory_next %= NUM_CSQCENTITYDB_FRAMES;
+	client->csqcentityframehistory[ringfirst].framenum = framenum;
+	client->csqcentityframehistory[ringfirst].num = 0;
+	return ringfirst;
+}
+static void EntityFrameCSQC_DeallocFrame(client_t *client, int framenum)
+{
+	int ringfirst = client->csqcentityframehistory_next; // oldest entry
+	int ringlast = (ringfirst + NUM_CSQCENTITYDB_FRAMES - 1) % NUM_CSQCENTITYDB_FRAMES; // most recently added entry
+	if(framenum == client->csqcentityframehistory[ringlast].framenum)
+	{
+		client->csqcentityframehistory[ringlast].framenum = -1;
+		client->csqcentityframehistory[ringlast].num = 0;
+		client->csqcentityframehistory_next = ringlast;
+	}
+	else
+		Con_Printf("Trying to dealloc the wrong entity frame\n");
 }
 
 //[515]: we use only one array per-client for SendEntity feature
-void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states)
+// TODO: add some handling for entity send priorities, to better deal with huge
+// amounts of csqc networked entities
+void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numstates, const entity_state_t *states, int framenum)
 {
-	int i, num;
+	int num, number, end, sendflags;
 	qboolean sectionstarted = false;
 	const entity_state_t *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 this server progs is not CSQC-aware, return early
 	if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
 		return;
+
 	// make sure there is enough room to store the svc_csqcentities byte,
 	// the terminator (0x0000) and at least one entity update
-	if (msg->cursize + 32 >= msg->maxsize)
+	if (msg->cursize + 32 >= maxsize)
 		return;
 
-	num = 1;
+	if (client->csqcnumedicts < prog->num_edicts)
+		client->csqcnumedicts = prog->num_edicts;
+
+	number = 1;
+	for (num = 0, n = states;num < numstates;num++, n++)
+	{
+		end = n->number;
+		for (;number < end;number++)
+		{
+			if (client->csqcentityscope[number])
+			{
+				client->csqcentityscope[number] = 1;
+				client->csqcentitysendflags[number] = 0xFFFFFF;
+			}
+		}
+		ed = prog->edicts + number;
+		val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
+		if (val->function)
+			client->csqcentityscope[number] = 2;
+		else if (client->csqcentityscope[number])
+		{
+			client->csqcentityscope[number] = 1;
+			client->csqcentitysendflags[number] = 0xFFFFFF;
+		}
+		number++;
+	}
+	end = client->csqcnumedicts;
+	for (;number < end;number++)
+	{
+		if (client->csqcentityscope[number])
+		{
+			client->csqcentityscope[number] = 1;
+			client->csqcentitysendflags[number] = 0xFFFFFF;
+		}
+	}
+
+	/*
+	// mark all scope entities as remove
+	for (number = 1;number < client->csqcnumedicts;number++)
+		if (client->csqcentityscope[number])
+			client->csqcentityscope[number] = 1;
+	// keep visible entities
 	for (i = 0, n = states;i < numstates;i++, n++)
 	{
-		// all entities between the previous entity state and this one are dead
-		for (;num < n->number;num++)
-			if(svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[num])
-				EntityFrameCSQC_WriteState(msg, num, false, &sectionstarted);
-		// update this entity
-		EntityFrameCSQC_WriteState(msg, num, true, &sectionstarted);
-		// advance to next entity so the next iteration doesn't immediately remove it
-		num++;
+		number = n->number;
+		ed = prog->edicts + number;
+		val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.SendEntity);
+		if (val->function)
+			client->csqcentityscope[number] = 2;
+	}
+	*/
+
+	// now try to emit the entity updates
+	// (FIXME: prioritize by distance?)
+	end = client->csqcnumedicts;
+	for (number = 1;number < end;number++)
+	{
+		if (!client->csqcentityscope[number])
+			continue;
+		sendflags = client->csqcentitysendflags[number];
+		if (!sendflags)
+			continue;
+		if(db->num >= NUM_CSQCENTITIES_PER_FRAME)
+			break;
+		ed = prog->edicts + number;
+		// entity scope is either update (2) or remove (1)
+		if (client->csqcentityscope[number] == 1)
+		{
+			// write a remove message
+			// first write the message identifier if needed
+			if(!sectionstarted)
+			{
+				sectionstarted = 1;
+				MSG_WriteByte(msg, svc_csqcentities);
+			}
+			// write the remove message
+			{
+				ENTITYSIZEPROFILING_START(msg, number);
+				MSG_WriteShort(msg, (unsigned short)number | 0x8000);
+				client->csqcentityscope[number] = 0;
+				client->csqcentitysendflags[number] = 0xFFFFFF; // resend completely if it becomes active again
+				db->entno[db->num] = number;
+				db->sendflags[db->num] = -1;
+				db->num += 1;
+				client->csqcentityglobalhistory[number] = 1;
+				ENTITYSIZEPROFILING_END(msg, number);
+			}
+			if (msg->cursize + 17 >= maxsize)
+				break;
+		}
+		else
+		{
+			// write an update
+			// 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(!sectionstarted)
+					MSG_WriteByte(msg, svc_csqcentities);
+				{
+					ENTITYSIZEPROFILING_START(msg, number);
+					MSG_WriteShort(msg, number);
+					msg->allowoverflow = true;
+					PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
+					PRVM_G_FLOAT(OFS_PARM1) = sendflags;
+					prog->globals.server->self = number;
+					PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
+					msg->allowoverflow = false;
+					if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
+					{
+						// an update has been successfully written
+						client->csqcentitysendflags[number] = 0;
+						db->entno[db->num] = number;
+						db->sendflags[db->num] = sendflags;
+						db->num += 1;
+						client->csqcentityglobalhistory[number] = 1;
+						// and take note that we have begun the svc_csqcentities
+						// section of the packet
+						sectionstarted = 1;
+						ENTITYSIZEPROFILING_END(msg, number);
+						if (msg->cursize + 17 >= maxsize)
+							break;
+						continue;
+					}
+				}
+			}
+			// self.SendEntity returned false (or does not exist) or the
+			// update was too big for this packet - rollback the buffer to its
+			// state before the writes occurred, we'll try again next frame
+			msg->cursize = oldcursize;
+			msg->overflowed = false;
+		}
 	}
-	// all remaining entities are dead
-	for (;num < prog->num_edicts;num++)
-		if(svs.clients[sv.writeentitiestoclient_clientnumber].csqcentityversion[num])
-			EntityFrameCSQC_WriteState(msg, num, false, &sectionstarted);
 	if (sectionstarted)
 	{
 		// write index 0 to end the update (0 is never used by real entities)
 		MSG_WriteShort(msg, 0);
 	}
+
+	if(db->num == 0)
+		// if no single ent got added, remove the frame from the DB again, to allow
+		// for a larger history
+		EntityFrameCSQC_DeallocFrame(client, framenum);
 }
 
 void Protocol_UpdateClientStats(const int *stats)
@@ -387,33 +613,62 @@ void Protocol_UpdateClientStats(const int *stats)
 	}
 }
 
+// only a few stats are within the 32 stat limit of Quake, and most of them
+// are sent every frame in svc_clientdata messages, so we only send the
+// remaining ones here
+static const int sendquakestats[] =
+{
+// quake did not send these secrets/monsters stats in this way, but doing so
+// allows a mod to increase STAT_TOTALMONSTERS during the game, and ensures
+// that STAT_SECRETS and STAT_MONSTERS are always correct (even if a client
+// didn't receive an svc_foundsecret or svc_killedmonster), which may be most
+// valuable if randomly seeking around in a demo
+STAT_TOTALSECRETS, // never changes during game
+STAT_TOTALMONSTERS, // changes in some mods
+STAT_SECRETS, // this makes svc_foundsecret unnecessary
+STAT_MONSTERS, // this makes svc_killedmonster unnecessary
+STAT_VIEWHEIGHT, // sent just for FTEQW clients
+STAT_VIEWZOOM, // this rarely changes
+-1,
+};
+
 void Protocol_WriteStatsReliable(void)
 {
-	int i;
+	int i, j;
 	if (!host_client->netconnection)
 		return;
 	// detect changes in stats and write reliable messages
-	for (i = 0;i < MAX_CL_STATS;i++)
+	// this only deals with 32 stats because the older protocols which use
+	// this function can only cope with 32 stats,
+	// they also do not support svc_updatestatubyte which was introduced in
+	// DP6 protocol (except for QW)
+	for (j = 0;sendquakestats[j] >= 0;j++)
 	{
-		// quickly skip zero bytes
-		if (!host_client->statsdeltabits[i >> 3])
-		{
-			i |= 7;
-			continue;
-		}
+		i = sendquakestats[j];
 		// check if this bit is set
 		if (host_client->statsdeltabits[i >> 3] & (1 << (i & 7)))
 		{
 			host_client->statsdeltabits[i >> 3] -= (1 << (i & 7));
 			// send the stat as a byte if possible
-			if (host_client->stats[i] >= 0 && host_client->stats[i] < 256)
+			if (sv.protocol == PROTOCOL_QUAKEWORLD)
 			{
-				MSG_WriteByte(&host_client->netconnection->message, svc_updatestatubyte);
-				MSG_WriteByte(&host_client->netconnection->message, i);
-				MSG_WriteByte(&host_client->netconnection->message, host_client->stats[i]);
+				if (host_client->stats[i] >= 0 && host_client->stats[i] < 256)
+				{
+					MSG_WriteByte(&host_client->netconnection->message, qw_svc_updatestat);
+					MSG_WriteByte(&host_client->netconnection->message, i);
+					MSG_WriteByte(&host_client->netconnection->message, host_client->stats[i]);
+				}
+				else
+				{
+					MSG_WriteByte(&host_client->netconnection->message, qw_svc_updatestatlong);
+					MSG_WriteByte(&host_client->netconnection->message, i);
+					MSG_WriteLong(&host_client->netconnection->message, host_client->stats[i]);
+				}
 			}
 			else
 			{
+				// this could make use of svc_updatestatubyte in DP6 and later
+				// protocols but those protocols do not use this function
 				MSG_WriteByte(&host_client->netconnection->message, svc_updatestat);
 				MSG_WriteByte(&host_client->netconnection->message, i);
 				MSG_WriteLong(&host_client->netconnection->message, host_client->stats[i]);
@@ -423,7 +678,7 @@ void Protocol_WriteStatsReliable(void)
 }
 
 
-void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_state_t *states)
+void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int maxsize, int numstates, const entity_state_t *states)
 {
 	const entity_state_t *s;
 	entity_state_t baseline;
@@ -439,6 +694,7 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
 
 	for (i = 0, s = states;i < numstates;i++, s++)
 	{
+		ENTITYSIZEPROFILING_START(msg, s->number);
 		val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity);
 		if(val && val->function)
 			continue;
@@ -492,7 +748,7 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
 		if (baseline.modelindex != s->modelindex)
 		{
 			bits |= U_MODEL;
-			if (s->modelindex & 0xFF00)
+			if ((s->modelindex & 0xFF00) && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
 				bits |= U_MODEL2;
 		}
 		if (baseline.alpha != s->alpha)
@@ -503,6 +759,8 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
 			bits |= U_GLOWSIZE;
 		if (baseline.glowcolor != s->glowcolor)
 			bits |= U_GLOWCOLOR;
+		if (!VectorCompare(baseline.colormod, s->colormod))
+			bits |= U_COLORMOD;
 
 		// if extensions are disabled, clear the relevant update flags
 		if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
@@ -522,12 +780,21 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
 
 		MSG_WriteByte (&buf, bits);
 		if (bits & U_MOREBITS)		MSG_WriteByte(&buf, bits>>8);
-		if (bits & U_EXTEND1)		MSG_WriteByte(&buf, bits>>16);
-		if (bits & U_EXTEND2)		MSG_WriteByte(&buf, bits>>24);
+		if (sv.protocol != PROTOCOL_NEHAHRAMOVIE)
+		{
+			if (bits & U_EXTEND1)	MSG_WriteByte(&buf, bits>>16);
+			if (bits & U_EXTEND2)	MSG_WriteByte(&buf, bits>>24);
+		}
 		if (bits & U_LONGENTITY)	MSG_WriteShort(&buf, s->number);
 		else						MSG_WriteByte(&buf, s->number);
 
-		if (bits & U_MODEL)			MSG_WriteByte(&buf, s->modelindex);
+		if (bits & U_MODEL)
+		{
+			if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
+				MSG_WriteShort(&buf, s->modelindex);
+			else
+				MSG_WriteByte(&buf, s->modelindex);
+		}
 		if (bits & U_FRAME)			MSG_WriteByte(&buf, s->frame);
 		if (bits & U_COLORMAP)		MSG_WriteByte(&buf, s->colormap);
 		if (bits & U_SKIN)			MSG_WriteByte(&buf, s->skin);
@@ -564,13 +831,14 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
 		}
 
 		// if the commit is full, we're done this frame
-		if (msg->cursize + buf.cursize > msg->maxsize)
+		if (msg->cursize + buf.cursize > maxsize)
 		{
 			// next frame we will continue where we left off
 			break;
 		}
 		// write the message to the packet
 		SZ_Write(msg, buf.data, buf.cursize);
+		ENTITYSIZEPROFILING_END(msg, s->number);
 	}
 }
 
@@ -756,6 +1024,7 @@ void EntityState_WriteFields(const entity_state_t *ent, sizebuf_t *msg, unsigned
 void EntityState_WriteUpdate(const entity_state_t *ent, sizebuf_t *msg, const entity_state_t *delta)
 {
 	unsigned int bits;
+	ENTITYSIZEPROFILING_START(msg, ent->number);
 	if (ent->active)
 	{
 		// entity is active, check for changes from the delta
@@ -776,6 +1045,7 @@ void EntityState_WriteUpdate(const entity_state_t *ent, sizebuf_t *msg, const en
 			MSG_WriteShort(msg, ent->number | 0x8000);
 		}
 	}
+	ENTITYSIZEPROFILING_END(msg, ent->number);
 }
 
 int EntityState_ReadExtendBits(void)
@@ -1059,7 +1329,7 @@ void EntityFrame_AddFrame(entityframe_database_t *d, vec3_t eye, int framenum, i
 }
 
 // (server) writes a frame to network stream
-void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numstates, const entity_state_t *states, int viewentnum)
+void 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;
@@ -1535,7 +1805,7 @@ void EntityFrame4_CL_ReadFrame(void)
 		EntityFrame4_ResetDatabase(d);
 }
 
-void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int numstates, const entity_state_t *states)
+void 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;
@@ -1545,7 +1815,7 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
 	prvm_eval_t *val;
 
 	// if there isn't enough space to accomplish anything, skip it
-	if (msg->cursize + 24 > msg->maxsize)
+	if (msg->cursize + 24 > maxsize)
 		return;
 
 	// prepare the buffer
@@ -1615,7 +1885,7 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
 			}
 		}
 		// if the commit is full, we're done this frame
-		if (msg->cursize + buf.cursize > msg->maxsize - 4)
+		if (msg->cursize + buf.cursize > maxsize - 4)
 		{
 			// next frame we will continue where we left off
 			break;
@@ -1662,7 +1932,7 @@ void EntityFrame5_FreeDatabase(entityframe5_database_t *d)
 	Mem_Free(d);
 }
 
-void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
+static void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
 {
 	if (d->maxedicts < newmax)
 	{
@@ -1693,7 +1963,7 @@ void EntityFrame5_ExpandEdicts(entityframe5_database_t *d, int newmax)
 	}
 }
 
-int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
+static int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
 {
 	int limit, priority;
 	entity_state_t *s;
@@ -1739,6 +2009,7 @@ int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
 void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbits, sizebuf_t *msg)
 {
 	unsigned int bits = 0;
+	ENTITYSIZEPROFILING_START(msg, s->number);
 
 	prvm_eval_t *val;
 	val = PRVM_EDICTFIELDVALUE((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity);
@@ -1750,8 +2021,17 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi
 	else
 	{
 		bits = changedbits;
-		if ((bits & E5_ORIGIN) && ((s->flags & RENDER_EXTERIORMODEL) || s->origin[0] < -4096 || s->origin[0] >= 4096 || s->origin[1] < -4096 || s->origin[1] >= 4096 || s->origin[2] < -4096 || s->origin[2] >= 4096))
+		if ((bits & E5_ORIGIN) && ((s->flags & RENDER_EXTERIORMODEL) || s->origin[0] <= -4096.0625 || s->origin[0] >= 4095.9375 || s->origin[1] <= -4096.0625 || s->origin[1] >= 4095.9375 || s->origin[2] <= -4096.0625 || s->origin[2] >= 4095.9375))
 			bits |= E5_ORIGIN32;
+			// possible values:
+			//   negative origin:
+			//     (int)(f * 8 - 0.5) >= -32768
+			//          (f * 8 - 0.5) >  -32769
+			//           f            >  -4096.0625
+			//   positive origin:
+			//     (int)(f * 8 + 0.5) <=  32767
+			//          (f * 8 + 0.5) <   32768
+			//           f * 8 + 0.5) <   4095.9375
 		if ((bits & E5_ANGLES) && !(s->flags & RENDER_LOWPRECISION))
 			bits |= E5_ANGLES16;
 		if ((bits & E5_MODEL) && s->modelindex >= 256)
@@ -1868,9 +2148,11 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi
 			MSG_WriteByte(msg, s->colormod[2]);
 		}
 	}
+
+	ENTITYSIZEPROFILING_END(msg, s->number);
 }
 
-void EntityState5_ReadUpdate(entity_state_t *s, int number)
+static void EntityState5_ReadUpdate(entity_state_t *s, int number)
 {
 	int bits;
 	bits = MSG_ReadByte();
@@ -2036,7 +2318,7 @@ void EntityState5_ReadUpdate(entity_state_t *s, int number)
 	}
 }
 
-int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t *n)
+static int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t *n)
 {
 	unsigned int bits = 0;
 	if (n->active)
@@ -2180,7 +2462,7 @@ void EntityFrame5_LostFrame(entityframe5_database_t *d, int framenum)
 				{
 					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))
+					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);
@@ -2213,7 +2495,7 @@ void EntityFrame5_AckFrame(entityframe5_database_t *d, int framenum)
 			d->packetlog[i].packetnumber = 0;
 }
 
-void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int movesequence)
+void EntityFrame5_WriteFrame(sizebuf_t *msg, int maxsize, entityframe5_database_t *d, int numstates, const entity_state_t *states, int viewentnum, int movesequence)
 {
 	const entity_state_t *n;
 	int i, num, l, framenum, packetlognumber, priority;
@@ -2323,9 +2605,9 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
 	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)
+	if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3 && sv.protocol != PROTOCOL_DARKPLACES1 && sv.protocol != PROTOCOL_DARKPLACES2 && sv.protocol != PROTOCOL_DARKPLACES3 && sv.protocol != PROTOCOL_DARKPLACES4 && sv.protocol != PROTOCOL_DARKPLACES5)
 	{
-		for (i = 0;i < MAX_CL_STATS && msg->cursize + 6 + 11 <= msg->maxsize;i++)
+		for (i = 0;i < MAX_CL_STATS && msg->cursize + 6 + 11 <= maxsize;i++)
 		{
 			if (host_client->statsdeltabits[i>>3] & (1<<(i&7)))
 			{
@@ -2365,7 +2647,7 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
 			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)
+			if (msg->cursize + buf.cursize + 2 > maxsize)
 				continue;
 			// write entity to the packet
 			SZ_Write(msg, buf.data, buf.cursize);