X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=protocol.c;h=f7caf5773b670a16b3cd05e8833df94db70047df;hp=1be46fbbf79aa0bc91c0caf5fd3098f22f58ab11;hb=3fc7ab39fd981ceb01c0c810a84ad070a8082e22;hpb=3a310f4a95b21c5caaf7a3affa0f2afc00034f32

diff --git a/protocol.c b/protocol.c
index 1be46fbb..f7caf577 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 =
 {
@@ -21,7 +37,7 @@ entity_state_t defaultstate =
 	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
+	ACTIVE_NOT,//unsigned char active; // true if a valid state
 	0,//unsigned char lightstyle;
 	0,//unsigned char lightpflags;
 	0,//unsigned char colormap;
@@ -34,8 +50,9 @@ entity_state_t defaultstate =
 	0,//unsigned char internaleffects; // INTEF_FLAG1QW and so on
 	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,0,0,0}//unsigned char unused[5]; // !
+	{0,0}//unsigned char unused[2]; // !
 };
 
 // LordHavoc: I own protocol ranges 96, 97, 3500-3599
@@ -149,7 +166,7 @@ void EntityFrameQuake_ReadEntity(int bits)
 	else
 	{
 		s = ent->state_baseline;
-		s.active = true;
+		s.active = ACTIVE_NETWORK;
 	}
 
 	cl.isquakeentity[num] = true;
@@ -210,7 +227,7 @@ void EntityFrameQuake_ReadEntity(int bits)
 
 	ent->state_previous = ent->state_current;
 	ent->state_current = s;
-	if (ent->state_current.active)
+	if (ent->state_current.active == ACTIVE_NETWORK)
 	{
 		CL_MoveLerpEntityStates(ent);
 		cl.entities_active[ent->state_current.number] = true;
@@ -239,7 +256,7 @@ void EntityFrameQuake_ISeeDeadEntities(void)
 			else
 			{
 				cl.isquakeentity[num] = false;
-				cl.entities_active[num] = false;
+				cl.entities_active[num] = ACTIVE_NOT;
 				cl.entities[num].state_current = defaultstate;
 				cl.entities[num].state_current.number = num;
 			}
@@ -247,145 +264,342 @@ 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;
 
-void EntityFrameCSQC_WriteState (sizebuf_t *msg, int number, qboolean doupdate, qboolean *sectionstarted)
+	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)
+				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);
-			PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
-			prog->globals.server->self = number;
-			PRVM_ExecuteProgram(val->function, "Null SendEntity\n");
-			if(PRVM_G_FLOAT(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
+qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers, const unsigned short *numbers, int framenum)
 {
-	int i, num;
+	int num, number, end, sendflags;
 	qboolean sectionstarted = false;
-	const entity_state_t *n;
+	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 this server progs is not CSQC-aware, return early
 	if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
-		return;
+		return false;
+
 	// make sure there is enough room to store the svc_csqcentities byte,
 	// the terminator (0x0000) and at least one entity update
-	if (msg->cursize + 32 >= msg->maxsize)
-		return;
+	if (msg->cursize + 32 >= maxsize)
+		return false;
 
-	num = 1;
-	for (i = 0, n = states;i < numstates;i++, n++)
+	if (client->csqcnumedicts < prog->num_edicts)
+		client->csqcnumedicts = prog->num_edicts;
+
+	number = 1;
+	for (num = 0, n = numbers;num < numnumbers;num++, 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++;
+		end = *n;
+		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 = numbers;i < numnumbers;i++, n++)
+	{
+		number = *n;
+		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);
+	
+	return sectionstarted;
 }
 
 void Protocol_UpdateClientStats(const int *stats)
@@ -467,7 +681,7 @@ void Protocol_WriteStatsReliable(void)
 }
 
 
