X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=sv_main.c;h=b0f4f2a2eb9a9fa642d4050465aa3341d9cd0f2e;hb=9976ca010e51f14b9dfe4c5bc1f945344d3d9bf7;hp=4470a753ccc338f78dd24f9c26da11f6e1328d1a;hpb=e119924277152e9f2bb99b7d51fb6c83b622eda8;p=xonotic%2Fdarkplaces.git

diff --git a/sv_main.c b/sv_main.c
index 4470a753..b0f4f2a2 100644
--- a/sv_main.c
+++ b/sv_main.c
@@ -21,11 +21,23 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
-static cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "0"}; // fast but loose
-static cvar_t sv_cullentities_trace = {0, "sv_cullentities_trace", "1"}; // tends to get false negatives, uses a timeout to keep entities visible a short time after becoming hidden
+// select which protocol to host, by name
+// this is named the same as PROTOCOL_DARKPLACES5 for example, minus the PROTOCOL_ prefix
+cvar_t sv_protocolname = {0, "sv_protocolname", "DARKPLACES5"};
+cvar_t sv_ratelimitlocalplayer = {0, "sv_ratelimitlocalplayer", "0"};
+cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "10000"};
+
+static cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1"}; // fast but loose
+static cvar_t sv_cullentities_trace = {0, "sv_cullentities_trace", "0"}; // tends to get false negatives, uses a timeout to keep entities visible a short time after becoming hidden
 static cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0"};
 static cvar_t sv_entpatch = {0, "sv_entpatch", "1"};
 
+cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1"};
+cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1"};
+cvar_t sv_gameplayfix_stepdown = {0, "sv_gameplayfix_stepdown", "1"};
+cvar_t sv_gameplayfix_stepwhilejumping = {0, "sv_gameplayfix_stepwhilejumping", "1"};
+cvar_t sv_gameplayfix_swiminbmodels = {0, "sv_gameplayfix_swiminbmodels", "1"};
+
 server_t sv;
 server_static_t svs;
 
@@ -37,6 +49,7 @@ mempool_t *sv_edicts_mempool = NULL;
 
 extern void SV_Phys_Init (void);
 extern void SV_World_Init (void);
