X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=sv_main.c;h=a46d87d22370bfcdc1c6504cc8320d3c1d69d437;hb=69a21479a3466471cecff1eae841893028cb1da7;hp=9a3c37ed3b6df8e4ec7c86c6d454839387768106;hpb=cc3c823ce3baf63d6d8f216c3bf4df88496eb231;p=xonotic%2Fdarkplaces.git

diff --git a/sv_main.c b/sv_main.c
index 9a3c37ed..a46d87d2 100644
--- a/sv_main.c
+++ b/sv_main.c
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -21,10 +21,17 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
+static cvar_t sv_pvscheckentities = {0, "sv_pvscheckentities", "1"};
+static cvar_t sv_vischeckentities = {0, "sv_vischeckentities", "0"}; // extremely accurate visibility checking, but too slow
+static cvar_t sv_reportvischeckentities = {0, "sv_reportvischeckentities", "0"};
+static int sv_vischeckentitycullcount = 0;
+
 server_t		sv;
 server_static_t	svs;
 
-char	localmodels[MAX_MODELS][5];			// inline model names for precache
+static char localmodels[MAX_MODELS][5];			// inline model names for precache
+
+static mempool_t *sv_edicts_mempool = NULL;
 
 //============================================================================
 
@@ -35,18 +42,7 @@ SV_Init
 */
 void SV_Init (void)
 {
-	int		i;
-	extern	cvar_t	sv_maxvelocity;
-	extern	cvar_t	sv_gravity;
-	extern	cvar_t	sv_nostep;
-	extern	cvar_t	sv_friction;
-	extern	cvar_t	sv_edgefriction;
-	extern	cvar_t	sv_stopspeed;
-	extern	cvar_t	sv_maxspeed;
-	extern	cvar_t	sv_accelerate;
-	extern	cvar_t	sv_idealpitchscale;
-	extern	cvar_t	sv_aim;
-	extern	cvar_t	sv_predict;
+	int i;
 
 	Cvar_RegisterVariable (&sv_maxvelocity);
 	Cvar_RegisterVariable (&sv_gravity);
@@ -59,9 +55,15 @@ void SV_Init (void)
 	Cvar_RegisterVariable (&sv_aim);
 	Cvar_RegisterVariable (&sv_nostep);
 	Cvar_RegisterVariable (&sv_predict);
+	Cvar_RegisterVariable (&sv_deltacompress);
+	Cvar_RegisterVariable (&sv_pvscheckentities);
+	Cvar_RegisterVariable (&sv_vischeckentities);
+	Cvar_RegisterVariable (&sv_reportvischeckentities);
 
-	for (i=0 ; i<MAX_MODELS ; i++)
+	for (i = 0;i < MAX_MODELS;i++)
 		sprintf (localmodels[i], "*%i", i);
+
+	sv_edicts_mempool = Mem_AllocPool("edicts");
 }
 
 /*
@@ -72,7 +74,7 @@ EVENT MESSAGES
 =============================================================================
 */
 
-/*  
+/*
 ==================
 SV_StartParticle
 
@@ -84,7 +86,7 @@ void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
 	int		i, v;
 
 	if (sv.datagram.cursize > MAX_DATAGRAM-16)
-		return;	
+		return;
 	MSG_WriteByte (&sv.datagram, svc_particle);
 	MSG_WriteFloatCoord (&sv.datagram, org[0]);
 	MSG_WriteFloatCoord (&sv.datagram, org[1]);
@@ -100,9 +102,44 @@ void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
 	}
 	MSG_WriteByte (&sv.datagram, count);
 	MSG_WriteByte (&sv.datagram, color);
-}           
+}
+
+/*
+==================
+SV_StartEffect
+
+Make sure the event gets sent to all clients
+==================
+*/
+void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
+{
+	if (sv.datagram.cursize > MAX_DATAGRAM-18)
+		return;
+	if (modelindex >= 256 || startframe >= 256)
+	{
+		MSG_WriteByte (&sv.datagram, svc_effect2);
+		MSG_WriteFloatCoord (&sv.datagram, org[0]);
+		MSG_WriteFloatCoord (&sv.datagram, org[1]);
+		MSG_WriteFloatCoord (&sv.datagram, org[2]);
+		MSG_WriteShort (&sv.datagram, modelindex);
+		MSG_WriteShort (&sv.datagram, startframe);
+		MSG_WriteByte (&sv.datagram, framecount);
+		MSG_WriteByte (&sv.datagram, framerate);
+	}
+	else
+	{
+		MSG_WriteByte (&sv.datagram, svc_effect);
+		MSG_WriteFloatCoord (&sv.datagram, org[0]);
+		MSG_WriteFloatCoord (&sv.datagram, org[1]);
+		MSG_WriteFloatCoord (&sv.datagram, org[2]);
+		MSG_WriteByte (&sv.datagram, modelindex);
+		MSG_WriteByte (&sv.datagram, startframe);
+		MSG_WriteByte (&sv.datagram, framecount);
+		MSG_WriteByte (&sv.datagram, framerate);
+	}
+}
 