-void EntityFrameQuake_WriteFrame(sizebuf_t *msg, 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;
@@ -475,6 +689,7 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
 	sizebuf_t buf;
 	unsigned char data[128];
 	prvm_eval_t *val;
+	qboolean success = false;
 
 	// prepare the buffer
 	memset(&buf, 0, sizeof(buf));
@@ -483,6 +698,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;
@@ -619,21 +835,24 @@ 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);
+		success = true;
+		ENTITYSIZEPROFILING_END(msg, s->number);
 	}
+	return success;
 }
 
 int EntityState_DeltaBits(const entity_state_t *o, const entity_state_t *n)
 {
 	unsigned int bits;
 	// if o is not active, delta from default
-	if (!o->active)
+	if (o->active != ACTIVE_NETWORK)
 		o = &defaultstate;
 	bits = 0;
 	if (fabs(n->origin[0] - o->origin[0]) > (1.0f / 256.0f))
@@ -811,7 +1030,8 @@ 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;
-	if (ent->active)
+	ENTITYSIZEPROFILING_START(msg, ent->number);
+	if (ent->active == ACTIVE_NETWORK)
 	{
 		// entity is active, check for changes from the delta
 		if ((bits = EntityState_DeltaBits(delta, ent)))
@@ -825,12 +1045,13 @@ void EntityState_WriteUpdate(const entity_state_t *ent, sizebuf_t *msg, const en
 	else
 	{
 		// entity is inactive, check if the delta was active
-		if (delta->active)
+		if (delta->active == ACTIVE_NETWORK)
 		{
 			// write the remove number
 			MSG_WriteShort(msg, ent->number | 0x8000);
 		}
 	}
+	ENTITYSIZEPROFILING_END(msg, ent->number);
 }
 
 int EntityState_ReadExtendBits(void)
@@ -1114,7 +1335,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)
+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;
@@ -1153,7 +1374,7 @@ void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numst
 
 		val = PRVM_EDICTFIELDVALUE((&prog->edicts[number]), prog->fieldoffsets.SendEntity);
 		if(val && val->function)
-				continue;
+			continue;
 		for (;onum < o->numentities && o->entitydata[onum].number < number;onum++)
 		{
 			// write remove message
@@ -1179,6 +1400,8 @@ void EntityFrame_WriteFrame(sizebuf_t *msg, entityframe_database_t *d, int numst
 		MSG_WriteShort(msg, o->entitydata[onum].number | 0x8000);
 	}
 	MSG_WriteShort(msg, 0xFFFF);
+
+	return true;
 }
 
 // (client) reads a frame from network stream
@@ -1261,7 +1484,7 @@ void EntityFrame_CL_ReadFrame(void)
 					CL_ExpandEntities(number);
 			}
 			cl.entities_active[number] = true;
-			e->active = true;
+			e->active = ACTIVE_NETWORK;
 			e->time = cl.mtime[0];
 			e->number = number;
 			EntityState_ReadFields(e, EntityState_ReadExtendBits());
@@ -1285,7 +1508,7 @@ void EntityFrame_CL_ReadFrame(void)
 			if (cl.entities_active[number])
 			{
 				cl.entities_active[number] = false;
-				cl.entities[number].state_current.active = false;
+				cl.entities[number].state_current.active = ACTIVE_NOT;
 			}
 		}
 		if (number >= cl.num_entities)
@@ -1304,7 +1527,7 @@ void EntityFrame_CL_ReadFrame(void)
 		if (cl.entities_active[number])
 		{
 			cl.entities_active[number] = false;
-			cl.entities[number].state_current.active = false;
+			cl.entities[number].state_current.active = ACTIVE_NOT;
 		}
 	}
 }