+static void SV_SaveEntFile_f(void);
 
 /*
 ===============
@@ -47,6 +60,7 @@ void SV_Init (void)
 {
 	int i;
 
+	Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f);
 	Cvar_RegisterVariable (&sv_maxvelocity);
 	Cvar_RegisterVariable (&sv_gravity);
 	Cvar_RegisterVariable (&sv_friction);
@@ -62,6 +76,14 @@ void SV_Init (void)
 	Cvar_RegisterVariable (&sv_cullentities_trace);
 	Cvar_RegisterVariable (&sv_cullentities_stats);
 	Cvar_RegisterVariable (&sv_entpatch);
+	Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
+	Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
+	Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
+	Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
+	Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
+	Cvar_RegisterVariable (&sv_protocolname);
+	Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
+	Cvar_RegisterVariable (&sv_maxrate);
 
 	SV_Phys_Init();
 	SV_World_Init();
@@ -69,7 +91,19 @@ void SV_Init (void)
 	for (i = 0;i < MAX_MODELS;i++)
 		sprintf (localmodels[i], "*%i", i);
 
-	sv_edicts_mempool = Mem_AllocPool("server edicts");
+	sv_edicts_mempool = Mem_AllocPool("server edicts", 0, NULL);
+}
+
+static void SV_SaveEntFile_f(void)
+{
+	char basename[MAX_QPATH];
+	if (!sv.active || !sv.worldmodel)
+	{
+		Con_Print("Not running a server\n");
+		return;
+	}
+	FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
+	FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, strlen(sv.worldmodel->brush.entities));
 }
 
 /*
@@ -94,9 +128,9 @@ void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
 	if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
 		return;
 	MSG_WriteByte (&sv.datagram, svc_particle);
-	MSG_WriteDPCoord (&sv.datagram, org[0]);
-	MSG_WriteDPCoord (&sv.datagram, org[1]);
-	MSG_WriteDPCoord (&sv.datagram, org[2]);
+	MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
+	MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
+	MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 	for (i=0 ; i<3 ; i++)
 	{
 		v = dir[i]*16;
@@ -124,9 +158,9 @@ void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount,
 		if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
 			return;
 		MSG_WriteByte (&sv.datagram, svc_effect2);
-		MSG_WriteDPCoord (&sv.datagram, org[0]);
-		MSG_WriteDPCoord (&sv.datagram, org[1]);
-		MSG_WriteDPCoord (&sv.datagram, org[2]);
+		MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
+		MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
+		MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 		MSG_WriteShort (&sv.datagram, modelindex);
 		MSG_WriteShort (&sv.datagram, startframe);
 		MSG_WriteByte (&sv.datagram, framecount);
@@ -137,9 +171,9 @@ void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount,
 		if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
 			return;
 		MSG_WriteByte (&sv.datagram, svc_effect);
-		MSG_WriteDPCoord (&sv.datagram, org[0]);
-		MSG_WriteDPCoord (&sv.datagram, org[1]);
-		MSG_WriteDPCoord (&sv.datagram, org[2]);
+		MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
+		MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
+		MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 		MSG_WriteByte (&sv.datagram, modelindex);
 		MSG_WriteByte (&sv.datagram, startframe);
 		MSG_WriteByte (&sv.datagram, framecount);
@@ -185,7 +219,7 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume, floa
 
 	if ( sound_num == MAX_SOUNDS || !sv.sound_precache[sound_num] )
 	{
-		Con_Printf ("SV_StartSound: %s not precached\n", sample);
+		Con_Printf("SV_StartSound: %s not precached\n", sample);
 		return;
 	}
 
@@ -220,7 +254,7 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume, floa
 	else
 		MSG_WriteByte (&sv.datagram, sound_num);
 	for (i = 0;i < 3;i++)
-		MSG_WriteDPCoord (&sv.datagram, entity->v->origin[i]+0.5*(entity->v->mins[i]+entity->v->maxs[i]));
+		MSG_WriteCoord (&sv.datagram, entity->v->origin[i]+0.5*(entity->v->mins[i]+entity->v->maxs[i]), sv.protocol);
 }
 
 /*
@@ -247,18 +281,29 @@ void SV_SendServerinfo (client_t *client)
 	// edicts get reallocated on level changes, so we need to update it here
 	client->edict = EDICT_NUM(client->number + 1);
 
+
 	// LordHavoc: clear entityframe tracking
-	client->entityframenumber = 0;
+
+	if (client->entitydatabase)
+		EntityFrame_FreeDatabase(client->entitydatabase);
 	if (client->entitydatabase4)
 		EntityFrame4_FreeDatabase(client->entitydatabase4);
-	client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_clients_mempool);
+	if (client->entitydatabase5)
+		EntityFrame5_FreeDatabase(client->entitydatabase5);
+
+	if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
+		client->entitydatabase = EntityFrame_AllocDatabase(sv_clients_mempool);
+	if (sv.protocol == PROTOCOL_DARKPLACES4)
+		client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_clients_mempool);
+	if (sv.protocol == PROTOCOL_DARKPLACES5)
+		client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_clients_mempool);
 
 	MSG_WriteByte (&client->message, svc_print);
 	snprintf (message, sizeof (message), "\002\nServer: %s build %s (progs %i crc)", gamename, buildstring, pr_crc);
 	MSG_WriteString (&client->message,message);
 
 	MSG_WriteByte (&client->message, svc_serverinfo);
-	MSG_WriteLong (&client->message, PROTOCOL_DARKPLACES4);
+	MSG_WriteLong (&client->message, sv.protocol);
 	MSG_WriteByte (&client->message, svs.maxclients);
 
 	if (!coop.integer && deathmatch.integer)
@@ -373,339 +418,6 @@ crosses a waterline.
 int sv_writeentitiestoclient_pvsbytes;
 qbyte sv_writeentitiestoclient_pvs[MAX_MAP_LEAFS/8];
 
-/*
-=============
-SV_WriteEntitiesToClient
-
-=============
-*/
-#ifdef QUAKEENTITIES
-void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
-{
-	int e, clentnum, bits, alpha, glowcolor, glowsize, scale, effects, lightsize;
-	int culled_pvs, culled_trace, visibleentities, totalentities;
-	qbyte *pvs;
-	vec3_t origin, angles, entmins, entmaxs, testorigin, testeye;
-	float nextfullupdate, alphaf;
-	edict_t *ent;
-	eval_t *val;
-	entity_state_t *baseline; // LordHavoc: delta or startup baseline
-	model_t *model;
-
-	Mod_CheckLoaded(sv.worldmodel);
-
-// find the client's PVS
-	VectorAdd (clent->v->origin, clent->v->view_ofs, testeye);
-	fatbytes = 0;
-	if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
-		fatbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, testeye, 8, sv_writeentitiestoclient_pvs, sizeof(sv_writeentitiestoclient_pvs));
-
-	culled_pvs = 0;
-	culled_trace = 0;
-	visibleentities = 0;
-	totalentities = 0;
-
-	clentnum = EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
-	// send all entities that touch the pvs
-	ent = NEXT_EDICT(sv.edicts);
-	for (e = 1;e < sv.num_edicts;e++, ent = NEXT_EDICT(ent))
-	{
-		bits = 0;
-
-		// prevent delta compression against this frame (unless actually sent, which will restore this later)
-		nextfullupdate = client->nextfullupdate[e];
-		client->nextfullupdate[e] = -1;
-
-		if (ent != clent) // LordHavoc: always send player
-		{
-			if ((val = GETEDICTFIELDVALUE(ent, eval_viewmodelforclient)) && val->edict)
-			{
-				if (val->edict != clentnum)
-				{
-					// don't show to anyone else
-					continue;
-				}
-				else
-					bits |= U_VIEWMODEL; // show relative to the view
-			}
-			else
-			{
-				// LordHavoc: never draw something told not to display to this client
-				if ((val = GETEDICTFIELDVALUE(ent, eval_nodrawtoclient)) && val->edict == clentnum)
-					continue;
-				if ((val = GETEDICTFIELDVALUE(ent, eval_drawonlytoclient)) && val->edict && val->edict != clentnum)
-					continue;
-			}
-		}
-
-		glowsize = 0;
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_glow_size)))
-			glowsize = (int) val->_float >> 2;
-		if (glowsize > 255) glowsize = 255;
-		if (glowsize < 0) glowsize = 0;
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_glow_trail)))
-		if (val->_float != 0)
-			bits |= U_GLOWTRAIL;
-
-		if (ent->v->modelindex >= 0 && ent->v->modelindex < MAX_MODELS && *PR_GetString(ent->v->model))
-		{
-			model = sv.models[(int)ent->v->modelindex];
-			Mod_CheckLoaded(model);
-		}
-		else
-		{
-			model = NULL;
-			if (ent != clent) // LordHavoc: always send player
-				if (glowsize == 0 && (bits & U_GLOWTRAIL) == 0) // no effects
-					continue;
-		}
-
-		VectorCopy(ent->v->angles, angles);
-		VectorCopy(ent->v->origin, origin);
-
-		// ent has survived every check so far, check if it is visible
-		if (ent != clent && ((bits & U_VIEWMODEL) == 0))
-		{
-			// use the predicted origin
-			entmins[0] = origin[0] - 1.0f;
-			entmins[1] = origin[1] - 1.0f;
-			entmins[2] = origin[2] - 1.0f;
-			entmaxs[0] = origin[0] + 1.0f;
-			entmaxs[1] = origin[1] + 1.0f;
-			entmaxs[2] = origin[2] + 1.0f;
-			// using the model's bounding box to ensure things are visible regardless of their physics box
-			if (model)
-			{
-				if (ent->v->angles[0] || ent->v->angles[2]) // pitch and roll
-				{
-					VectorAdd(entmins, model->rotatedmins, entmins);
-					VectorAdd(entmaxs, model->rotatedmaxs, entmaxs);
-				}
-				else if (ent->v->angles[1])
-				{
-					VectorAdd(entmins, model->yawmins, entmins);
-					VectorAdd(entmaxs, model->yawmaxs, entmaxs);
-				}
-				else
-				{
-					VectorAdd(entmins, model->normalmins, entmins);
-					VectorAdd(entmaxs, model->normalmaxs, entmaxs);
-				}
-			}
-
-			totalentities++;
-
-			// if not touching a visible leaf
-			if (sv_cullentities_pvs.integer && fatbytes && sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv_writeentitiestoclient_pvs, entmins, entmaxs))
-			{
-				culled_pvs++;
-				continue;
-			}
-
-			// don't try to cull embedded brush models with this, they're sometimes huge (spanning several rooms)
-			if (sv_cullentities_trace.integer && (model == NULL || model->name[0] != '*'))
-			{
-				// LordHavoc: test random offsets, to maximize chance of detection
-				testorigin[0] = lhrandom(entmins[0], entmaxs[0]);
-				testorigin[1] = lhrandom(entmins[1], entmaxs[1]);
-				testorigin[2] = lhrandom(entmins[2], entmaxs[2]);
-
-				sv.worldmodel->TraceBox(sv.worldmodel, 0, &trace, testeye, testeye, testorigin, testorigin, SUPERCONTENTS_SOLID);
-				if (trace.fraction == 1)
-					client->visibletime[e] = realtime + 1;
-				else
-				{
-					//test nearest point on bbox
-					testorigin[0] = bound(entmins[0], testeye[0], entmaxs[0]);
-					testorigin[1] = bound(entmins[1], testeye[1], entmaxs[1]);
-					testorigin[2] = bound(entmins[2], testeye[2], entmaxs[2]);
-
-					sv.worldmodel->TraceBox(sv.worldmodel, 0, &trace, testeye, testeye, testorigin, testorigin, SUPERCONTENTS_SOLID);
-					if (trace.fraction == 1)
-						client->visibletime[e] = realtime + 1;
-					else if (realtime > client->visibletime[e])
-					{
-						culled_trace++;
-						continue;
-					}
-				}
-			}
-			visibleentities++;
-		}
-
-		alphaf = 255.0f;
-		scale = 16;
-		glowcolor = 254;
-		effects = ent->v->effects;
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_alpha)))
-		if (val->_float != 0)
-			alphaf = val->_float * 255.0f;
-
-		// HalfLife support
-		if ((val = GETEDICTFIELDVALUE(ent, eval_renderamt)))
-		if (val->_float != 0)
-			alphaf = val->_float;
-
-		if (alphaf == 0.0f)
-			alphaf = 255.0f;
-		alpha = bound(0, alphaf, 255);
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_scale)))
-		if ((scale = (int) (val->_float * 16.0)) == 0) scale = 16;
-		if (scale < 0) scale = 0;
-		if (scale > 255) scale = 255;
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_glow_color)))
-		if (val->_float != 0)
-			glowcolor = (int) val->_float;
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_fullbright)))
-		if (val->_float != 0)
-			effects |= EF_FULLBRIGHT;
-
-		if (ent != clent)
-		{
-			if (glowsize == 0 && (bits & U_GLOWTRAIL) == 0) // no effects
-			{
-				if (model) // model
-				{
-					// don't send if flagged for NODRAW and there are no effects
-					if (model->flags == 0 && ((effects & EF_NODRAW) || scale <= 0 || alpha <= 0))
-						continue;
-				}
-				else // no model and no effects
-					continue;
-			}
-		}
-
-		if (msg->maxsize - msg->cursize < 32) // LordHavoc: increased check from 16 to 32
-		{
-			Con_Printf ("packet overflow\n");
-			// mark the rest of the entities so they can't be delta compressed against this frame
-			for (;e < sv.num_edicts;e++)
-			{
-				client->nextfullupdate[e] = -1;
-				client->visibletime[e] = -1;
-			}
-			return;
-		}
-
-		if ((val = GETEDICTFIELDVALUE(ent, eval_exteriormodeltoclient)) && val->edict == clentnum)
-			bits = bits | U_EXTERIORMODEL;
-
-// send an update
-		baseline = &ent->e->baseline;
-
-		if (((int)ent->v->effects & EF_DELTA) && sv_deltacompress.integer)
-		{
-			// every half second a full update is forced
-			if (realtime < client->nextfullupdate[e])
-			{
-				bits |= U_DELTA;
-				baseline = &ent->e->deltabaseline;
-			}
-			else
-				nextfullupdate = realtime + 0.5f;
-		}
-		else
-			nextfullupdate = realtime + 0.5f;
-
-		// restore nextfullupdate since this is being sent for real
-		client->nextfullupdate[e] = nextfullupdate;
-
-		if (e >= 256)
-			bits |= U_LONGENTITY;
-
-		if (ent->v->movetype == MOVETYPE_STEP)
-			bits |= U_STEP;
-
-		// LordHavoc: old stuff, but rewritten to have more exact tolerances
-		if (origin[0] != baseline->origin[0])											bits |= U_ORIGIN1;
-		if (origin[1] != baseline->origin[1])											bits |= U_ORIGIN2;
-		if (origin[2] != baseline->origin[2])											bits |= U_ORIGIN3;
-		if (((int)(angles[0]*(256.0/360.0)) & 255) != ((int)(baseline->angles[0]*(256.0/360.0)) & 255))	bits |= U_ANGLE1;
-		if (((int)(angles[1]*(256.0/360.0)) & 255) != ((int)(baseline->angles[1]*(256.0/360.0)) & 255))	bits |= U_ANGLE2;
-		if (((int)(angles[2]*(256.0/360.0)) & 255) != ((int)(baseline->angles[2]*(256.0/360.0)) & 255))	bits |= U_ANGLE3;
-		if (baseline->colormap != (qbyte) ent->v->colormap)								bits |= U_COLORMAP;
-		if (baseline->skin != (qbyte) ent->v->skin)										bits |= U_SKIN;
-		if ((baseline->frame & 0x00FF) != ((int) ent->v->frame & 0x00FF))				bits |= U_FRAME;
-		if ((baseline->effects & 0x00FF) != ((int) ent->v->effects & 0x00FF))			bits |= U_EFFECTS;
-		if ((baseline->modelindex & 0x00FF) != ((int) ent->v->modelindex & 0x00FF))		bits |= U_MODEL;
-
-		// LordHavoc: new stuff
-		if (baseline->alpha != alpha)													bits |= U_ALPHA;
-		if (baseline->scale != scale)													bits |= U_SCALE;
-		if (((int) baseline->effects & 0xFF00) != ((int) ent->v->effects & 0xFF00))		bits |= U_EFFECTS2;
-		if (baseline->glowsize != glowsize)												bits |= U_GLOWSIZE;
-		if (baseline->glowcolor != glowcolor)											bits |= U_GLOWCOLOR;
-		if (((int) baseline->frame & 0xFF00) != ((int) ent->v->frame & 0xFF00))			bits |= U_FRAME2;
-		if (((int) baseline->frame & 0xFF00) != ((int) ent->v->modelindex & 0xFF00))		bits |= U_MODEL2;
-
-		// update delta baseline
-		VectorCopy(ent->v->origin, ent->e->deltabaseline.origin);
-		VectorCopy(ent->v->angles, ent->e->deltabaseline.angles);
-		ent->e->deltabaseline.colormap = ent->v->colormap;
-		ent->e->deltabaseline.skin = ent->v->skin;
-		ent->e->deltabaseline.frame = ent->v->frame;
-		ent->e->deltabaseline.effects = ent->v->effects;
-		ent->e->deltabaseline.modelindex = ent->v->modelindex;
-		ent->e->deltabaseline.alpha = alpha;
-		ent->e->deltabaseline.scale = scale;
-		ent->e->deltabaseline.glowsize = glowsize;
-		ent->e->deltabaseline.glowcolor = glowcolor;
-
-		// write the message
-		if (bits >= 16777216)
-			bits |= U_EXTEND2;
-		if (bits >= 65536)
-			bits |= U_EXTEND1;
-		if (bits >= 256)
-			bits |= U_MOREBITS;
-		bits |= U_SIGNAL;
-
-		MSG_WriteByte (msg, bits);
-		if (bits & U_MOREBITS)
-			MSG_WriteByte (msg, bits>>8);
-		// LordHavoc: extend bytes have to be written here due to delta compression
-		if (bits & U_EXTEND1)
-			MSG_WriteByte (msg, bits>>16);
-		if (bits & U_EXTEND2)
-			MSG_WriteByte (msg, bits>>24);
-
-		// LordHavoc: old stuff
-		if (bits & U_LONGENTITY)
-			MSG_WriteShort (msg,e);
-		else
-			MSG_WriteByte (msg,e);
-		if (bits & U_MODEL)		MSG_WriteByte(msg,	ent->v->modelindex);
-		if (bits & U_FRAME)		MSG_WriteByte(msg, ent->v->frame);
-		if (bits & U_COLORMAP)	MSG_WriteByte(msg, ent->v->colormap);
-		if (bits & U_SKIN)		MSG_WriteByte(msg, ent->v->skin);
-		if (bits & U_EFFECTS)	MSG_WriteByte(msg, ent->v->effects);
-		if (bits & U_ORIGIN1)	MSG_WriteDPCoord(msg, origin[0]);
-		if (bits & U_ANGLE1)	MSG_WriteAngle(msg, angles[0]);
-		if (bits & U_ORIGIN2)	MSG_WriteDPCoord(msg, origin[1]);
-		if (bits & U_ANGLE2)	MSG_WriteAngle(msg, angles[1]);
-		if (bits & U_ORIGIN3)	MSG_WriteDPCoord(msg, origin[2]);
-		if (bits & U_ANGLE3)	MSG_WriteAngle(msg, angles[2]);
-
-		// LordHavoc: new stuff
-		if (bits & U_ALPHA)		MSG_WriteByte(msg, alpha);
-		if (bits & U_SCALE)		MSG_WriteByte(msg, scale);
-		if (bits & U_EFFECTS2)	MSG_WriteByte(msg, (int)ent->v->effects >> 8);
-		if (bits & U_GLOWSIZE)	MSG_WriteByte(msg, glowsize);
-		if (bits & U_GLOWCOLOR)	MSG_WriteByte(msg, glowcolor);
-		if (bits & U_FRAME2)	MSG_WriteByte(msg, (int)ent->v->frame >> 8);
-		if (bits & U_MODEL2)	MSG_WriteByte(msg, (int)ent->v->modelindex >> 8);
-	}
-
-	if (sv_cullentities_stats.integer)
-		Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, totalentities, visibleentities, culled_pvs + culled_trace, culled_pvs, culled_trace);
-}
-#else
 static int numsendentities;
 static entity_state_t sendentities[MAX_EDICTS];
 static entity_state_t *sendentitiesindex[MAX_EDICTS];