-/*  
+/*
 ==================
 SV_StartSound
 
@@ -110,21 +147,21 @@ Each entity can have eight independant sound sources, like voice,
 weapon, feet, etc.
 
 Channel 0 is an auto-allocate channel, the others override anything
-allready running on that entity/channel pair.
+already running on that entity/channel pair.
 
 An attenuation of 0 will play full volume everywhere in the level.
 Larger attenuations will drop off.  (max 4 attenuation)
 
 ==================
-*/  
+*/
 void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
     float attenuation)
-{       
+{
     int         sound_num;
     int field_mask;
     int			i;
 	int			ent;
-	
+
 	if (volume < 0 || volume > 255)
 		Host_Error ("SV_StartSound: volume = %i", volume);
 
@@ -135,20 +172,20 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
 		Host_Error ("SV_StartSound: channel = %i", channel);
 
 	if (sv.datagram.cursize > MAX_DATAGRAM-16)
-		return;	
+		return;
 
 // find precache number for sound
     for (sound_num=1 ; sound_num<MAX_SOUNDS
         && sv.sound_precache[sound_num] ; sound_num++)
         if (!strcmp(sample, sv.sound_precache[sound_num]))
             break;
-    
+
     if ( sound_num == MAX_SOUNDS || !sv.sound_precache[sound_num] )
     {
         Con_Printf ("SV_StartSound: %s not precached\n", sample);
         return;
     }
-    
+
 	ent = NUM_FOR_EDICT(entity);
 
 	channel = (ent<<3) | channel;
@@ -159,18 +196,24 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
 	if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
 		field_mask |= SND_ATTENUATION;
 
-// directed messages go only to the entity the are targeted on
-	MSG_WriteByte (&sv.datagram, svc_sound);
+// directed messages go only to the entity they are targeted on
+	if (sound_num >= 256)
+		MSG_WriteByte (&sv.datagram, svc_sound2);
+	else
+		MSG_WriteByte (&sv.datagram, svc_sound);
 	MSG_WriteByte (&sv.datagram, field_mask);
 	if (field_mask & SND_VOLUME)
 		MSG_WriteByte (&sv.datagram, volume);
 	if (field_mask & SND_ATTENUATION)
 		MSG_WriteByte (&sv.datagram, attenuation*64);
 	MSG_WriteShort (&sv.datagram, channel);
-	MSG_WriteByte (&sv.datagram, sound_num);
+	if (sound_num >= 256)
+		MSG_WriteShort (&sv.datagram, sound_num);
+	else
+		MSG_WriteByte (&sv.datagram, sound_num);
 	for (i=0 ; i<3 ; i++)
 		MSG_WriteFloatCoord (&sv.datagram, entity->v.origin[i]+0.5*(entity->v.mins[i]+entity->v.maxs[i]));
-}           
+}
 
 /*
 ==============================================================================
@@ -194,14 +237,14 @@ void SV_SendServerinfo (client_t *client)
 	char			message[2048];
 
 	MSG_WriteByte (&client->message, svc_print);
-	sprintf (message, "%c\nDARKPLACES VERSION %4.2f BUILD %i SERVER (%i CRC)", 2, VERSION, buildnumber, pr_crc);
+	sprintf (message, "\002\nServer: %s build %i (progs %i crc)", gamename, buildnumber, pr_crc);
 	MSG_WriteString (&client->message,message);
 
 	MSG_WriteByte (&client->message, svc_serverinfo);
 	MSG_WriteLong (&client->message, DPPROTOCOL_VERSION);
 	MSG_WriteByte (&client->message, svs.maxclients);
 
-	if (!coop.value && deathmatch.value)
+	if (!coop.integer && deathmatch.integer)
 		MSG_WriteByte (&client->message, GAME_DEATHMATCH);
 	else
 		MSG_WriteByte (&client->message, GAME_COOP);
@@ -223,7 +266,7 @@ void SV_SendServerinfo (client_t *client)
 	MSG_WriteByte (&client->message, sv.edicts->v.sounds);
 	MSG_WriteByte (&client->message, sv.edicts->v.sounds);
 
-// set view	
+// set view
 	MSG_WriteByte (&client->message, svc_setview);
 	MSG_WriteShort (&client->message, NUM_FOR_EDICT(client->edict));
 
@@ -258,10 +301,10 @@ void SV_ConnectClient (int clientnum)
 	edictnum = clientnum+1;
 
 	ent = EDICT_NUM(edictnum);
-	
+
 // set up the client_t
 	netconnection = client->netconnection;
-	
+
 	if (sv.loadgame)
 		memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
 	memset (client, 0, sizeof(*client));
@@ -299,7 +342,7 @@ void SV_CheckForNewClients (void)
 {
 	struct qsocket_s	*ret;
 	int				i;
-		
+
 //
 // check for new connections
 //
@@ -309,18 +352,18 @@ void SV_CheckForNewClients (void)
 		if (!ret)
 			break;
 
-	// 
+	//
 	// init a new client structure
-	//	
+	//
 		for (i=0 ; i<svs.maxclients ; i++)
 			if (!svs.clients[i].active)
 				break;
 		if (i == svs.maxclients)
 			Sys_Error ("Host_CheckForNewClients: no free clients");
-		
+
 		svs.clients[i].netconnection = ret;
-		SV_ConnectClient (i);	
-	
+		SV_ConnectClient (i);
+
 		net_activeconnections++;
 	}
 }
@@ -380,7 +423,7 @@ void SV_AddToFatPVS (vec3_t org, mnode_t *node)
 			}
 			return;
 		}
-	
+
 		plane = node->plane;
 		d = DotProduct (org, plane->normal) - plane->dist;
 		if (d > 8)
@@ -414,6 +457,40 @@ byte *SV_FatPVS (vec3_t org)
 //=============================================================================
 
 
+int SV_BoxTouchingPVS (byte *pvs, vec3_t mins, vec3_t maxs, mnode_t *node)
+{
+	int leafnum;
+loc0:
+	if (node->contents < 0)
+	{
+		// leaf
+		if (node->contents == CONTENTS_SOLID)
+			return false;
+		leafnum = (mleaf_t *)node - sv.worldmodel->leafs - 1;
+		return pvs[leafnum >> 3] & (1 << (leafnum & 7));
+	}
+
+	// node - recurse down the BSP tree
+	switch (BOX_ON_PLANE_SIDE(mins, maxs, node->plane))
+	{
+	case 1: // front
+		node = node->children[0];
+		goto loc0;
+	case 2: // back
+		node = node->children[1];
+		goto loc0;
+	default: // crossing
+		if (node->children[0]->contents != CONTENTS_SOLID)
+			if (SV_BoxTouchingPVS (pvs, mins, maxs, node->children[0]))
+				return true;
+		node = node->children[1];
+		goto loc0;
+	}
+	// never reached
+	return false;
+}
+
+
 /*
 =============
 SV_WriteEntitiesToClient
@@ -422,39 +499,49 @@ SV_WriteEntitiesToClient
 */
 void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 {
-	int		e, i, clentnum, bits, alpha, glowcolor, glowsize, scale, colormod, modred, modgreen, modblue, dodelta, effects;
+	int		e, clentnum, bits, alpha, glowcolor, glowsize, scale, effects;
 	byte	*pvs;
-	vec3_t	org, origin, angles;
-	float	movelerp, moveilerp;
+	vec3_t	org, origin, angles, entmins, entmaxs;
+	float	nextfullupdate;
 	edict_t	*ent;
-	eval_t  *val;
-	entity_state_t *baseline; // LordHavoc: delta or startup baseline
+	eval_t	*val;
+	entity_state_t	*baseline; // LordHavoc: delta or startup baseline
+	trace_t	trace;
+	model_t	*model;
+
+	Mod_CheckLoaded(sv.worldmodel);
 
 // find the client's PVS
 	VectorAdd (clent->v.origin, clent->v.view_ofs, org);
 	pvs = SV_FatPVS (org);
 	/*
-	if (dpprotocol)
-	{
-		MSG_WriteByte(msg, svc_playerposition);
-		MSG_WriteFloat(msg, org[0]);
-		MSG_WriteFloat(msg, org[1]);
-		MSG_WriteFloat(msg, org[2]);
-	}
+	// dp protocol
+	MSG_WriteByte(msg, svc_playerposition);
+	MSG_WriteFloat(msg, org[0]);
+	MSG_WriteFloat(msg, org[1]);
+	MSG_WriteFloat(msg, org[2]);
 	*/
 
 	clentnum = EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
-// send over all entities (except the client) that touch the pvs
+	// send all entities that touch the pvs
 	ent = NEXT_EDICT(sv.edicts);
-	for (e=1 ; e<sv.num_edicts ; e++, ent = NEXT_EDICT(ent))
+	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)
-					continue; // don't show to anyone else
+				{
+					// don't show to anyone else
+					continue;
+				}
 				else
 					bits |= U_VIEWMODEL; // show relative to the view
 			}