@@ -1429,7 +1652,7 @@ int EntityFrame4_AckFrame(entityframe4_database_t *d, int framenum, int servermo
 							entity_state_t *s = EntityFrame4_GetReferenceEntity(d, commit->entity[j].number);
 							if (commit->entity[j].active != s->active)
 							{
-								if (commit->entity[j].active)
+								if (commit->entity[j].active == ACTIVE_NETWORK)
 									Con_Printf("commit entity %i has become active (modelindex %i)\n", commit->entity[j].number, commit->entity[j].modelindex);
 								else
 									Con_Printf("commit entity %i has become inactive (modelindex %i)\n", commit->entity[j].number, commit->entity[j].modelindex);
@@ -1557,20 +1780,20 @@ void EntityFrame4_CL_ReadFrame(void)
 					// read the changes
 					if (developer_networkentities.integer >= 2)
 						Con_Printf("entity %i: update\n", enumber);
-					s->active = true;
+					s->active = ACTIVE_NETWORK;
 					EntityState_ReadFields(s, EntityState_ReadExtendBits());
 				}
 			}
 			else if (developer_networkentities.integer >= 4)
 				Con_Printf("entity %i: copy\n", enumber);
 			// set the cl.entities_active flag
-			cl.entities_active[enumber] = s->active;
+			cl.entities_active[enumber] = (s->active == ACTIVE_NETWORK);
 			// set the update time
 			s->time = cl.mtime[0];
 			// fix the number (it gets wiped occasionally by copying from defaultstate)
 			s->number = enumber;
 			// check if we need to update the lerp stuff
-			if (s->active)
+			if (s->active == ACTIVE_NETWORK)
 				CL_MoveLerpEntityStates(&cl.entities[enumber]);
 			// add this to the commit entry whether it is modified or not
 			if (d->currentcommit)
@@ -1578,7 +1801,7 @@ void EntityFrame4_CL_ReadFrame(void)
 			// print extra messages if desired
 			if (developer_networkentities.integer >= 2 && cl.entities[enumber].state_current.active != cl.entities[enumber].state_previous.active)
 			{
-				if (cl.entities[enumber].state_current.active)
+				if (cl.entities[enumber].state_current.active == ACTIVE_NETWORK)
 					Con_Printf("entity #%i has become active\n", enumber);
 				else if (cl.entities[enumber].state_previous.active)
 					Con_Printf("entity #%i has become inactive\n", enumber);
@@ -1590,7 +1813,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)
+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;
@@ -1600,8 +1823,8 @@ 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)
-		return;
+	if (msg->cursize + 24 > maxsize)
+		return false;
 
 	// prepare the buffer
 	memset(&buf, 0, sizeof(buf));
@@ -1613,7 +1836,7 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
 			break;
 	// if commit buffer full, just don't bother writing an update this frame
 	if (i == MAX_ENTITY_HISTORY)
-		return;
+		return false;
 	d->currentcommit = d->commit + i;
 
 	// this state's number gets played around with later
@@ -1663,14 +1886,14 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
 		{
 			inactiveentitystate.number = n;
 			s = &inactiveentitystate;
-			if (e->active)
+			if (e->active == ACTIVE_NETWORK)
 			{
 				// entity used to exist but doesn't anymore, send remove
 				MSG_WriteShort(&buf, n | 0x8000);
 			}
 		}
 		// 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;
@@ -1692,6 +1915,8 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
 	MSG_WriteShort(msg, d->currententitynumber);
 	// just to be sure
 	d->currentcommit = NULL;
+
+	return true;
 }
 
 
@@ -1717,7 +1942,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)
 	{
@@ -1748,7 +1973,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;
@@ -1761,7 +1986,7 @@ int EntityState5_Priority(entityframe5_database_t *d, int stateindex)
 	if (stateindex <= svs.maxclients)
 		priority++;
 	// remove dead entities very quickly because they are just 2 bytes
-	if (!d->states[stateindex].active)
+	if (d->states[stateindex].active != ACTIVE_NETWORK)
 	{
 		priority++;
 		return bound(1, priority, ENTITYFRAME5_PRIORITYLEVELS - 1);
@@ -1794,19 +2019,31 @@ 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;
+	//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)
 		return;
 
-	if (!s->active)
+	if (s->active != ACTIVE_NETWORK)
 		MSG_WriteShort(msg, number | 0x8000);
 	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_LOWPRECISION) || s->exteriormodelforclient || s->tagentity || s->viewmodelforclient || (s->number >= 1 && s->number <= svs.maxclients) || 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))