@@ -725,7 +437,7 @@ void SV_PrepareEntitiesForSending(void)
 		if (ent->e->free)
 			continue;
 
-		ClearStateToDefault(&cs);
+		cs = defaultstate;
 		cs.active = true;
 		cs.number = e;
 		VectorCopy(ent->v->origin, cs.origin);
@@ -791,7 +503,40 @@ void SV_PrepareEntitiesForSending(void)
 		if (cs.viewmodelforclient)
 			cs.flags |= RENDER_VIEWMODEL; // show relative to the view
 
+		f = GETEDICTFIELDVALUE(ent, eval_color)->vector[0]*256;
+		cs.light[0] = (unsigned short)bound(0, f, 65535);
+		f = GETEDICTFIELDVALUE(ent, eval_color)->vector[1]*256;
+		cs.light[1] = (unsigned short)bound(0, f, 65535);
+		f = GETEDICTFIELDVALUE(ent, eval_color)->vector[2]*256;
+		cs.light[2] = (unsigned short)bound(0, f, 65535);
+		f = GETEDICTFIELDVALUE(ent, eval_light_lev)->_float;
+		cs.light[3] = (unsigned short)bound(0, f, 65535);
+		cs.lightstyle = (qbyte)GETEDICTFIELDVALUE(ent, eval_style)->_float;
+		cs.lightpflags = (qbyte)GETEDICTFIELDVALUE(ent, eval_pflags)->_float;
+
+		if (gamemode == GAME_TENEBRAE)
+		{
+			// tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
+			if (cs.effects & 16)
+			{
+				cs.effects &= ~16;
+				cs.lightpflags |= PFLAGS_FULLDYNAMIC;
+			}
+			// tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
+			if (cs.effects & 32)
+			{
+				cs.effects &= ~32;
+				cs.light[0] = 0.2;
+				cs.light[1] = 1;
+				cs.light[2] = 0.2;
+				cs.light[3] = 200;
+				cs.lightpflags |= PFLAGS_FULLDYNAMIC;
+			}
+		}
+
 		cs.specialvisibilityradius = 0;