@@ -465,46 +552,111 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 					continue;
 				if ((val = GETEDICTFIELDVALUE(ent, eval_drawonlytoclient)) && val->edict && val->edict != clentnum)
 					continue;
-				// ignore if not touching a PV leaf
-				for (i=0 ; i < ent->num_leafs ; i++)
-					if (pvs[ent->leafnums[i] >> 3] & (1 << (ent->leafnums[i]&7) ))
-						break;
-					
-				if (i == ent->num_leafs)
-					continue;		// not visible
 			}
 		}
 
-		// don't send if flagged for NODRAW and there are no effects
+		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_strings[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);
+		if (DotProduct(ent->v.velocity, ent->v.velocity) >= 1.0f)
+		{
+			VectorMA(ent->v.origin, host_client->latency, ent->v.velocity, origin);
+			// LordHavoc: trace predicted movement to avoid putting things in walls
+			trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, origin, MOVE_NORMAL, ent);
+			VectorCopy(trace.endpos, origin);
+		}
+		else
+		{
+			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);
+				}
+			}
+
+			// if not touching a visible leaf
+			if (sv_pvscheckentities.integer && !SV_BoxTouchingPVS(pvs, entmins, entmaxs, sv.worldmodel->nodes))
+				continue;
+
+			// or not visible through the portals
+			if (sv_vischeckentities.integer && !Portal_CheckBox(sv.worldmodel, org, entmins, entmaxs))
+			{
+				sv_vischeckentitycullcount++;
+				continue;
+			}
+		}
+
 		alpha = 255;
 		scale = 16;