+		// maybe also add: ((model = sv.models[s->modelindex]) != NULL && model->name[0] == '*')
 			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)
@@ -1922,10 +2159,18 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi
 			MSG_WriteByte(msg, s->colormod[1]);
 			MSG_WriteByte(msg, s->colormod[2]);
 		}
+		if (bits & E5_GLOWMOD)
+		{
+			MSG_WriteByte(msg, s->glowmod[0]);
+			MSG_WriteByte(msg, s->glowmod[1]);
+			MSG_WriteByte(msg, s->glowmod[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();
@@ -1942,7 +2187,7 @@ void EntityState5_ReadUpdate(entity_state_t *s, int number)
 	if (bits & E5_FULLUPDATE)
 	{
 		*s = defaultstate;
-		s->active = true;
+		s->active = ACTIVE_NETWORK;
 	}
 	if (bits & E5_FLAGS)
 		s->flags = MSG_ReadByte();
@@ -2032,6 +2277,12 @@ void EntityState5_ReadUpdate(entity_state_t *s, int number)
 		s->colormod[1] = MSG_ReadByte();
 		s->colormod[2] = MSG_ReadByte();
 	}
+	if (bits & E5_GLOWMOD)
+	{
+		s->glowmod[0] = MSG_ReadByte();
+		s->glowmod[1] = MSG_ReadByte();
+		s->glowmod[2] = MSG_ReadByte();
+	}
 
 
 	if (developer_networkentities.integer >= 2)
@@ -2087,16 +2338,18 @@ void EntityState5_ReadUpdate(entity_state_t *s, int number)
 			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);
+		if (bits & E5_GLOWMOD)
+			Con_Printf(" E5_GLOWMOD %f:%f:%f", s->glowmod[0] / 32.0f, s->glowmod[1] / 32.0f, s->glowmod[2] / 32.0f);
 		Con_Print("\n");
 	}
 }
 
-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)
+	if (n->active == ACTIVE_NETWORK)
 	{
-		if (!o->active)
+		if (o->active != ACTIVE_NETWORK)
 			bits |= E5_FULLUPDATE;
 		if (!VectorCompare(o->origin, n->origin))
 			bits |= E5_ORIGIN;
@@ -2126,9 +2379,11 @@ int EntityState5_DeltaBits(const entity_state_t *o, const entity_state_t *n)
 			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;
+		if (o->glowmod[0] != n->glowmod[0] || o->glowmod[1] != n->glowmod[1] || o->glowmod[2] != n->glowmod[2])
+			bits |= E5_GLOWMOD;
 	}
 	else
-		if (o->active)
+		if (o->active == ACTIVE_NETWORK)
 			bits |= E5_FULLUPDATE;
 	return bits;
 }
@@ -2176,18 +2431,18 @@ void EntityFrame5_CL_ReadFrame(void)
 			EntityState5_ReadUpdate(s, enumber);
 		}
 		// set the cl.entities_active flag
-		cl.entities_active[enumber] = s->active;
+		cl.entities_active[enumber] = (s->active == ACTIVE_NETWORK);
 		// set the update time
 		s->time = cl.mtime[0];
 		// fix the number (it gets wiped occasionally by copying from defaultstate)
 		s->number = enumber;
 		// check if we need to update the lerp stuff
-		if (s->active)
+		if (s->active == ACTIVE_NETWORK)
 			CL_MoveLerpEntityStates(&cl.entities[enumber]);
 		// print extra messages if desired
 		if (developer_networkentities.integer >= 2 && cl.entities[enumber].state_current.active != cl.entities[enumber].state_previous.active)
 		{
-			if (cl.entities[enumber].state_current.active)
+			if (cl.entities[enumber].state_current.active == ACTIVE_NETWORK)
 				Con_Printf("entity #%i has become active\n", enumber);
 			else if (cl.entities[enumber].state_previous.active)
 				Con_Printf("entity #%i has become inactive\n", enumber);
@@ -2268,7 +2523,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)
+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;
@@ -2350,7 +2605,7 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int 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;
+		return false;
 
 	// build lists of entities by priority level
 	memset(d->prioritychaincounts, 0, sizeof(d->prioritychaincounts));