+		if (cs.lightpflags & PFLAGS_FULLDYNAMIC)
+			cs.specialvisibilityradius = max(cs.specialvisibilityradius, cs.light[3]);
 		if (cs.glowsize)
 			cs.specialvisibilityradius = max(cs.specialvisibilityradius, cs.glowsize * 4);
 		if (cs.flags & RENDER_GLOWTRAIL)
@@ -842,6 +587,7 @@ static client_t *sv_writeentitiestoclient_client;
 
 void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 {
+	int isbmodel;
 	vec3_t entmins, entmaxs, lightmins, lightmaxs, testorigin;
 	model_t *model;
 	trace_t trace;
@@ -877,7 +623,8 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 				return;
 		}
 		// always send world submodels, they don't generate much traffic
-		else if ((model = sv.models[s->modelindex]) == NULL || model->name[0] != '*')
+		// except in PROTOCOL_QUAKE where they hog bandwidth like crazy
+		else if ((!(isbmodel = (model = sv.models[s->modelindex]) != NULL && model->name[0] == '*') && !(s->effects & EF_NODEPTHTEST)) || sv.protocol == PROTOCOL_QUAKE)
 		{
 			Mod_CheckLoaded(model);
 			// entity has survived every check so far, check if visible
@@ -912,9 +659,9 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 			lightmins[0] = min(entmins[0], s->origin[0] - s->specialvisibilityradius);
 			lightmins[1] = min(entmins[1], s->origin[1] - s->specialvisibilityradius);
 			lightmins[2] = min(entmins[2], s->origin[2] - s->specialvisibilityradius);
-			lightmaxs[0] = min(entmaxs[0], s->origin[0] + s->specialvisibilityradius);
-			lightmaxs[1] = min(entmaxs[1], s->origin[1] + s->specialvisibilityradius);
-			lightmaxs[2] = min(entmaxs[2], s->origin[2] + s->specialvisibilityradius);
+			lightmaxs[0] = max(entmaxs[0], s->origin[0] + s->specialvisibilityradius);
+			lightmaxs[1] = max(entmaxs[1], s->origin[1] + s->specialvisibilityradius);
+			lightmaxs[2] = max(entmaxs[2], s->origin[2] + s->specialvisibilityradius);
 			sv_writeentitiestoclient_totalentities++;
 			// if not touching a visible leaf
 			if (sv_cullentities_pvs.integer && sv_writeentitiestoclient_pvsbytes && sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv_writeentitiestoclient_pvs, lightmins, lightmaxs))