-		glowsize = 0;
 		glowcolor = 254;
-		colormod = 255;
 		effects = ent->v.effects;
 
 		if ((val = GETEDICTFIELDVALUE(ent, eval_alpha)))
-		if ((alpha = (int) (val->_float * 255.0)) == 0)
-			alpha = 255;
-		if ((val = GETEDICTFIELDVALUE(ent, eval_renderamt)) && val->_float != 0) // HalfLife support
+		if (val->_float != 0)
+			alpha = (int) (val->_float * 255.0);
+
+		// HalfLife support
+		if ((val = GETEDICTFIELDVALUE(ent, eval_renderamt)))
+		if (val->_float != 0)
 			alpha = (int) val->_float;
-		if (alpha < 0) alpha = 0;
-		if (alpha > 255) alpha = 255;
 
-		if ((val = GETEDICTFIELDVALUE(ent, eval_glow_size)))
-			glowsize = (int) val->_float >> 2;
-		if (glowsize > 255) glowsize = 255;
-		if (glowsize < 0) glowsize = 0;
+		if (alpha == 0)
+			alpha = 255;
+		alpha = bound(0, alpha, 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_trail)))
-		if (val->_float != 0)
-			bits |= U_GLOWTRAIL;
-
 		if ((val = GETEDICTFIELDVALUE(ent, eval_glow_color)))
 		if (val->_float != 0)
 			glowcolor = (int) val->_float;
@@ -513,22 +665,14 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 		if (val->_float != 0)
 			effects |= EF_FULLBRIGHT;
 