@@ -2373,34 +2628,53 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
 		}
 	}
 
-	// add packetlog entry
-	packetlog = d->packetlog + packetlognumber;
-	packetlog->packetnumber = framenum;
-	packetlog->numstates = 0;
+	packetlog = NULL;
 	// write stat updates
 	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)))
 			{
 				host_client->statsdeltabits[i>>3] &= ~(1<<(i&7));
+				// add packetlog entry now that we have something for it
+				if (!packetlog)
+				{
+					packetlog = d->packetlog + packetlognumber;
+					packetlog->packetnumber = framenum;
+					packetlog->numstates = 0;
+				}
 				packetlog->statsdeltabits[i>>3] |= (1<<(i&7));
 				if (host_client->stats[i] >= 0 && host_client->stats[i] < 256)
 				{
 					MSG_WriteByte(msg, svc_updatestatubyte);
 					MSG_WriteByte(msg, i);
 					MSG_WriteByte(msg, host_client->stats[i]);
+					l = 1;
 				}
 				else
 				{
 					MSG_WriteByte(msg, svc_updatestat);
 					MSG_WriteByte(msg, i);
 					MSG_WriteLong(msg, host_client->stats[i]);
+					l = 1;
 				}
 			}
 		}
 	}
+
+	// only send empty svc_entities frame if needed
+	if(!l && !need_empty)
+		return false;
+
+	// add packetlog entry now that we have something for it
+	if (!packetlog)
+	{
+		packetlog = d->packetlog + packetlognumber;
+		packetlog->packetnumber = framenum;
+		packetlog->numstates = 0;
+	}
+
 	// write state updates
 	if (developer_networkentities.integer >= 10)
 		Con_Printf("send: svc_entities %i\n", framenum);
@@ -2420,7 +2694,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);
@@ -2436,6 +2710,8 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
 		}
 	}
 	MSG_WriteShort(msg, 0x8000);
+
+	return true;
 }
 
 
@@ -2498,7 +2774,7 @@ void EntityStateQW_ReadPlayerUpdate(void)
 	// read the update
 	s = &ent->state_current;
 	*s = defaultstate;
-	s->active = true;
+	s->active = ACTIVE_NETWORK;
 	s->number = enumber;
 	s->colormap = enumber;
 	playerflags = MSG_ReadShort();
@@ -2601,18 +2877,18 @@ void EntityStateQW_ReadPlayerUpdate(void)
 	}
 
 	// set the cl.entities_active flag
-	cl.entities_active[enumber] = s->active;
+	cl.entities_active[enumber] = (s->active == ACTIVE_NETWORK);
 	// set the update time
 	s->time = cl.mtime[0] - msec * 0.001; // qw has no clock
 	// check if we need to update the lerp stuff
-	if (s->active)
+	if (s->active == ACTIVE_NETWORK)
 		CL_MoveLerpEntityStates(&cl.entities[enumber]);
 }
 
 static void EntityStateQW_ReadEntityUpdate(entity_state_t *s, int bits)
 {
 	int qweffects = 0;
-	s->active = true;
+	s->active = ACTIVE_NETWORK;
 	s->number = bits & 511;
 	bits &= ~511;
 	if (bits & QW_U_MOREBITS)
@@ -2812,7 +3088,7 @@ void EntityFrameQW_CL_ReadFrame(qboolean delta)
 			if (cl.entities_active[number])
 			{
 				cl.entities_active[number] = false;
-				cl.entities[number].state_current.active = false;
+				cl.entities[number].state_current.active = ACTIVE_NOT;
 			}
 		}
 		if (number >= cl.num_entities)