The Quake sources as originally release under the GPL license on December 21, 1999

1 files changed, 1083 insertions, 0 deletions

diff --git a/QW/client/cl_ents.c b/QW/client/cl_ents.c
new file mode 100644
index 0000000..80d28c4
--- /dev/null
+++ b/QW/client/cl_ents.c
@@ -0,0 +1,1083 @@
+/*
+Copyright (C) 1996-1997 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+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.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+// cl_ents.c -- entity parsing and management
+
+#include "quakedef.h"
+
+extern	cvar_t	cl_predict_players;
+extern	cvar_t	cl_predict_players2;
+extern	cvar_t	cl_solid_players;
+
+static struct predicted_player {
+	int flags;
+	qboolean active;
+	vec3_t origin;	// predicted origin
+} predicted_players[MAX_CLIENTS];
+
+//============================================================
+
+/*
+===============
+CL_AllocDlight
+
+===============
+*/
+dlight_t *CL_AllocDlight (int key)
+{
+	int		i;
+	dlight_t	*dl;
+
+// first look for an exact key match
+	if (key)
+	{
+		dl = cl_dlights;
+		for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
+		{
+			if (dl->key == key)
+			{
+				memset (dl, 0, sizeof(*dl));
+				dl->key = key;
+				return dl;
+			}
+		}
+	}
+
+// then look for anything else
+	dl = cl_dlights;
+	for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
+	{
+		if (dl->die < cl.time)
+		{
+			memset (dl, 0, sizeof(*dl));
+			dl->key = key;
+			return dl;
+		}
+	}
+
+	dl = &cl_dlights[0];
+	memset (dl, 0, sizeof(*dl));
+	dl->key = key;
+	return dl;
+}
+
+/*
+===============
+CL_NewDlight
+===============
+*/
+void CL_NewDlight (int key, float x, float y, float z, float radius, float time,
+				   int type)
+{
+	dlight_t	*dl;
+
+	dl = CL_AllocDlight (key);
+	dl->origin[0] = x;
+	dl->origin[1] = y;
+	dl->origin[2] = z;
+	dl->radius = radius;
+	dl->die = cl.time + time;
+	if (type == 0) {
+		dl->color[0] = 0.2;
+		dl->color[1] = 0.1;
+		dl->color[2] = 0.05;
+		dl->color[3] = 0.7;
+	} else if (type == 1) {
+		dl->color[0] = 0.05;
+		dl->color[1] = 0.05;
+		dl->color[2] = 0.3;
+		dl->color[3] = 0.7;
+	} else if (type == 2) {
+		dl->color[0] = 0.5;
+		dl->color[1] = 0.05;
+		dl->color[2] = 0.05;
+		dl->color[3] = 0.7;
+	} else if (type == 3) {
+		dl->color[0]=0.5;
+		dl->color[1] = 0.05;
+		dl->color[2] = 0.4;
+		dl->color[3] = 0.7;
+	}
+}
+
+
+/*
+===============
+CL_DecayLights
+
+===============
+*/
+void CL_DecayLights (void)
+{
+	int			i;
+	dlight_t	*dl;
+
+	dl = cl_dlights;
+	for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
+	{
+		if (dl->die < cl.time || !dl->radius)
+			continue;
+		
+		dl->radius -= host_frametime*dl->decay;
+		if (dl->radius < 0)
+			dl->radius = 0;
+	}
+}
+
+
+/*
+=========================================================================
+
+PACKET ENTITY PARSING / LINKING
+
+=========================================================================
+*/
+
+/*
+==================
+CL_ParseDelta
+
+Can go from either a baseline or a previous packet_entity
+==================
+*/
+int	bitcounts[32];	/// just for protocol profiling
+void CL_ParseDelta (entity_state_t *from, entity_state_t *to, int bits)
+{
+	int			i;
+
+	// set everything to the state we are delta'ing from
+	*to = *from;
+
+	to->number = bits & 511;
+	bits &= ~511;
+
+	if (bits & U_MOREBITS)
+	{	// read in the low order bits
+		i = MSG_ReadByte ();
+		bits |= i;
+	}
+
+	// count the bits for net profiling
+	for (i=0 ; i<16 ; i++)
+		if (bits&(1<<i))
+			bitcounts[i]++;
+
+	to->flags = bits;
+	
+	if (bits & U_MODEL)
+		to->modelindex = MSG_ReadByte ();
+		
+	if (bits & U_FRAME)
+		to->frame = MSG_ReadByte ();
+
+	if (bits & U_COLORMAP)
+		to->colormap = MSG_ReadByte();
+
+	if (bits & U_SKIN)
+		to->skinnum = MSG_ReadByte();
+
+	if (bits & U_EFFECTS)
+		to->effects = MSG_ReadByte();
+
+	if (bits & U_ORIGIN1)
+		to->origin[0] = MSG_ReadCoord ();
+		
+	if (bits & U_ANGLE1)
+		to->angles[0] = MSG_ReadAngle();
+
+	if (bits & U_ORIGIN2)
+		to->origin[1] = MSG_ReadCoord ();
+		
+	if (bits & U_ANGLE2)
+		to->angles[1] = MSG_ReadAngle();
+
+	if (bits & U_ORIGIN3)
+		to->origin[2] = MSG_ReadCoord ();
+		
+	if (bits & U_ANGLE3)
+		to->angles[2] = MSG_ReadAngle();
+
+	if (bits & U_SOLID)
+	{
+		// FIXME
+	}
+}
+
+
+/*
+=================
+FlushEntityPacket
+=================
+*/
+void FlushEntityPacket (void)
+{
+	int			word;
+	entity_state_t	olde, newe;
+
+	Con_DPrintf ("FlushEntityPacket\n");
+
+	memset (&olde, 0, sizeof(olde));
+
+	cl.validsequence = 0;		// can't render a frame
+	cl.frames[cls.netchan.incoming_sequence&UPDATE_MASK].invalid = true;
+
+	// read it all, but ignore it
+	while (1)
+	{
+		word = (unsigned short)MSG_ReadShort ();
+		if (msg_badread)
+		{	// something didn't parse right...
+			Host_EndGame ("msg_badread in packetentities");
+			return;
+		}
+
+		if (!word)
+			break;	// done
+
+		CL_ParseDelta (&olde, &newe, word);
+	}
+}
+
+/*
+==================
+CL_ParsePacketEntities
+
+An svc_packetentities has just been parsed, deal with the
+rest of the data stream.
+==================
+*/
+void CL_ParsePacketEntities (qboolean delta)
+{
+	int			oldpacket, newpacket;
+	packet_entities_t	*oldp, *newp, dummy;
+	int			oldindex, newindex;
+	int			word, newnum, oldnum;
+	qboolean	full;
+	byte		from;
+
+	newpacket = cls.netchan.incoming_sequence&UPDATE_MASK;
+	newp = &cl.frames[newpacket].packet_entities;
+	cl.frames[newpacket].invalid = false;
+
+	if (delta)
+	{
+		from = MSG_ReadByte ();
+
+		oldpacket = cl.frames[newpacket].delta_sequence;
+
+		if ( (from&UPDATE_MASK) != (oldpacket&UPDATE_MASK) )
+			Con_DPrintf ("WARNING: from mismatch\n");
+	}
+	else
+		oldpacket = -1;
+
+	full = false;
+	if (oldpacket != -1)
+	{
+		if (cls.netchan.outgoing_sequence - oldpacket >= UPDATE_BACKUP-1)
+		{	// we can't use this, it is too old
+			FlushEntityPacket ();
+			return;
+		}
+		cl.validsequence = cls.netchan.incoming_sequence;
+		oldp = &cl.frames[oldpacket&UPDATE_MASK].packet_entities;
+	}
+	else
+	{	// this is a full update that we can start delta compressing from now
+		oldp = &dummy;
+		dummy.num_entities = 0;
+		cl.validsequence = cls.netchan.incoming_sequence;
+		full = true;
+	}
+
+	oldindex = 0;
+	newindex = 0;
+	newp->num_entities = 0;
+
+	while (1)
+	{
+		word = (unsigned short)MSG_ReadShort ();
+		if (msg_badread)
+		{	// something didn't parse right...
+			Host_EndGame ("msg_badread in packetentities");
+			return;
+		}
+
+		if (!word)
+		{
+			while (oldindex < oldp->num_entities)
+			{	// copy all the rest of the entities from the old packet
+//Con_Printf ("copy %i\n", oldp->entities[oldindex].number);
+				if (newindex >= MAX_PACKET_ENTITIES)
+					Host_EndGame ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");
+				newp->entities[newindex] = oldp->entities[oldindex];
+				newindex++;
+				oldindex++;
+			}
+			break;
+		}
+		newnum = word&511;
+		oldnum = oldindex >= oldp->num_entities ? 9999 : oldp->entities[oldindex].number;
+
+		while (newnum > oldnum)
+		{
+			if (full)
+			{
+				Con_Printf ("WARNING: oldcopy on full update");
+				FlushEntityPacket ();
+				return;
+			}
+
+//Con_Printf ("copy %i\n", oldnum);
+			// copy one of the old entities over to the new packet unchanged
+			if (newindex >= MAX_PACKET_ENTITIES)
+				Host_EndGame ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");
+			newp->entities[newindex] = oldp->entities[oldindex];
+			newindex++;
+			oldindex++;
+			oldnum = oldindex >= oldp->num_entities ? 9999 : oldp->entities[oldindex].number;
+		}
+
+		if (newnum < oldnum)
+		{	// new from baseline
+//Con_Printf ("baseline %i\n", newnum);
+			if (word & U_REMOVE)
+			{
+				if (full)
+				{
+					cl.validsequence = 0;
+					Con_Printf ("WARNING: U_REMOVE on full update\n");
+					FlushEntityPacket ();
+					return;
+				}
+				continue;
+			}
+			if (newindex >= MAX_PACKET_ENTITIES)
+				Host_EndGame ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");
+			CL_ParseDelta (&cl_baselines[newnum], &newp->entities[newindex], word);
+			newindex++;
+			continue;
+		}
+
+		if (newnum == oldnum)
+		{	// delta from previous
+			if (full)
+			{
+				cl.validsequence = 0;
+				Con_Printf ("WARNING: delta on full update");
+			}
+			if (word & U_REMOVE)
+			{
+				oldindex++;
+				continue;
+			}
+//Con_Printf ("delta %i\n",newnum);
+			CL_ParseDelta (&oldp->entities[oldindex], &newp->entities[newindex], word);
+			newindex++;
+			oldindex++;
+		}
+
+	}
+
+	newp->num_entities = newindex;
+}
+
+
+/*
+===============
+CL_LinkPacketEntities
+
+===============
+*/
+void CL_LinkPacketEntities (void)
+{
+	entity_t			*ent;
+	packet_entities_t	*pack;
+	entity_state_t		*s1, *s2;
+	float				f;
+	model_t				*model;
+	vec3_t				old_origin;
+	float				autorotate;
+	int					i;
+	int					pnum;
+	dlight_t			*dl;
+
+	pack = &cl.frames[cls.netchan.incoming_sequence&UPDATE_MASK].packet_entities;
+
+	autorotate = anglemod(100*cl.time);
+
+	f = 0;		// FIXME: no interpolation right now
+
+	for (pnum=0 ; pnum<pack->num_entities ; pnum++)
+	{
+		s1 = &pack->entities[pnum];
+		s2 = s1;	// FIXME: no interpolation right now
+
+		// spawn light flashes, even ones coming from invisible objects
+		if ((s1->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED))
+			CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 3);
+		else if (s1->effects & EF_BLUE)
+			CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 1);
+		else if (s1->effects & EF_RED)
+			CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 2);
+		else if (s1->effects & EF_BRIGHTLIGHT)
+			CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2] + 16, 400 + (rand()&31), 0.1, 0);
+		else if (s1->effects & EF_DIMLIGHT)
+			CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 0);
+
+		// if set to invisible, skip
+		if (!s1->modelindex)
+			continue;
+
+		// create a new entity
+		if (cl_numvisedicts == MAX_VISEDICTS)
+			break;		// object list is full
+
+		ent = &cl_visedicts[cl_numvisedicts];
+		cl_numvisedicts++;
+
+		ent->keynum = s1->number;
+		ent->model = model = cl.model_precache[s1->modelindex];
+	
+		// set colormap
+		if (s1->colormap && (s1->colormap < MAX_CLIENTS) 
+			&& !strcmp(ent->model->name,"progs/player.mdl") )
+		{
+			ent->colormap = cl.players[s1->colormap-1].translations;
+			ent->scoreboard = &cl.players[s1->colormap-1];
+		}
+		else
+		{
+			ent->colormap = vid.colormap;
+			ent->scoreboard = NULL;
+		}
+
+		// set skin
+		ent->skinnum = s1->skinnum;
+		
+		// set frame
+		ent->frame = s1->frame;
+
+		// rotate binary objects locally
+		if (model->flags & EF_ROTATE)
+		{
+			ent->angles[0] = 0;
+			ent->angles[1] = autorotate;
+			ent->angles[2] = 0;
+		}
+		else
+		{
+			float	a1, a2;
+
+			for (i=0 ; i<3 ; i++)
+			{
+				a1 = s1->angles[i];
+				a2 = s2->angles[i];
+				if (a1 - a2 > 180)
+					a1 -= 360;
+				if (a1 - a2 < -180)
+					a1 += 360;
+				ent->angles[i] = a2 + f * (a1 - a2);
+			}
+		}
+
+		// calculate origin
+		for (i=0 ; i<3 ; i++)
+			ent->origin[i] = s2->origin[i] + 
+			f * (s1->origin[i] - s2->origin[i]);
+
+		// add automatic particle trails
+		if (!model->flags)
+			continue;
+
+		// scan the old entity display list for a matching
+		for (i=0 ; i<cl_oldnumvisedicts ; i++)
+		{
+			if (cl_oldvisedicts[i].keynum == ent->keynum)
+			{
+				VectorCopy (cl_oldvisedicts[i].origin, old_origin);
+				break;
+			}
+		}
+		if (i == cl_oldnumvisedicts)
+			continue;		// not in last message
+
+		for (i=0 ; i<3 ; i++)
+			if ( abs(old_origin[i] - ent->origin[i]) > 128)
+			{	// no trail if too far
+				VectorCopy (ent->origin, old_origin);
+				break;
+			}
+		if (model->flags & EF_ROCKET)
+		{
+			R_RocketTrail (old_origin, ent->origin, 0);
+			dl = CL_AllocDlight (s1->number);
+			VectorCopy (ent->origin, dl->origin);
+			dl->radius = 200;
+			dl->die = cl.time + 0.1;
+		}
+		else if (model->flags & EF_GRENADE)
+			R_RocketTrail (old_origin, ent->origin, 1);
+		else if (model->flags & EF_GIB)
+			R_RocketTrail (old_origin, ent->origin, 2);
+		else if (model->flags & EF_ZOMGIB)
+			R_RocketTrail (old_origin, ent->origin, 4);
+		else if (model->flags & EF_TRACER)
+			R_RocketTrail (old_origin, ent->origin, 3);
+		else if (model->flags & EF_TRACER2)
+			R_RocketTrail (old_origin, ent->origin, 5);
+		else if (model->flags & EF_TRACER3)
+			R_RocketTrail (old_origin, ent->origin, 6);
+	}
+}
+
+
+/*
+=========================================================================
+
+PROJECTILE PARSING / LINKING
+
+=========================================================================
+*/
+
+typedef struct
+{
+	int		modelindex;
+	vec3_t	origin;
+	vec3_t	angles;
+} projectile_t;
+
+#define	MAX_PROJECTILES	32
+projectile_t	cl_projectiles[MAX_PROJECTILES];
+int				cl_num_projectiles;
+
+extern int cl_spikeindex;
+
+void CL_ClearProjectiles (void)
+{
+	cl_num_projectiles = 0;
+}
+
+/*
+=====================
+CL_ParseProjectiles
+
+Nails are passed as efficient temporary entities
+=====================
+*/
+void CL_ParseProjectiles (void)
+{
+	int		i, c, j;
+	byte	bits[6];
+	projectile_t	*pr;
+
+	c = MSG_ReadByte ();
+	for (i=0 ; i<c ; i++)
+	{
+		for (j=0 ; j<6 ; j++)
+			bits[j] = MSG_ReadByte ();
+
+		if (cl_num_projectiles == MAX_PROJECTILES)
+			continue;
+
+		pr = &cl_projectiles[cl_num_projectiles];
+		cl_num_projectiles++;
+
+		pr->modelindex = cl_spikeindex;
+		pr->origin[0] = ( ( bits[0] + ((bits[1]&15)<<8) ) <<1) - 4096;
+		pr->origin[1] = ( ( (bits[1]>>4) + (bits[2]<<4) ) <<1) - 4096;
+		pr->origin[2] = ( ( bits[3] + ((bits[4]&15)<<8) ) <<1) - 4096;
+		pr->angles[0] = 360*(bits[4]>>4)/16;
+		pr->angles[1] = 360*bits[5]/256;
+	}
+}
+
+/*
+=============
+CL_LinkProjectiles
+
+=============
+*/
+void CL_LinkProjectiles (void)
+{
+	int		i;
+	projectile_t	*pr;
+	entity_t		*ent;
+
+	for (i=0, pr=cl_projectiles ; i<cl_num_projectiles ; i++, pr++)
+	{
+		// grab an entity to fill in
+		if (cl_numvisedicts == MAX_VISEDICTS)
+			break;		// object list is full
+		ent = &cl_visedicts[cl_numvisedicts];
+		cl_numvisedicts++;
+		ent->keynum = 0;
+
+		if (pr->modelindex < 1)
+			continue;
+		ent->model = cl.model_precache[pr->modelindex];
+		ent->skinnum = 0;
+		ent->frame = 0;
+		ent->colormap = vid.colormap;
+		ent->scoreboard = NULL;
+		VectorCopy (pr->origin, ent->origin);
+		VectorCopy (pr->angles, ent->angles);
+	}
+}
+
+//========================================
+
+extern	int		cl_spikeindex, cl_playerindex, cl_flagindex;
+
+entity_t *CL_NewTempEntity (void);
+
+/*
+===================
+CL_ParsePlayerinfo
+===================
+*/
+extern int parsecountmod;
+extern double parsecounttime;
+void CL_ParsePlayerinfo (void)
+{
+	int			msec;
+	int			flags;
+	player_info_t	*info;
+	player_state_t	*state;
+	int			num;
+	int			i;
+
+	num = MSG_ReadByte ();
+	if (num > MAX_CLIENTS)
+		Sys_Error ("CL_ParsePlayerinfo: bad num");
+
+	info = &cl.players[num];
+
+	state = &cl.frames[parsecountmod].playerstate[num];
+
+	flags = state->flags = MSG_ReadShort ();
+
+	state->messagenum = cl.parsecount;
+	state->origin[0] = MSG_ReadCoord ();
+	state->origin[1] = MSG_ReadCoord ();
+	state->origin[2] = MSG_ReadCoord ();
+
+	state->frame = MSG_ReadByte ();
+
+	// the other player's last move was likely some time
+	// before the packet was sent out, so accurately track
+	// the exact time it was valid at
+	if (flags & PF_MSEC)
+	{
+		msec = MSG_ReadByte ();
+		state->state_time = parsecounttime - msec*0.001;
+	}
+	else
+		state->state_time = parsecounttime;
+
+	if (flags & PF_COMMAND)
+		MSG_ReadDeltaUsercmd (&nullcmd, &state->command);
+
+	for (i=0 ; i<3 ; i++)
+	{
+		if (flags & (PF_VELOCITY1<<i) )
+			state->velocity[i] = MSG_ReadShort();
+		else
+			state->velocity[i] = 0;
+	}
+	if (flags & PF_MODEL)
+		state->modelindex = MSG_ReadByte ();
+	else
+		state->modelindex = cl_playerindex;
+
+	if (flags & PF_SKINNUM)
+		state->skinnum = MSG_ReadByte ();
+	else
+		state->skinnum = 0;
+
+	if (flags & PF_EFFECTS)
+		state->effects = MSG_ReadByte ();
+	else
+		state->effects = 0;
+
+	if (flags & PF_WEAPONFRAME)
+		state->weaponframe = MSG_ReadByte ();
+	else
+		state->weaponframe = 0;
+
+	VectorCopy (state->command.angles, state->viewangles);
+}
+
+
+/*
+================
+CL_AddFlagModels
+
+Called when the CTF flags are set
+================
+*/
+void CL_AddFlagModels (entity_t *ent, int team)
+{
+	int		i;
+	float	f;
+	vec3_t	v_forward, v_right, v_up;
+	entity_t	*newent;
+
+	if (cl_flagindex == -1)
+		return;
+
+	f = 14;
+	if (ent->frame >= 29 && ent->frame <= 40) {
+		if (ent->frame >= 29 && ent->frame <= 34) { //axpain
+			if      (ent->frame == 29) f = f + 2; 
+			else if (ent->frame == 30) f = f + 8;
+			else if (ent->frame == 31) f = f + 12;
+			else if (ent->frame == 32) f = f + 11;
+			else if (ent->frame == 33) f = f + 10;
+			else if (ent->frame == 34) f = f + 4;
+		} else if (ent->frame >= 35 && ent->frame <= 40) { // pain
+			if      (ent->frame == 35) f = f + 2; 
+			else if (ent->frame == 36) f = f + 10;
+			else if (ent->frame == 37) f = f + 10;
+			else if (ent->frame == 38) f = f + 8;
+			else if (ent->frame == 39) f = f + 4;
+			else if (ent->frame == 40) f = f + 2;
+		}
+	} else if (ent->frame >= 103 && ent->frame <= 118) {
+		if      (ent->frame >= 103 && ent->frame <= 104) f = f + 6;  //nailattack
+		else if (ent->frame >= 105 && ent->frame <= 106) f = f + 6;  //light 
+		else if (ent->frame >= 107 && ent->frame <= 112) f = f + 7;  //rocketattack
+		else if (ent->frame >= 112 && ent->frame <= 118) f = f + 7;  //shotattack
+	}
+
+	newent = CL_NewTempEntity ();
+	newent->model = cl.model_precache[cl_flagindex];
+	newent->skinnum = team;
+
+	AngleVectors (ent->angles, v_forward, v_right, v_up);
+	v_forward[2] = -v_forward[2]; // reverse z component
+	for (i=0 ; i<3 ; i++)
+		newent->origin[i] = ent->origin[i] - f*v_forward[i] + 22*v_right[i];
+	newent->origin[2] -= 16;
+
+	VectorCopy (ent->angles, newent->angles)
+	newent->angles[2] -= 45;
+}
+
+/*
+=============
+CL_LinkPlayers
+
+Create visible entities in the correct position
+for all current players
+=============
+*/
+void CL_LinkPlayers (void)
+{
+	int				j;
+	player_info_t	*info;
+	player_state_t	*state;
+	player_state_t	exact;
+	double			playertime;
+	entity_t		*ent;
+	int				msec;
+	frame_t			*frame;
+	int				oldphysent;
+
+	playertime = realtime - cls.latency + 0.02;
+	if (playertime > realtime)
+		playertime = realtime;
+
+	frame = &cl.frames[cl.parsecount&UPDATE_MASK];
+
+	for (j=0, info=cl.players, state=frame->playerstate ; j < MAX_CLIENTS 
+		; j++, info++, state++)
+	{
+		if (state->messagenum != cl.parsecount)
+			continue;	// not present this frame
+
+		// spawn light flashes, even ones coming from invisible objects
+#ifdef GLQUAKE
+		if (!gl_flashblend.value || j != cl.playernum) {
+#endif
+			if ((state->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED))
+				CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 3);
+			else if (state->effects & EF_BLUE)
+				CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 1);
+			else if (state->effects & EF_RED)
+				CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 2);
+			else if (state->effects & EF_BRIGHTLIGHT)
+				CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2] + 16, 400 + (rand()&31), 0.1, 0);
+			else if (state->effects & EF_DIMLIGHT)
+				CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 0);
+#ifdef GLQUAKE
+		}
+#endif
+
+		// the player object never gets added
+		if (j == cl.playernum)
+			continue;
+
+		if (!state->modelindex)
+			continue;
+
+		if (!Cam_DrawPlayer(j))
+			continue;
+
+		// grab an entity to fill in
+		if (cl_numvisedicts == MAX_VISEDICTS)
+			break;		// object list is full
+		ent = &cl_visedicts[cl_numvisedicts];
+		cl_numvisedicts++;
+		ent->keynum = 0;
+
+		ent->model = cl.model_precache[state->modelindex];
+		ent->skinnum = state->skinnum;
+		ent->frame = state->frame;
+		ent->colormap = info->translations;
+		if (state->modelindex == cl_playerindex)
+			ent->scoreboard = info;		// use custom skin
+		else
+			ent->scoreboard = NULL;
+
+		//
+		// angles
+		//
+		ent->angles[PITCH] = -state->viewangles[PITCH]/3;
+		ent->angles[YAW] = state->viewangles[YAW];
+		ent->angles[ROLL] = 0;
+		ent->angles[ROLL] = V_CalcRoll (ent->angles, state->velocity)*4;
+
+		// only predict half the move to minimize overruns
+		msec = 500*(playertime - state->state_time);
+		if (msec <= 0 || (!cl_predict_players.value && !cl_predict_players2.value))
+		{
+			VectorCopy (state->origin, ent->origin);
+//Con_DPrintf ("nopredict\n");
+		}
+		else
+		{
+			// predict players movement
+			if (msec > 255)
+				msec = 255;
+			state->command.msec = msec;
+//Con_DPrintf ("predict: %i\n", msec);
+
+			oldphysent = pmove.numphysent;
+			CL_SetSolidPlayers (j);
+			CL_PredictUsercmd (state, &exact, &state->command, false);
+			pmove.numphysent = oldphysent;
+			VectorCopy (exact.origin, ent->origin);
+		}
+
+		if (state->effects & EF_FLAG1)
+			CL_AddFlagModels (ent, 0);
+		else if (state->effects & EF_FLAG2)
+			CL_AddFlagModels (ent, 1);
+
+	}
+}
+
+//======================================================================
+
+/*
+===============
+CL_SetSolid
+
+Builds all the pmove physents for the current frame
+===============
+*/
+void CL_SetSolidEntities (void)
+{
+	int		i;
+	frame_t	*frame;
+	packet_entities_t	*pak;
+	entity_state_t		*state;
+
+	pmove.physents[0].model = cl.worldmodel;
+	VectorCopy (vec3_origin, pmove.physents[0].origin);
+	pmove.physents[0].info = 0;
+	pmove.numphysent = 1;
+
+	frame = &cl.frames[parsecountmod];
+	pak = &frame->packet_entities;
+
+	for (i=0 ; i<pak->num_entities ; i++)
+	{
+		state = &pak->entities[i];
+
+		if (!state->modelindex)
+			continue;
+		if (!cl.model_precache[state->modelindex])
+			continue;
+		if ( cl.model_precache[state->modelindex]->hulls[1].firstclipnode 
+			|| cl.model_precache[state->modelindex]->clipbox )
+		{
+			pmove.physents[pmove.numphysent].model = cl.model_precache[state->modelindex];
+			VectorCopy (state->origin, pmove.physents[pmove.numphysent].origin);
+			pmove.numphysent++;
+		}
+	}
+
+}
+
+/*
+===
+Calculate the new position of players, without other player clipping
+
+We do this to set up real player prediction.
+Players are predicted twice, first without clipping other players,
+then with clipping against them.
+This sets up the first phase.
+===
+*/
+void CL_SetUpPlayerPrediction(qboolean dopred)
+{
+	int				j;
+	player_state_t	*state;
+	player_state_t	exact;
+	double			playertime;
+	int				msec;
+	frame_t			*frame;
+	struct predicted_player *pplayer;
+
+	playertime = realtime - cls.latency + 0.02;
+	if (playertime > realtime)
+		playertime = realtime;
+
+	frame = &cl.frames[cl.parsecount&UPDATE_MASK];
+
+	for (j=0, pplayer = predicted_players, state=frame->playerstate; 
+		j < MAX_CLIENTS;
+		j++, pplayer++, state++) {
+
+		pplayer->active = false;
+
+		if (state->messagenum != cl.parsecount)
+			continue;	// not present this frame
+
+		if (!state->modelindex)
+			continue;
+
+		pplayer->active = true;
+		pplayer->flags = state->flags;
+
+		// note that the local player is special, since he moves locally
+		// we use his last predicted postition
+		if (j == cl.playernum) {
+			VectorCopy(cl.frames[cls.netchan.outgoing_sequence&UPDATE_MASK].playerstate[cl.playernum].origin,
+				pplayer->origin);
+		} else {
+			// only predict half the move to minimize overruns
+			msec = 500*(playertime - state->state_time);
+			if (msec <= 0 ||
+				(!cl_predict_players.value && !cl_predict_players2.value) ||
+				!dopred)
+			{
+				VectorCopy (state->origin, pplayer->origin);
+	//Con_DPrintf ("nopredict\n");
+			}
+			else
+			{
+				// predict players movement
+				if (msec > 255)
+					msec = 255;
+				state->command.msec = msec;
+	//Con_DPrintf ("predict: %i\n", msec);
+
+				CL_PredictUsercmd (state, &exact, &state->command, false);
+				VectorCopy (exact.origin, pplayer->origin);
+			}
+		}
+	}
+}
+
+/*
+===============
+CL_SetSolid
+
+Builds all the pmove physents for the current frame
+Note that CL_SetUpPlayerPrediction() must be called first!
+pmove must be setup with world and solid entity hulls before calling
+(via CL_PredictMove)
+===============
+*/
+void CL_SetSolidPlayers (int playernum)
+{
+	int		j;
+	extern	vec3_t	player_mins;
+	extern	vec3_t	player_maxs;
+	struct predicted_player *pplayer;
+	physent_t *pent;
+
+	if (!cl_solid_players.value)
+		return;
+
+	pent = pmove.physents + pmove.numphysent;
+
+	for (j=0, pplayer = predicted_players; j < MAX_CLIENTS;	j++, pplayer++) {
+
+		if (!pplayer->active)
+			continue;	// not present this frame
+
+		// the player object never gets added
+		if (j == playernum)
+			continue;
+
+		if (pplayer->flags & PF_DEAD)
+			continue; // dead players aren't solid
+
+		pent->model = 0;
+		VectorCopy(pplayer->origin, pent->origin);
+		VectorCopy(player_mins, pent->mins);
+		VectorCopy(player_maxs, pent->maxs);
+		pmove.numphysent++;
+		pent++;
+	}
+}
+
+
+/*
+===============
+CL_EmitEntities
+
+Builds the visedicts array for cl.time
+
+Made up of: clients, packet_entities, nails, and tents
+===============
+*/
+void CL_EmitEntities (void)
+{
+	if (cls.state != ca_active)
+		return;
+	if (!cl.validsequence)
+		return;
+
+	cl_oldnumvisedicts = cl_numvisedicts;
+	cl_oldvisedicts = cl_visedicts_list[(cls.netchan.incoming_sequence-1)&1];
+	cl_visedicts = cl_visedicts_list[cls.netchan.incoming_sequence&1];
+
+	cl_numvisedicts = 0;
+
+	CL_LinkPlayers ();
+	CL_LinkPacketEntities ();
+	CL_LinkProjectiles ();
+	CL_UpdateTEnts ();
+}
+