-		if ((val = GETEDICTFIELDVALUE(ent, eval_colormod)))
-		if (val->vector[0] != 0 || val->vector[1] != 0 || val->vector[2] != 0)
-		{
-			modred = val->vector[0] * 8.0;if (modred < 0) modred = 0;if (modred > 7) modred = 7;
-			modgreen = val->vector[1] * 8.0;if (modgreen < 0) modgreen = 0;if (modgreen > 7) modgreen = 7;
-			modblue = val->vector[2] * 4.0;if (modblue < 0) modblue = 0;if (modblue > 3) modblue = 3;
-			colormod = (modred << 5) | (modgreen << 2) | modblue;
-		}
-
 		if (ent != clent)
 		{
-			if (glowsize == 0 && bits == 0) // no effects
+			if (glowsize == 0 && (bits & U_GLOWTRAIL) == 0) // no effects
 			{
-				if (ent->v.modelindex && pr_strings[ent->v.model]) // model
+				if (model) // model
 				{
-					if (sv.models[ (int)ent->v.modelindex ]->flags == 0 && (ent->v.effects == EF_NODRAW || scale <= 0 || alpha <= 0))
+					// 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
@@ -539,97 +683,56 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 		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;
 			return;
 		}
 
-// send an update
-		bits = 0;
+		if ((val = GETEDICTFIELDVALUE(ent, eval_exteriormodeltoclient)) && val->edict == clentnum)
+			bits = bits | U_EXTERIORMODEL;
 
-		dodelta = false;
-		if ((int)ent->v.effects & EF_DELTA)
-			dodelta = sv.time < client->nextfullupdate[e]; // every half second a full update is forced
+// send an update
+		baseline = &ent->baseline;
 
-		if (dodelta)
+		if (((int)ent->v.effects & EF_DELTA) && sv_deltacompress.integer)
 		{
-			bits |= U_DELTA;
-			baseline = &ent->deltabaseline;
+			// every half second a full update is forced
+			if (realtime < client->nextfullupdate[e])
+			{
+				bits |= U_DELTA;
+				baseline = &ent->deltabaseline;
+			}
+			else
+				nextfullupdate = realtime + 0.5f;
 		}
 		else
-		{
-			client->nextfullupdate[e] = sv.time + 0.5;
-			baseline = &ent->baseline;
-		}
+			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;
-		
-		if (ent->v.movetype == MOVETYPE_STEP && ((int) ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) // monsters have smoothed walking/flying/swimming movement
-		{
-			if (!ent->steplerptime || ent->steplerptime > sv.time) // when the level just started...
-			{
-				ent->steplerptime = sv.time;
-				VectorCopy(ent->v.origin, ent->stepoldorigin);
-				VectorCopy(ent->v.angles, ent->stepoldangles);
-				VectorCopy(ent->v.origin, ent->steporigin);
-				VectorCopy(ent->v.angles, ent->stepangles);
-			}
-			VectorSubtract(ent->v.origin, ent->steporigin, origin);
-			VectorSubtract(ent->v.angles, ent->stepangles, angles);
-			if (DotProduct(origin, origin) >= 0.125 || DotProduct(angles, angles) >= 1.4)
-			{
-				// update lerp positions
-				ent->steplerptime = sv.time;
-				VectorCopy(ent->steporigin, ent->stepoldorigin);
-				VectorCopy(ent->stepangles, ent->stepoldangles);
-				VectorCopy(ent->v.origin, ent->steporigin);
-				VectorCopy(ent->v.angles, ent->stepangles);
-			}
-			movelerp = (sv.time - ent->steplerptime) * 10.0;
-			if (movelerp > 1) movelerp = 1;
-			moveilerp = 1 - movelerp;
-			origin[0] = ent->stepoldorigin[0] * moveilerp + ent->steporigin[0] * movelerp;
-			origin[1] = ent->stepoldorigin[1] * moveilerp + ent->steporigin[1] * movelerp;
-			origin[2] = ent->stepoldorigin[2] * moveilerp + ent->steporigin[2] * movelerp;
-			// choose shortest rotate (to avoid 'spin around' situations)
-			VectorSubtract(ent->stepangles, ent->stepoldangles, angles);
-			if (angles[0] < -180) angles[0] += 360;if (angles[0] >= 180) angles[0] -= 360;
-			if (angles[1] < -180) angles[1] += 360;if (angles[1] >= 180) angles[1] -= 360;
-			if (angles[2] < -180) angles[2] += 360;if (angles[2] >= 180) angles[2] -= 360;
-			angles[0] = angles[0] * movelerp + ent->stepoldangles[0];
-			angles[1] = angles[1] * movelerp + ent->stepoldangles[1];
-			angles[2] = angles[2] * movelerp + ent->stepoldangles[2];
-			VectorMA(origin, host_client->latency, ent->v.velocity, origin);
-		}
-		else // copy as they are
-		{
-//			VectorCopy(ent->v.origin, origin);
-			VectorCopy(ent->v.angles, angles);
-			VectorMA(ent->v.origin, host_client->latency, ent->v.velocity, origin);
-			if (ent->v.movetype == MOVETYPE_STEP) // monster, but airborn, update lerp info
-			{
-				// update lerp positions
-				ent->steplerptime = sv.time;
-				VectorCopy(ent->v.origin, ent->stepoldorigin);
-				VectorCopy(ent->v.angles, ent->stepoldangles);
-				VectorCopy(ent->v.origin, ent->steporigin);
-				VectorCopy(ent->v.angles, ent->stepangles);
-			}
-		}
 
 		// LordHavoc: old stuff, but rewritten to have more exact tolerances
-		if ((int)(origin[0]*8.0) != (int)(baseline->origin[0]*8.0))						bits |= U_ORIGIN1;
-		if ((int)(origin[1]*8.0) != (int)(baseline->origin[1]*8.0))						bits |= U_ORIGIN2;
-		if ((int)(origin[2]*8.0) != (int)(baseline->origin[2]*8.0))						bits |= U_ORIGIN3;
-		if ((int)(angles[0]*(256.0/360.0)) != (int)(baseline->angles[0]*(256.0/360.0)))	bits |= U_ANGLE1;
-		if ((int)(angles[1]*(256.0/360.0)) != (int)(baseline->angles[1]*(256.0/360.0)))	bits |= U_ANGLE2;
-		if ((int)(angles[2]*(256.0/360.0)) != (int)(baseline->angles[2]*(256.0/360.0)))	bits |= U_ANGLE3;
-		if (baseline->colormap != (int) ent->v.colormap)								bits |= U_COLORMAP;
-		if (baseline->skin != (int) ent->v.skin)										bits |= U_SKIN;
+//		if ((int)(origin[0]*8.0) != (int)(baseline->origin[0]*8.0))						bits |= U_ORIGIN1;
+//		if ((int)(origin[1]*8.0) != (int)(baseline->origin[1]*8.0))						bits |= U_ORIGIN2;
+//		if ((int)(origin[2]*8.0) != (int)(baseline->origin[2]*8.0))						bits |= U_ORIGIN3;
+		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 != (byte) ent->v.colormap)								bits |= U_COLORMAP;
+		if (baseline->skin != (byte) 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 != (int) ent->v.modelindex)							bits |= U_MODEL;
+		if ((baseline->modelindex & 0x00FF) != ((int) ent->v.modelindex & 0x00FF))		bits |= U_MODEL;
 
 		// LordHavoc: new stuff
 		if (baseline->alpha != alpha)													bits |= U_ALPHA;
@@ -637,8 +740,8 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 		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 (baseline->colormod != colormod)												bits |= U_COLORMOD;
 		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->deltabaseline.origin);
@@ -652,7 +755,6 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 		ent->deltabaseline.scale = scale;
 		ent->deltabaseline.glowsize = glowsize;
 		ent->deltabaseline.glowcolor = glowcolor;
-		ent->deltabaseline.colormod = colormod;
 
 		// write the message
 		if (bits >= 16777216)
@@ -695,9 +797,13 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 		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_COLORMOD)	MSG_WriteByte(msg, colormod);
 		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_reportvischeckentities.integer)