@@ -923,7 +670,7 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 				return;
 			}
 			// or not seen by random tracelines
-			if (sv_cullentities_trace.integer)
+			if (sv_cullentities_trace.integer && !isbmodel)
 			{
 				// LordHavoc: test center first
 				testorigin[0] = (entmins[0] + entmaxs[0]) * 0.5f;
@@ -970,34 +717,16 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 	sententities[s->number] = sententitiesmark;
 }
 
+entity_state_t sendstates[MAX_EDICTS]; 
+
 void SV_WriteEntitiesToClient(client_t *client, edict_t *clent, sizebuf_t *msg)
 {
-	int i;
-	vec3_t testorigin;
+	int i, numsendstates;
 	entity_state_t *s;
-	entity_database4_t *d;
-	int maxbytes, n, startnumber;
-	entity_state_t *e, inactiveentitystate;
-	sizebuf_t buf;
-	qbyte data[128];
-	// prepare the buffer
-	memset(&buf, 0, sizeof(buf));
-	buf.data = data;
-	buf.maxsize = sizeof(data);
-
-	d = client->entitydatabase4;
-
-	for (i = 0;i < MAX_ENTITY_HISTORY;i++)
-		if (!d->commit[i].numentities)
-			break;
-	// if commit buffer full, just don't bother writing an update this frame
-	if (i == MAX_ENTITY_HISTORY)
-		return;
-	d->currentcommit = d->commit + i;
 
-	// this state's number gets played around with later
-	ClearStateToDefault(&inactiveentitystate);
-	//inactiveentitystate = defaultstate;
+	// if there isn't enough space to accomplish anything, skip it
+	if (msg->cursize + 25 > msg->maxsize)
+		return;
 
 	sv_writeentitiestoclient_client = client;
 
@@ -1019,106 +748,33 @@ void SV_WriteEntitiesToClient(client_t *client, edict_t *clent, sizebuf_t *msg)
 
 	sententitiesmark++;
 
-	// the place being reported (to consider the fact the client still
-	// applies the view_ofs[2], so we have to only send the fractional part
-	// of view_ofs[2], undoing what the client will redo)
-	VectorCopy(sv_writeentitiestoclient_testeye, testorigin);
-	i = (int) clent->v->view_ofs[2] & 255;
-	if (i >= 128)
-		i -= 256;
-	testorigin[2] -= (float) i;
-
 	for (i = 0;i < numsendentities;i++)
 		SV_MarkWriteEntityStateToClient(sendentities + i);
 
-	// calculate maximum bytes to allow in this packet
-	// deduct 4 to account for the end data
-	maxbytes = min(msg->maxsize, MAX_PACKETFRAGMENT) - 4;
-
-	d->currentcommit->numentities = 0;
-	d->currentcommit->framenum = ++client->entityframenumber;
-	MSG_WriteByte(msg, svc_entities);
-	MSG_WriteLong(msg, d->referenceframenum);
-	MSG_WriteLong(msg, d->currentcommit->framenum);
-	if (developer_networkentities.integer >= 1)
-	{
-		Con_Printf("send svc_entities ref:%i num:%i (database: ref:%i commits:", d->referenceframenum, d->currentcommit->framenum, d->referenceframenum);
-		for (i = 0;i < MAX_ENTITY_HISTORY;i++)
-			if (d->commit[i].numentities)
-				Con_Printf(" %i", d->commit[i].framenum);
-		Con_Printf(")\n");
-	}
-	if (d->currententitynumber >= sv.max_edicts)
-		startnumber = 1;
-	else
-		startnumber = bound(1, d->currententitynumber, sv.max_edicts - 1);
-	MSG_WriteShort(msg, startnumber);
-	// reset currententitynumber so if the loop does not break it we will
-	// start at beginning next frame (if it does break, it will set it)
-	d->currententitynumber = 1;
-	for (i = 0, n = startnumber;n < sv.max_edicts;n++)
+	numsendstates = 0;
+	for (i = 0;i < numsendentities;i++)
 	{
-		// find the old state to delta from
-		e = EntityFrame4_GetReferenceEntity(d, n);
-		// prepare the buffer
-		SZ_Clear(&buf);
-		// make the message
-		if (sententities[n] == sententitiesmark)
+		if (sententities[sendentities[i].number] == sententitiesmark)
 		{
-			// entity exists, build an update (if empty there is no change)
-			// find the state in the list
-			for (;i < numsendentities && sendentities[i].number < n;i++);
-			s = sendentities + i;
-			if (s->number != n)
-				Sys_Error("SV_WriteEntitiesToClient: s->number != n\n");
-			// build the update
+			s = &sendstates[numsendstates++];
+			*s = sendentities[i];
 			if (s->exteriormodelforclient && s->exteriormodelforclient == sv_writeentitiestoclient_clentnum)
-			{
 				s->flags |= RENDER_EXTERIORMODEL;
-				EntityState_Write(s, &buf, e);
-				s->flags &= ~RENDER_EXTERIORMODEL;
-			}
-			else
-				EntityState_Write(s, &buf, e);
-		}
-		else
-		{
-			s = &inactiveentitystate;
-			s->number = n;
-			if (e->active)
-			{
-				// 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 > maxbytes)
-		{
-			// next frame we will continue where we left off
-			break;
-		}
-		// add the entity to the commit
-		EntityFrame4_AddCommitEntity(d, s);
-		// if the message is empty, skip out now
-		if (buf.cursize)
-		{
-			// write the message to the packet
-			SZ_Write(msg, buf.data, buf.cursize);
 		}
 	}
-	d->currententitynumber = n;
-
-	// remove world message (invalid, and thus a good terminator)
-	MSG_WriteShort(msg, 0x8000);
-	// write the number of the end entity
-	MSG_WriteShort(msg, d->currententitynumber);
-	// just to be sure
-	d->currentcommit = NULL;
 
 	if (sv_cullentities_stats.integer)
 		Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, sv_writeentitiestoclient_totalentities, sv_writeentitiestoclient_visibleentities, sv_writeentitiestoclient_culled_pvs + sv_writeentitiestoclient_culled_trace, sv_writeentitiestoclient_culled_pvs, sv_writeentitiestoclient_culled_trace);
+
+	if (client->entitydatabase5)
+		EntityFrame5_WriteFrame(msg, client->entitydatabase5, numsendstates, sendstates, client - svs.clients + 1);
+	else if (client->entitydatabase4)
+		EntityFrame4_WriteFrame(msg, client->entitydatabase4, numsendstates, sendstates);
+	else if (client->entitydatabase)
+		EntityFrame_WriteFrame(msg, client->entitydatabase, numsendstates, sendstates, client - svs.clients + 1);
+	else
+		EntityFrameQuake_WriteFrame(msg, numsendstates, sendstates);
 }
-#endif
 
 /*
 =============
@@ -1162,7 +818,7 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 		MSG_WriteByte (msg, ent->v->dmg_save);
 		MSG_WriteByte (msg, ent->v->dmg_take);
 		for (i=0 ; i<3 ; i++)
-			MSG_WriteDPCoord (msg, other->v->origin[i] + 0.5*(other->v->mins[i] + other->v->maxs[i]));
+			MSG_WriteCoord (msg, other->v->origin[i] + 0.5*(other->v->mins[i] + other->v->maxs[i]), sv.protocol);
 
 		ent->v->dmg_take = 0;
 		ent->v->dmg_save = 0;
@@ -1178,7 +834,7 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 	{
 		MSG_WriteByte (msg, svc_setangle);
 		for (i=0 ; i < 3 ; i++)
-			MSG_WriteAngle (msg, ent->v->angles[i] );
+			MSG_WriteAngle (msg, ent->v->angles[i], sv.protocol);
 		ent->v->fixangle = 0;
 	}
 
@@ -1219,19 +875,22 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 		if (i == 0)
 			i = 255;
 		else
-			i = bound(0, i, 255);
+			i = bound(0, i, 65535);
 	}
 	viewzoom = i;
 
-	if (viewzoom != 255)
-		bits |= SU_VIEWZOOM;
+	// FIXME: which protocols support this?  does PROTOCOL_DARKPLACES3 support viewzoom?
+	if (sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
+		if (viewzoom != 255)
+			bits |= SU_VIEWZOOM;
 
 	for (i=0 ; i<3 ; i++)
 	{
 		if (ent->v->punchangle[i])
 			bits |= (SU_PUNCH1<<i);
-		if (punchvector[i]) // PROTOCOL_DARKPLACES
-			bits |= (SU_PUNCHVEC1<<i); // PROTOCOL_DARKPLACES
+		if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
+			if (punchvector[i])
+				bits |= (SU_PUNCHVEC1<<i);
 		if (ent->v->velocity[i])
 			bits |= (SU_VELOCITY1<<i);
 	}
@@ -1267,48 +926,114 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 	for (i=0 ; i<3 ; i++)
 	{
 		if (bits & (SU_PUNCH1<<i))
-			MSG_WritePreciseAngle(msg, ent->v->punchangle[i]); // PROTOCOL_DARKPLACES
-		if (bits & (SU_PUNCHVEC1<<i)) // PROTOCOL_DARKPLACES
-			MSG_WriteDPCoord(msg, punchvector[i]); // PROTOCOL_DARKPLACES
+		{
+			if (sv.protocol == PROTOCOL_QUAKE)
+				MSG_WriteChar(msg, ent->v->punchangle[i]);
+			else if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
+				MSG_WriteAngle16i(msg, ent->v->punchangle[i]);
+		}
+		if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
+		{
+			if (bits & (SU_PUNCHVEC1<<i))
+			{
+				if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
+					MSG_WriteCoord16i(msg, punchvector[i]);
+				else if (sv.protocol == PROTOCOL_DARKPLACES5)
+					MSG_WriteCoord32f(msg, punchvector[i]);
+			}
+		}
 		if (bits & (SU_VELOCITY1<<i))
-			MSG_WriteChar (msg, ent->v->velocity[i]/16);
+		{
+			if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
+				MSG_WriteChar(msg, ent->v->velocity[i] * (1.0f / 16.0f));
+			else if (sv.protocol == PROTOCOL_DARKPLACES5)
+				MSG_WriteCoord32f(msg, ent->v->velocity[i]);
+		}
 	}
 
 // [always sent]	if (bits & SU_ITEMS)
 	MSG_WriteLong (msg, items);
 
-	if (bits & SU_WEAPONFRAME)
-		MSG_WriteByte (msg, ent->v->weaponframe);
-	if (bits & SU_ARMOR)
-		MSG_WriteByte (msg, ent->v->armorvalue);
-	if (bits & SU_WEAPON)
-		MSG_WriteByte (msg, SV_ModelIndex(PR_GetString(ent->v->weaponmodel)));
-
-	MSG_WriteShort (msg, ent->v->health);
-	MSG_WriteByte (msg, ent->v->currentammo);
-	MSG_WriteByte (msg, ent->v->ammo_shells);
-	MSG_WriteByte (msg, ent->v->ammo_nails);
-	MSG_WriteByte (msg, ent->v->ammo_rockets);
-	MSG_WriteByte (msg, ent->v->ammo_cells);
-
-	if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
+	if (sv.protocol == PROTOCOL_DARKPLACES5)
 	{
-		for(i=0;i<32;i++)
+		if (bits & SU_WEAPONFRAME)
+			MSG_WriteShort (msg, ent->v->weaponframe);
+		if (bits & SU_ARMOR)
+			MSG_WriteShort (msg, ent->v->armorvalue);
+		if (bits & SU_WEAPON)
 		{
-			if ( ((int)ent->v->weapon) & (1<<i) )
+			i = SV_ModelIndex(PR_GetString(ent->v->weaponmodel));
+			if (i < 0)
 			{
-				MSG_WriteByte (msg, i);
-				break;
+				Con_DPrintf("weaponmodel \"%s\" not precached\n", PR_GetString(ent->v->weaponmodel));
+				i = 0;
 			}
+			MSG_WriteShort (msg, i);
 		}
+
+		MSG_WriteShort (msg, ent->v->health);
+		MSG_WriteShort (msg, ent->v->currentammo);
+		MSG_WriteShort (msg, ent->v->ammo_shells);
+		MSG_WriteShort (msg, ent->v->ammo_nails);
+		MSG_WriteShort (msg, ent->v->ammo_rockets);
+		MSG_WriteShort (msg, ent->v->ammo_cells);
+
+		MSG_WriteShort (msg, ent->v->weapon);
+	
+		if (bits & SU_VIEWZOOM)
+			MSG_WriteShort (msg, viewzoom);
 	}
 	else
 	{
-		MSG_WriteByte (msg, ent->v->weapon);
-	}
+		if (bits & SU_WEAPONFRAME)
+			MSG_WriteByte (msg, ent->v->weaponframe);
+		if (bits & SU_ARMOR)
+			MSG_WriteByte (msg, ent->v->armorvalue);
+		if (bits & SU_WEAPON)
+		{
+			i = SV_ModelIndex(PR_GetString(ent->v->weaponmodel));
+			if (i < 0)
+			{
+				Con_DPrintf("weaponmodel \"%s\" not precached\n", PR_GetString(ent->v->weaponmodel));
+				i = 0;
+			}
+			MSG_WriteByte (msg, i);
+		}
+
+		MSG_WriteShort (msg, ent->v->health);
+		MSG_WriteByte (msg, ent->v->currentammo);
+		MSG_WriteByte (msg, ent->v->ammo_shells);
+		MSG_WriteByte (msg, ent->v->ammo_nails);
+		MSG_WriteByte (msg, ent->v->ammo_rockets);
+		MSG_WriteByte (msg, ent->v->ammo_cells);
 
-	if (bits & SU_VIEWZOOM)
-		MSG_WriteByte (msg, viewzoom);
+		if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
+		{
+			for(i=0;i<32;i++)
+			{
+				if ( ((int)ent->v->weapon) & (1<<i) )
+				{
+					MSG_WriteByte (msg, i);
+					break;
+				}
+			}
+		}
+		else
+		{
+			MSG_WriteByte (msg, ent->v->weapon);
+		}
+	
+		if (bits & SU_VIEWZOOM)
+		{
+			if (sv.protocol == PROTOCOL_DARKPLACES4)
+			{
+				viewzoom = min(viewzoom, 255);
+				MSG_WriteByte (msg, viewzoom);
+			}
+			else if (sv.protocol == PROTOCOL_DARKPLACES5)
+				MSG_WriteShort (msg, viewzoom);
+		}
+	}
 }
 
 /*
@@ -1316,13 +1041,41 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 SV_SendClientDatagram
 =======================
 */
-static qbyte sv_sendclientdatagram_buf[MAX_DATAGRAM]; // FIXME?
+static qbyte sv_sendclientdatagram_buf[NET_MAXMESSAGE]; // FIXME?
 qboolean SV_SendClientDatagram (client_t *client)
 {
-	sizebuf_t	msg;
+	int rate, maxrate, maxsize, maxsize2;
+	sizebuf_t msg;
+
+	if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !sv_ratelimitlocalplayer.integer)
+	{
+		// for good singleplayer, send huge packets
+		maxsize = sizeof(sv_sendclientdatagram_buf);
+		maxsize2 = sizeof(sv_sendclientdatagram_buf);
+	}
+	else if (sv.protocol == PROTOCOL_DARKPLACES5)
+	{
+		// PROTOCOL_DARKPLACES5 supports packet size limiting of updates
+		maxrate = bound(NET_MINRATE, sv_maxrate.integer, NET_MAXRATE);
+		if (sv_maxrate.integer != maxrate)
+			Cvar_SetValueQuick(&sv_maxrate, maxrate);
+
+		rate = bound(NET_MINRATE, client->netconnection->rate, maxrate);
+		rate = (int)(client->netconnection->rate * sys_ticrate.value);
+		maxsize = bound(100, rate, 1400);
+		maxsize2 = 1400;
+	}
+	else
+	{
+		// no rate limiting support on older protocols because dp protocols
+		// 1-4 kick the client off if they overflow, and quake protocol shows
+		// less than the full entity set if rate limited
+		maxsize = 1400;
+		maxsize2 = 1400;
+	}
 
 	msg.data = sv_sendclientdatagram_buf;
-	msg.maxsize = sizeof(sv_sendclientdatagram_buf);
+	msg.maxsize = maxsize;
 	msg.cursize = 0;
 
 	MSG_WriteByte (&msg, svc_time);
@@ -1333,8 +1086,13 @@ qboolean SV_SendClientDatagram (client_t *client)
 
 	SV_WriteEntitiesToClient (client, client->edict, &msg);
 
+	// expand packet size to allow effects to go over the rate limit
+	// (dropping them is FAR too ugly)
+	msg.maxsize = maxsize2;
+
 	// copy the server datagram if there is space
-	if (msg.cursize + sv.datagram.cursize < msg.maxsize)
+	// FIXME: put in delayed queue of effects to send
+	if (sv.datagram.cursize > 0 && msg.cursize + sv.datagram.cursize <= msg.maxsize)
 		SZ_Write (&msg, sv.datagram.data, sv.datagram.cursize);
 
 // send the datagram
@@ -1554,11 +1312,13 @@ int SV_ModelIndex (const char *name)
 		if (!strcmp(sv.model_precache[i], name))
 			return i;
 	if (i==MAX_MODELS || !sv.model_precache[i])
-		Host_Error ("SV_ModelIndex: model %s not precached", name);
+	{
+		Con_DPrintf ("SV_ModelIndex: model %s not precached", name);
+		return -1;
+	}
 	return i;
 }
 