+		Con_Printf("sv_vischeck culled entities: %d\n", sv_vischeckentitycullcount);
+	sv_vischeckentitycullcount = 0;
 }
 
 /*
@@ -710,13 +816,10 @@ void SV_CleanupEnts (void)
 {
 	int		e;
 	edict_t	*ent;
-	
+
 	ent = NEXT_EDICT(sv.edicts);
 	for (e=1 ; e<sv.num_edicts ; e++, ent = NEXT_EDICT(ent))
-	{
 		ent->v.effects = (int)ent->v.effects & ~EF_MUZZLEFLASH;
-	}
-
 }
 
 /*
@@ -732,6 +835,7 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 	edict_t	*other;
 	int		items;
 	eval_t	*val;
+	vec3_t	punchvector;
 
 //
 // send a damage message
@@ -744,7 +848,7 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 		MSG_WriteByte (msg, ent->v.dmg_take);
 		for (i=0 ; i<3 ; i++)
 			MSG_WriteFloatCoord (msg, other->v.origin[i] + 0.5*(other->v.mins[i] + other->v.maxs[i]));
-	
+
 		ent->v.dmg_take = 0;
 		ent->v.dmg_save = 0;
 	}
@@ -764,10 +868,10 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 	}
 
 	bits = 0;
-	
+
 	if (ent->v.view_ofs[2] != DEFAULT_VIEWHEIGHT)
 		bits |= SU_VIEWHEIGHT;
-		
+
 	if (ent->v.idealpitch)
 		bits |= SU_IDEALPITCH;
 
@@ -781,21 +885,28 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 		items = (int)ent->v.items | ((int)pr_global_struct->serverflags << 28);
 
 	bits |= SU_ITEMS;
-	
+
 	if ( (int)ent->v.flags & FL_ONGROUND)
 		bits |= SU_ONGROUND;
-	
+
 	if ( ent->v.waterlevel >= 2)
 		bits |= SU_INWATER;
-	
+
+	// dpprotocol
+	VectorClear(punchvector);
+	if ((val = GETEDICTFIELDVALUE(ent, eval_punchvector)))
+		VectorCopy(val->vector, punchvector);
+
 	for (i=0 ; i<3 ; i++)
 	{
 		if (ent->v.punchangle[i])
 			bits |= (SU_PUNCH1<<i);
+		if (punchvector[i]) // dpprotocol
+			bits |= (SU_PUNCHVEC1<<i); // dpprotocol
 		if (ent->v.velocity[i])
 			bits |= (SU_VELOCITY1<<i);
 	}
-	
+
 	if (ent->v.weaponframe)
 		bits |= SU_WEAPONFRAME;
 
@@ -805,10 +916,19 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 //	if (ent->v.weapon)
 		bits |= SU_WEAPON;
 
+	if (bits >= 65536)
+		bits |= SU_EXTEND1;
+	if (bits >= 16777216)
+		bits |= SU_EXTEND2;
+
 // send the data
 
 	MSG_WriteByte (msg, svc_clientdata);
 	MSG_WriteShort (msg, bits);
+	if (bits & SU_EXTEND1)
+		MSG_WriteByte(msg, bits >> 16);
+	if (bits & SU_EXTEND2)
+		MSG_WriteByte(msg, bits >> 24);
 
 	if (bits & SU_VIEWHEIGHT)
 		MSG_WriteChar (msg, ent->v.view_ofs[2]);
@@ -819,7 +939,9 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 	for (i=0 ; i<3 ; i++)
 	{
 		if (bits & (SU_PUNCH1<<i))
-			MSG_WriteChar (msg, ent->v.punchangle[i]);
+			MSG_WritePreciseAngle(msg, ent->v.punchangle[i]); // dpprotocol
+		if (bits & (SU_PUNCHVEC1<<i)) // dpprotocol
+			MSG_WriteFloatCoord(msg, punchvector[i]); // dpprotocol
 		if (bits & (SU_VELOCITY1<<i))
 			MSG_WriteChar (msg, ent->v.velocity[i]/16);
 	}
@@ -833,7 +955,7 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 		MSG_WriteByte (msg, ent->v.armorvalue);
 	if (bits & SU_WEAPON)
 		MSG_WriteByte (msg, SV_ModelIndex(pr_strings+ent->v.weaponmodel));
-	
+
 	MSG_WriteShort (msg, ent->v.health);
 	MSG_WriteByte (msg, ent->v.currentammo);
 	MSG_WriteByte (msg, ent->v.ammo_shells);
@@ -841,11 +963,7 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 	MSG_WriteByte (msg, ent->v.ammo_rockets);
 	MSG_WriteByte (msg, ent->v.ammo_cells);
 
-	if (standard_quake)
-	{
-		MSG_WriteByte (msg, ent->v.weapon);
-	}
-	else
+	if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
 	{
 		for(i=0;i<32;i++)
 		{
@@ -856,6 +974,10 @@ void SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
 			}
 		}
 	}
+	else
+	{
+		MSG_WriteByte (msg, ent->v.weapon);
+	}
 }
 
 /*
@@ -867,7 +989,7 @@ qboolean SV_SendClientDatagram (client_t *client)
 {
 	byte		buf[MAX_DATAGRAM];
 	sizebuf_t	msg;
-	
+
 	msg.data = buf;
 	msg.maxsize = sizeof(buf);
 	msg.cursize = 0;
@@ -890,7 +1012,7 @@ qboolean SV_SendClientDatagram (client_t *client)
 		SV_DropClient (true);// if the message couldn't send, kick off
 		return false;
 	}
-	
+
 	return true;
 }
 
@@ -921,7 +1043,7 @@ void SV_UpdateToReliableMessages (void)
 			host_client->old_frags = host_client->edict->v.frags;
 		}
 	}
-	
+
 	for (j=0, client = svs.clients ; j<svs.maxclients ; j++, client++)
 	{
 		if (!client->active)
@@ -945,7 +1067,7 @@ void SV_SendNop (client_t *client)
 {
 	sizebuf_t	msg;
 	byte		buf[4];
-	
+
 	msg.data = buf;
 	msg.maxsize = sizeof(buf);
 	msg.cursize = 0;
@@ -965,7 +1087,7 @@ SV_SendClientMessages
 void SV_SendClientMessages (void)
 {
 	int			i;
-	
+
 // update frags, names, etc
 	SV_UpdateToReliableMessages ();
 
@@ -985,7 +1107,7 @@ void SV_SendClientMessages (void)
 		// the player isn't totally in the game yet
 		// send small keepalive messages if too much time has passed
 		// send a full message when the next signon stage has been requested
-		// some other message data (name changes, etc) may accumulate 
+		// some other message data (name changes, etc) may accumulate
 		// between signon stages
 			if (!host_client->sendsignon)
 			{
@@ -1004,7 +1126,7 @@ void SV_SendClientMessages (void)
 			host_client->message.overflowed = false;
 			continue;
 		}
-			
+
 		if (host_client->message.cursize || host_client->dropasap)
 		{
 			if (!NET_CanSendMessage (host_client->netconnection))
@@ -1025,8 +1147,8 @@ void SV_SendClientMessages (void)
 			}
 		}
 	}
-	
-	
+
+
 // clear muzzle flashes
 	SV_CleanupEnts ();
 }
@@ -1049,7 +1171,7 @@ SV_ModelIndex
 int SV_ModelIndex (char *name)
 {
 	int		i;
-	
+
 	if (!name || !name[0])
 		return 0;
 
@@ -1069,22 +1191,24 @@ SV_CreateBaseline
 */
 void SV_CreateBaseline (void)
 {
-	int			i;
-	edict_t			*svent;
-	int				entnum;	
-		
-	for (entnum = 0; entnum < sv.num_edicts ; entnum++)
+	int i, entnum, large;
+	edict_t *svent;
+
+	// LordHavoc: clear *all* states (note just active ones)
+	for (entnum = 0; entnum < MAX_EDICTS ; entnum++)
 	{
-	// get the current server version
+		// get the current server version
 		svent = EDICT_NUM(entnum);
+
+		// LordHavoc: always clear state values, whether the entity is in use or not
+		ClearStateToDefault(&svent->baseline);
+
 		if (svent->free)
 			continue;
 		if (entnum > svs.maxclients && !svent->v.modelindex)
 			continue;
 
-	//
-	// create entity baseline
-	//
+		// create entity baseline
 		VectorCopy (svent->v.origin, svent->baseline.origin);
 		VectorCopy (svent->v.angles, svent->baseline.angles);
 		svent->baseline.frame = svent->v.frame;
@@ -1097,23 +1221,30 @@ void SV_CreateBaseline (void)
 		else
 		{
 			svent->baseline.colormap = 0;
-			svent->baseline.modelindex =
-				SV_ModelIndex(pr_strings + svent->v.model);
+			svent->baseline.modelindex = svent->v.modelindex; //SV_ModelIndex(pr_strings + svent->v.model);
 		}
-		svent->baseline.alpha = 255;
-		svent->baseline.scale = 16;
-		svent->baseline.glowsize = 0;
-		svent->baseline.glowcolor = 254;
-		svent->baseline.colormod = 255;
-		
-	//
-	// add to the message
-	//
-		MSG_WriteByte (&sv.signon,svc_spawnbaseline);		
-		MSG_WriteShort (&sv.signon,entnum);
 
-		MSG_WriteByte (&sv.signon, svent->baseline.modelindex);
-		MSG_WriteByte (&sv.signon, svent->baseline.frame);
+		large = false;
+		if (svent->baseline.modelindex & 0xFF00 || svent->baseline.frame & 0xFF00)
+			large = true;
+
+		// add to the message
+		if (large)
+			MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
+		else
+			MSG_WriteByte (&sv.signon, svc_spawnbaseline);
+		MSG_WriteShort (&sv.signon, entnum);
+
+		if (large)
+		{
+			MSG_WriteShort (&sv.signon, svent->baseline.modelindex);
+			MSG_WriteShort (&sv.signon, svent->baseline.frame);
+		}
+		else
+		{
+			MSG_WriteByte (&sv.signon, svent->baseline.modelindex);
+			MSG_WriteByte (&sv.signon, svent->baseline.frame);
+		}
 		MSG_WriteByte (&sv.signon, svent->baseline.colormap);
 		MSG_WriteByte (&sv.signon, svent->baseline.skin);
 		for (i=0 ; i<3 ; i++)
@@ -1177,8 +1308,6 @@ void SV_SaveSpawnparms (void)
 	}
 }
 