-#ifdef SV_QUAKEENTITIES
 /*
 ================
 SV_CreateBaseline
@@ -1577,7 +1337,7 @@ void SV_CreateBaseline (void)
 		svent = EDICT_NUM(entnum);
 
 		// LordHavoc: always clear state values, whether the entity is in use or not
-		ClearStateToDefault(&svent->e->baseline);
+		svent->e->baseline = defaultstate;
 
 		if (svent->e->free)
 			continue;
@@ -1592,7 +1352,10 @@ void SV_CreateBaseline (void)
 		if (entnum > 0 && entnum <= svs.maxclients)
 		{
 			svent->e->baseline.colormap = entnum;
-			svent->e->baseline.modelindex = SV_ModelIndex("progs/player.mdl");
+			i = SV_ModelIndex("progs/player.mdl");
+			if (i < 0)
+				i = 0;
+			svent->e->baseline.modelindex = i;
 		}
 		else
 		{
@@ -1625,12 +1388,11 @@ void SV_CreateBaseline (void)
 		MSG_WriteByte (&sv.signon, svent->e->baseline.skin);
 		for (i=0 ; i<3 ; i++)
 		{
-			MSG_WriteDPCoord(&sv.signon, svent->e->baseline.origin[i]);
-			MSG_WriteAngle(&sv.signon, svent->e->baseline.angles[i]);
+			MSG_WriteCoord(&sv.signon, svent->e->baseline.origin[i], sv.protocol);
+			MSG_WriteAngle(&sv.signon, svent->e->baseline.angles[i], sv.protocol);
 		}
 	}
 }
-#endif
 
 
 /*
@@ -1742,13 +1504,24 @@ void SV_SpawnServer (const char *server)
 	edict_t *ent;
 	int i;
 	qbyte *entities;
+	model_t *worldmodel;
+	char modelname[sizeof(sv.modelname)];
+
+	Con_DPrintf("SpawnServer: %s\n", server);
+
+	snprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
+	worldmodel = Mod_ForName(modelname, false, true, true);
+	if (!worldmodel || !worldmodel->TraceBox)
+	{
+		Con_Printf("Couldn't load map %s\n", modelname);
+		return;
+	}
 
 	// let's not have any servers with no name
 	if (hostname.string[0] == 0)
 		Cvar_Set ("hostname", "UNNAMED");
 	scr_centertime_off = 0;
 
-	Con_DPrintf ("SpawnServer: %s\n",server);
 	svs.changelevel_issued = false;		// now safe to issue another
 
 //
@@ -1757,7 +1530,11 @@ void SV_SpawnServer (const char *server)
 	if (sv.active)
 		SV_SendReconnect();
 	else
+	{
+		// make sure cvars have been checked before opening the ports
+		NetConn_ServerFrame();
 		NetConn_OpenServerPorts(true);
+	}
 
 //
 // make cvars consistant
@@ -1777,6 +1554,49 @@ void SV_SpawnServer (const char *server)
 
 	strlcpy (sv.name, server, sizeof (sv.name));
 
+	// FIXME: cvar
+	if (!strcasecmp(sv_protocolname.string, "QUAKE"))
+	{
+		sv.protocol = PROTOCOL_QUAKE;
+		sv.netquakecompatible = true;
+	}
+	else if (!strcasecmp(sv_protocolname.string, "QUAKEDP"))
+	{
+		sv.protocol = PROTOCOL_QUAKE;
+		sv.netquakecompatible = false;
+	}
+	else if (!strcasecmp(sv_protocolname.string, "DARKPLACES1"))
+	{
+		sv.protocol = PROTOCOL_DARKPLACES1;
+		sv.netquakecompatible = false;
+	}
+	else if (!strcasecmp(sv_protocolname.string, "DARKPLACES2"))
+	{
+		sv.protocol = PROTOCOL_DARKPLACES2;
+		sv.netquakecompatible = false;
+	}
+	else if (!strcasecmp(sv_protocolname.string, "DARKPLACES3"))
+	{
+		sv.protocol = PROTOCOL_DARKPLACES3;
+		sv.netquakecompatible = false;
+	}
+	else if (!strcasecmp(sv_protocolname.string, "DARKPLACES4"))
+	{
+		sv.protocol = PROTOCOL_DARKPLACES4;
+		sv.netquakecompatible = false;
+	}
+	else if (!strcasecmp(sv_protocolname.string, "DARKPLACES5"))
+	{
+		sv.protocol = PROTOCOL_DARKPLACES5;
+		sv.netquakecompatible = false;
+	}
+	else
+	{
+		sv.protocol = PROTOCOL_DARKPLACES5;
+		sv.netquakecompatible = false;
+		Con_Printf("Unknown sv_protocolname \"%s\", valid values are QUAKE, QUAKEDP, DARKPLACES1, DARKPLACES2, DARKPLACES3, DARKPLACES4, DARKPLACES5, falling back to DARKPLACES5 protocol\n", sv_protocolname.string);
+	}
+
 // load progs to get entity field count
 	PR_LoadProgs ();
 
@@ -1823,16 +1643,11 @@ void SV_SpawnServer (const char *server)
 	sv.time = 1.0;
 
 	Mod_ClearUsed();
+	worldmodel->used = true;
 
 	strlcpy (sv.name, server, sizeof (sv.name));
-	snprintf (sv.modelname, sizeof (sv.modelname), "maps/%s.bsp", server);
-	sv.worldmodel = Mod_ForName(sv.modelname, false, true, true);
-	if (!sv.worldmodel)
-	{
-		Con_Printf ("Couldn't spawn server %s\n", sv.modelname);
-		sv.active = false;
-		return;
-	}
+	strcpy(sv.modelname, modelname);
+	sv.worldmodel = worldmodel;
 	sv.models[1] = sv.worldmodel;
 
 //
@@ -1874,7 +1689,7 @@ void SV_SpawnServer (const char *server)
 	// load replacement entity file if found
 	entities = NULL;
 	if (sv_entpatch.integer)
-		entities = FS_LoadFile(va("maps/%s.ent", sv.name), true);
+		entities = FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true);
 	if (entities)
 	{
 		Con_Printf("Loaded maps/%s.ent\n", sv.name);
@@ -1902,17 +1717,16 @@ void SV_SpawnServer (const char *server)
 
 	Mod_PurgeUnused();
 
-#ifdef QUAKEENTITIES
 // create a baseline for more efficient communications
-	SV_CreateBaseline ();
-#endif
+	if (sv.protocol == PROTOCOL_QUAKE)
+		SV_CreateBaseline ();
 
 // send serverinfo to all connected clients
 	for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
 		if (host_client->netconnection)
 			SV_SendServerinfo(host_client);
 
-	Con_DPrintf ("Server spawned.\n");
+	Con_DPrint("Server spawned.\n");
 	NetConn_Heartbeat (2);
 }