-qboolean isworldmodel;
-
 /*
 ================
 SV_SpawnServer
@@ -1205,23 +1334,17 @@ void SV_SpawnServer (char *server)
 // tell all connected clients that we are going to a new level
 //
 	if (sv.active)
-	{
 		SV_SendReconnect ();
-	}
 
 //
 // make cvars consistant
 //
-	if (coop.value)
+	if (coop.integer)
 		Cvar_SetValue ("deathmatch", 0);
-	current_skill = (int)(skill.value + 0.5);
-	if (current_skill < 0)
-		current_skill = 0;
-	if (current_skill > 3)
-		current_skill = 3;
+	current_skill = bound(0, (int)(skill.value + 0.5), 3);
 
 	Cvar_SetValue ("skill", (float)current_skill);
-	
+
 //
 // set up the new server
 //
@@ -1236,21 +1359,23 @@ void SV_SpawnServer (char *server)
 
 // allocate server memory
 	sv.max_edicts = MAX_EDICTS;
-	
-	sv.edicts = Hunk_AllocName (sv.max_edicts*pr_edict_size, "edicts");
+
+	// clear the edict memory pool
+	Mem_EmptyPool(sv_edicts_mempool);
+	sv.edicts = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * pr_edict_size);
 
 	sv.datagram.maxsize = sizeof(sv.datagram_buf);
 	sv.datagram.cursize = 0;
 	sv.datagram.data = sv.datagram_buf;
-	
+
 	sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
 	sv.reliable_datagram.cursize = 0;
 	sv.reliable_datagram.data = sv.reliable_datagram_buf;
-	
+
 	sv.signon.maxsize = sizeof(sv.signon_buf);
 	sv.signon.cursize = 0;
 	sv.signon.data = sv.signon_buf;
-	
+
 // leave slots at start for clients only
 	sv.num_edicts = svs.maxclients+1;
 	for (i=0 ; i<svs.maxclients ; i++)
@@ -1258,17 +1383,17 @@ void SV_SpawnServer (char *server)
 		ent = EDICT_NUM(i+1);
 		svs.clients[i].edict = ent;
 	}
-	
+
 	sv.state = ss_loading;
 	sv.paused = false;
 
 	sv.time = 1.0;
-	
+
+	Mod_ClearUsed();
+
 	strcpy (sv.name, server);
 	sprintf (sv.modelname,"maps/%s.bsp", server);
-	isworldmodel = true; // LordHavoc: only load submodels on the world model
-	sv.worldmodel = Mod_ForName (sv.modelname, false);
-	isworldmodel = false;
+	sv.worldmodel = Mod_ForName(sv.modelname, false, true, true);
 	if (!sv.worldmodel)
 	{
 		Con_Printf ("Couldn't spawn server %s\n", sv.modelname);
@@ -1276,25 +1401,25 @@ void SV_SpawnServer (char *server)
 		return;
 	}
 	sv.models[1] = sv.worldmodel;
-	
+
 //
 // clear world interaction links
 //
 	SV_ClearWorld ();
-	
+
 	sv.sound_precache[0] = pr_strings;
 
 	sv.model_precache[0] = pr_strings;
 	sv.model_precache[1] = sv.modelname;
-	for (i=1 ; i<sv.worldmodel->numsubmodels ; i++)
+	for (i = 1;i < sv.worldmodel->numsubmodels;i++)
 	{
-		sv.model_precache[1+i] = localmodels[i];
-		sv.models[i+1] = Mod_ForName (localmodels[i], false);
+		sv.model_precache[i+1] = localmodels[i];
+		sv.models[i+1] = Mod_ForName (localmodels[i], false, true, false);
 	}
 
 //
 // load the rest of the entities
-//	
+//
 	ent = EDICT_NUM(0);
 	memset (&ent->v, 0, progs->entityfields * 4);
 	ent->free = false;
@@ -1302,12 +1427,11 @@ void SV_SpawnServer (char *server)
 	ent->v.modelindex = 1;		// world model
 	ent->v.solid = SOLID_BSP;
 	ent->v.movetype = MOVETYPE_PUSH;
-	ent->v.angles[0] = ent->v.angles[1] = ent->v.angles[2] = 0;
 
-	if (coop.value)
-		pr_global_struct->coop = coop.value;
+	if (coop.integer)
+		pr_global_struct->coop = coop.integer;
 	else
-		pr_global_struct->deathmatch = deathmatch.value;
+		pr_global_struct->deathmatch = deathmatch.integer;
 
 	pr_global_struct->mapname = sv.name - pr_strings;
 
@@ -1316,18 +1440,20 @@ void SV_SpawnServer (char *server)
 	
 	ED_LoadFromFile (sv.worldmodel->entities);
 	// LordHavoc: clear world angles (to fix e3m3.bsp)
-	sv.edicts->v.angles[0] = sv.edicts->v.angles[1] = sv.edicts->v.angles[2] = 0;
+	VectorClear(sv.edicts->v.angles);
 
 	sv.active = true;
 
 // all setup is completed, any further precache statements are errors
 	sv.state = ss_active;
-	
+
 // run two frames to allow everything to settle
-	host_frametime = 0.1;
+	sv.frametime = pr_global_struct->frametime = host_frametime = 0.1;
 	SV_Physics ();
 	SV_Physics ();
 
+	Mod_PurgeUnused();
+
 // create a baseline for more efficient communications
 	SV_CreateBaseline ();
 
@@ -1335,6 +1461,6 @@ void SV_SpawnServer (char *server)
 	for (i=0,host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
 		if (host_client->active)
 			SV_SendServerinfo (host_client);
-	
+
 	Con_DPrintf ("Server spawned.\n");
 }