// cl_tent.c -- client side temporary entities
#include "client.h"


//-----------------------------------------------------------------------
// I'm just testing shit so, ignore the typedef/func names for now!!!!!
#define TE_MAX       20

typedef struct te_track_s {
   char type;                    // (1=normal ent   2=laser)                     // will have #defines soon
   long flags;                   // flags
   int track_index;              // index of ent src_index should track
   int src_index;                // index of ent to track track_index
   float forward;                // forward offset
   float right;                  // right offset
   float up;                     // up offset
   int dst_index;                // index of dst ent to track to
   vec3_t dstpos;                // dstpos to track to (if dst_index isn't used)
   float length;                 // length of something (varies)
} te_tracker_t;

te_tracker_t trackerList[TE_MAX];
vec3_t forward,right,up;

te_tracker_t *CL_FindTracker(int track_id);
void CL_AddTrackEnts(void);
void CL_TrackEntityMsg(void);
//-----------------------------------------------------------------------

typedef enum
{
	ex_free, 
	ex_explosion, 
	ex_misc, 
	ex_flash, 
	ex_mflash, 
	ex_poly, 
	ex_sprite,
	ex_scale_sprite	//	Nelno:	only one frame, scales from large to 0.1
} exptype_t;

typedef struct
{
	exptype_t	type;
	entity_t	ent;

	int			frames;
	float		light;
	vec3_t		lightcolor;
	float		start;
	int			baseframe;
	float		scale_factor;
	float		end_scale;
	float		alpha_scale;
	float		end_alpha;
} explosion_t;


#define	MAX_EXPLOSIONS	96
explosion_t	cl_explosions[MAX_EXPLOSIONS];
#define	MAX_BEAMS	32
typedef struct
{
	int		entity;
	struct model_s	*model;
	int		endtime;
	vec3_t	offset;
	vec3_t	start, end;
} beam_t;
beam_t		cl_beams[MAX_BEAMS];

#define	MAX_LASERS	32
typedef struct
{
	entity_t	ent;
	int			endtime;
} laser_t;
laser_t		cl_lasers[MAX_LASERS];


void CL_BlasterParticles (vec3_t org, vec3_t dir);
void CL_ExplosionParticles (vec3_t org);
void CL_SmallExplosionParticles (vec3_t org);
void CL_BFGExplosionParticles (vec3_t org);
struct sfx_s	*cl_sfx_ric1;
struct sfx_s	*cl_sfx_ric2;
struct sfx_s	*cl_sfx_ric3;
struct sfx_s	*cl_sfx_lashit;
struct sfx_s	*cl_sfx_spark5;
struct sfx_s	*cl_sfx_spark6;
struct sfx_s	*cl_sfx_spark7;
struct sfx_s	*cl_sfx_railg;
struct sfx_s	*cl_sfx_rockexp;
struct sfx_s	*cl_sfx_grenexp;
struct sfx_s	*cl_sfx_watrexp;

struct sfx_s	*cl_sfx_footsteps[4];
struct model_s	*cl_mod_explode;
struct model_s	*cl_mod_smoke;
struct model_s	*cl_mod_flash;
struct model_s	*cl_mod_parasite_segment;
struct model_s	*cl_mod_grapple_cable;
struct model_s	*cl_mod_parasite_tip;
struct model_s	*cl_mod_explo4;
struct model_s	*cl_mod_bfg_explo;
struct model_s	*cl_mod_powerscreen;

//	Nelno:	Daikatana temp entity models
struct	model_s	*cl_mod_explosion [2];
struct	sfx_s	*cl_sfx_explosion [1];
struct	model_s	*cl_mod_novahit;
struct	sfx_s	*cl_sfx_novahit;
struct	model_s	*cl_mod_kcorehit;
struct	model_s	*cl_mod_disctrail;

/*
=================
CL_RegisterTEntSounds
=================
*/
void CL_RegisterTEntSounds (void)
{
//	int		i;
//	char	name[MAX_QPATH];

	//	Nelno:	don't need Quake 2 sounds any longer.  Buh BYE!
/*
	cl_sfx_ric1 = S_RegisterSound ("world/ric1.wav");
	cl_sfx_ric2 = S_RegisterSound ("world/ric2.wav");
	cl_sfx_ric3 = S_RegisterSound ("world/ric3.wav");
	cl_sfx_lashit = S_RegisterSound("weapons/lashit.wav");
	cl_sfx_spark5 = S_RegisterSound ("world/spark5.wav");
	cl_sfx_spark6 = S_RegisterSound ("world/spark6.wav");
	cl_sfx_spark7 = S_RegisterSound ("world/spark7.wav");
	cl_sfx_railg = S_RegisterSound ("weapons/railgf1a.wav");
	cl_sfx_rockexp = S_RegisterSound ("weapons/rocklx1a.wav");
	cl_sfx_grenexp = S_RegisterSound ("weapons/grenlx1a.wav");
	cl_sfx_watrexp = S_RegisterSound ("weapons/xpld_wat.wav");

	S_RegisterSound ("player/land1.wav");

	S_RegisterSound ("player/fall2.wav");
	S_RegisterSound ("player/fall1.wav");

	for (i=0 ; i<4 ; i++)
	{
		Com_sprintf (name, sizeof(name), "player/step%i.wav", i+1);
		cl_sfx_footsteps[i] = S_RegisterSound (name);
	}
*/
	cl_sfx_explosion [0] = S_RegisterSound ("explosions/explode1.wav");
}	
/*
=================
CL_RegisterTEntModels
=================
*/
void CL_RegisterTEntModels (void)
{
	//	Nelno:	don't need Quake 2 models any longer
//	cl_mod_explode = re.RegisterModel ("models/objects/explode/tris.md2", RESOURCE_GLOBAL);
	cl_mod_smoke = re.RegisterModel ("models/gunsmoke/gunsmoke.md2", RESOURCE_GLOBAL);
	cl_mod_flash = re.RegisterModel ("models/flash/flash.md2", RESOURCE_GLOBAL);

	//	cache explosion sprite
	cl_mod_explosion [0] = re.RegisterModel ("models/explosion/explosion.sp2", RESOURCE_GLOBAL);
	cl_mod_explosion [1] = re.RegisterModel ("models/explosion2/explosion2.sp2", RESOURCE_GLOBAL);

	cl_mod_novahit = re.RegisterModel ("models/novahit/novahit.sp2", RESOURCE_GLOBAL);
	cl_mod_disctrail = re.RegisterModel ("models/disctrail/disctrail.sp2", RESOURCE_GLOBAL);
	cl_mod_kcorehit = re.RegisterModel ("models/kcorehit/kcorehit.sp2", RESOURCE_GLOBAL);
//	cl_mod_kcorehit = re.RegisterModel ("models/kcorehit/kcorehit.sp2", RESOURCE_GLOBAL);

/*
	cl_mod_parasite_segment = re.RegisterModel ("models/monsters/parasite/segment/tris.md2", RESOURCE_GLOBAL);
	cl_mod_grapple_cable = re.RegisterModel ("models/ctf/segment/tris.md2", RESOURCE_GLOBAL);
	cl_mod_parasite_tip = re.RegisterModel ("models/monsters/parasite/tip/tris.md2", RESOURCE_GLOBAL);
	cl_mod_explo4 = re.RegisterModel ("models/objects/r_explode/tris.md2", RESOURCE_GLOBAL);
	cl_mod_bfg_explo = re.RegisterModel ("sprites/s_bfg2.sp2", RESOURCE_GLOBAL);
	cl_mod_powerscreen = re.RegisterModel ("models/items/armor/effect/tris.md2", RESOURCE_GLOBAL);

	re.RegisterModel ("models/objects/laser/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/objects/grenade2/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/weapons/v_machn/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/weapons/v_handgr/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/weapons/v_shotg2/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/objects/gibs/bone/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/objects/gibs/sm_meat/tris.md2", RESOURCE_GLOBAL);
	re.RegisterModel ("models/objects/gibs/bone2/tris.md2", RESOURCE_GLOBAL);

	re.RegisterPic ("w_machinegun", RESOURCE_GLOBAL);
	re.RegisterPic ("a_bullets", RESOURCE_GLOBAL);
	re.RegisterPic ("i_health", RESOURCE_GLOBAL);
	re.RegisterPic ("a_grenades", RESOURCE_GLOBAL);
*/
}	
/*
=================
CL_ClearTEnts
=================
*/
void CL_ClearTEnts (void)
{
	memset (cl_beams, 0, sizeof(cl_beams));
	memset (cl_explosions, 0, sizeof(cl_explosions));
	memset (cl_lasers, 0, sizeof(cl_lasers));
   memset(trackerList,0,sizeof(trackerList));
}
/*
=================
CL_AllocExplosion
=================
*/
explosion_t *CL_AllocExplosion (void)
{
	int		i;
	int		time;
	int		index;
	
	for (i=0 ; i<MAX_EXPLOSIONS ; i++)
	{
		if (cl_explosions[i].type == ex_free)
		{
			memset (&cl_explosions[i], 0, sizeof (cl_explosions[i]));
			return &cl_explosions[i];
		}
	}
// find the oldest explosion
	time = cl.time;
	index = 0;
	for (i=0 ; i<MAX_EXPLOSIONS ; i++)
		if (cl_explosions[i].start < time)
		{
			time = cl_explosions[i].start;
			index = i;
		}
	memset (&cl_explosions[index], 0, sizeof (cl_explosions[index]));
	return &cl_explosions[index];
}

///////////////////////////////////////////////////////////////////////////////
//	CL_NovaHit
//
///////////////////////////////////////////////////////////////////////////////

void	CL_NovaHit (vec3_t org, vec3_t angles)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();

	ex->ent.origin [0] = org [0];
	ex->ent.origin [1] = org [1];
	ex->ent.origin [2] = org [2];

	ex->ent.angles [0] = angles [0];
	ex->ent.angles [1] = angles [1];
	ex->ent.angles [2] = angles [2];

	ex->type = ex_scale_sprite;
	ex->ent.flags = RF_FULLBRIGHT | RF_TRANSLUCENT | SPR_ORIENTED;

	ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;

	ex->light = 0;
	ex->lightcolor[0] = 1.0;
	ex->lightcolor[1] = 0.25;
	ex->lightcolor[2] = 0.25;
	
	ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = (rand () / (RAND_MAX << 1)) + 1.0;
	ex->ent.alpha = 0.9;
	ex->scale_factor = 0.995;
	ex->end_scale = 0.2;
	ex->alpha_scale = 0.95;
	ex->end_alpha = 0.025;

	ex->ent.model = cl_mod_novahit;

	ex->frames = 1;

	//	Nelno:	start cool hissing sound here
//		S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
}

///////////////////////////////////////////////////////////////////////////////
//	CL_DiscusTrail
//
///////////////////////////////////////////////////////////////////////////////

void	CL_DiscusTrail (vec3_t org, vec3_t angles)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();

	ex->ent.origin [0] = org [0];
	ex->ent.origin [1] = org [1];
	ex->ent.origin [2] = org [2];

	ex->ent.angles [0] = angles [0];
	ex->ent.angles [1] = angles [1];
	ex->ent.angles [2] = angles [2];

	ex->type = ex_scale_sprite;
	ex->ent.flags = RF_FULLBRIGHT | RF_TRANSLUCENT | SPR_ORIENTED;

	ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;

	ex->light = 0;
	ex->lightcolor[0] = 1.0;
	ex->lightcolor[1] = 0.25;
	ex->lightcolor[2] = 0.25;
	
	ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = (rand () / (RAND_MAX << 1)) + 1.0;
	ex->ent.alpha = 1.0;
	ex->scale_factor = 0.95;
	ex->end_scale = 0.2;
	ex->alpha_scale = 0.88;
	ex->end_alpha = 0.025;
//	ex->alpha_scale = 1.0;
//	ex->end_alpha = 0.0;

	ex->ent.model = cl_mod_disctrail;

	ex->frames = 1;

	//	Nelno:	start cool hissing sound here
//		S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
}


#if 1
///////////////////////////////////////////////////////////////////////////////
//	CL_KcoreHit
///////////////////////////////////////////////////////////////////////////////
void	CL_KcoreHit (vec3_t org, vec3_t angles)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();

	ex->ent.origin [0] = org [0];
	ex->ent.origin [1] = org [1];
	ex->ent.origin [2] = org [2];

	ex->ent.angles [0] = angles [0];
	ex->ent.angles [1] = angles [1];
	ex->ent.angles [2] = angles [2];

	ex->type = ex_scale_sprite;
	ex->ent.flags = RF_FULLBRIGHT | SPR_ALPHACHANNEL | RF_TRANSLUCENT | SPR_ORIENTED;

	ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;

	ex->light = 0;
	ex->lightcolor[0] = 1.0;
	ex->lightcolor[1] = 0.25;
	ex->lightcolor[2] = 0.25;
	
	ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = (rand () / (RAND_MAX << 1)) + 1.0;
	ex->ent.alpha = 1.0;
	ex->scale_factor = 0.90;
	ex->end_scale = 0.05;
	ex->alpha_scale = 0.90;
	ex->end_alpha = 0.05;

	ex->ent.model = cl_mod_kcorehit;

	ex->frames = 1;

	//	Nelno:	start cool hissing sound here
//		S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
}
#endif

#if 0
///////////////////////////////////////////////////////////////////////////////
//	CL_KcoreHit
///////////////////////////////////////////////////////////////////////////////
void	CL_KcoreHit (vec3_t org, vec3_t angles)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();

	ex->ent.origin [0] = org [0];
	ex->ent.origin [1] = org [1];
	ex->ent.origin [2] = org [2];

	ex->ent.angles [0] = angles [0];
	ex->ent.angles [1] = angles [1];
	ex->ent.angles [2] = angles [2];

	ex->type = ex_sprite;
	ex->ent.flags = RF_FULLBRIGHT | SPR_ALPHACHANNEL | RF_TRANSLUCENT | SPR_ORIENTED;

	ex->light = 0;
	ex->lightcolor[0] = 1.0;
	ex->lightcolor[1] = 0.25;
	ex->lightcolor[2] = 0.25;
	
	ex->ent.render_scale[0]=ex->ent.render_scale[1]=ex->ent.render_scale[2]=1;    // (rand () / (RAND_MAX << 1)) + 1.0;

	ex->ent.model = cl_mod_kcorehit;

	ex->frames=5;
   ex->baseframe=0;
	ex->start=cl.frame.servertime-CL_FRAME_MILLISECONDS;
}
#endif

//---------------------------------------------------------------------------
// CL_Explosion()
//---------------------------------------------------------------------------
void CL_Explosion(vec3_t org,vec3_t angles,float scale,int numframes,int modelindex)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();

	ex->ent.origin [0] = org [0];
	ex->ent.origin [1] = org [1];
	ex->ent.origin [2] = org [2];

	ex->ent.angles [0] = angles [0];
	ex->ent.angles [1] = angles [1];
	ex->ent.angles [2] = angles [2];

	ex->type = ex_sprite;

   // may need flags to deal with alphachannel
	ex->ent.flags = RF_FULLBRIGHT|SPR_ALPHACHANNEL|RF_TRANSLUCENT|SPR_ORIENTED;
//	ex->ent.flags = RF_FULLBRIGHT | RF_TRANSLUCENT | SPR_ORIENTED;

	ex->light = 0;
//	ex->lightcolor[0] = 1.0;
//	ex->lightcolor[1] = 0.25;
//	ex->lightcolor[2] = 0.25;
	
	ex->ent.render_scale[0]=ex->ent.render_scale[1]=ex->ent.render_scale[2]=scale;

   ex->ent.model=cl.model_draw[modelindex];

	ex->frames=numframes;
   ex->baseframe=0;
	ex->start=cl.frame.servertime-CL_FRAME_MILLISECONDS;
}

#if 0
///////////////////////////////////////////////////////////////////////////////
//	CL_IonHit
///////////////////////////////////////////////////////////////////////////////
void	CL_IonHit (vec3_t org, vec3_t angles)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();

	ex->ent.origin [0] = org [0];
	ex->ent.origin [1] = org [1];
	ex->ent.origin [2] = org [2];

	ex->ent.angles [0] = angles [0];
	ex->ent.angles [1] = angles [1];
	ex->ent.angles [2] = angles [2];

	ex->type = ex_sprite;
	ex->ent.flags = RF_FULLBRIGHT | SPR_ALPHACHANNEL | RF_TRANSLUCENT | SPR_ORIENTED;

	ex->light = 0;
	ex->lightcolor[0] = 1.0;
	ex->lightcolor[1] = 0.25;
	ex->lightcolor[2] = 0.25;
	
	ex->ent.render_scale[0]=ex->ent.render_scale[1]=ex->ent.render_scale[2]=1;

	ex->ent.model = cl_mod_ionhit;

	ex->frames=10;
   ex->baseframe=0;
	ex->start=cl.frame.servertime-CL_FRAME_MILLISECONDS;
}
#endif

/*
=================
CL_SmokeAndFlash
=================
*/
void CL_SmokeAndFlash(vec3_t origin)
{
	explosion_t	*ex;

	ex = CL_AllocExplosion ();
	VectorCopy (origin, ex->ent.origin);
	ex->type = ex_misc;
	ex->frames = 4;
	ex->ent.flags = RF_TRANSLUCENT;
	ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;
	ex->ent.model = cl_mod_smoke;
	ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = 1.0;

	ex = CL_AllocExplosion ();
	VectorCopy (origin, ex->ent.origin);
	ex->type = ex_flash;
	ex->ent.flags = RF_FULLBRIGHT;
	ex->frames = 2;
	ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;
	ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = 1.0;
	ex->ent.model = cl_mod_flash;
}
/*
=================
CL_ParseParticles
=================
*/
void CL_ParseParticles (void)
{
	int		color, count;
	vec3_t	pos, dir;
	MSG_ReadPos (&net_message, pos);
	MSG_ReadDir (&net_message, dir);
	color = MSG_ReadByte (&net_message);
	count = MSG_ReadByte (&net_message);
	CL_ParticleEffect (pos, dir, color, count);
}
/*
=================
CL_ParseBeam
=================
*/
int CL_ParseBeam (struct model_s *model)
{
	int		ent;
	vec3_t	start, end;
	beam_t	*b;
	int		i;
	
	ent = MSG_ReadShort (&net_message);
	
	MSG_ReadPos (&net_message, start);
	MSG_ReadPos (&net_message, end);
// override any beam with the same entity
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++)
		if (b->entity == ent)
		{
			b->entity = ent;
			b->model = model;
			b->endtime = cl.time + 200;
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorClear (b->offset);
			return ent;
		}
// find a free beam
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++)
	{
		if (!b->model || b->endtime < cl.time)
		{
			b->entity = ent;
			b->model = model;
			b->endtime = cl.time + 200;
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorClear (b->offset);
			return ent;
		}
	}
	Com_Printf ("beam list overflow!\n");	
	return ent;
}
/*
=================
CL_ParseBeam2
=================
*/
int CL_ParseBeam2 (struct model_s *model)
{
	int		ent;
	vec3_t	start, end, offset;
	beam_t	*b;
	int		i;
	
	ent = MSG_ReadShort (&net_message);
	
	MSG_ReadPos (&net_message, start);
	MSG_ReadPos (&net_message, end);
	MSG_ReadPos (&net_message, offset);

// override any beam with the same entity
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++)
		if (b->entity == ent)
		{
			b->entity = ent;
			b->model = model;
			b->endtime = cl.time + 200;
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorCopy (offset, b->offset);
			return ent;
		}

// find a free beam
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++)
	{
		if (!b->model || b->endtime < cl.time)
		{
			b->entity = ent;
			b->model = model;
			b->endtime = cl.time + 200;
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorCopy (offset, b->offset);
			return ent;
		}
	}
	Com_Printf ("beam list overflow!\n");	
	return ent;
}

/*
=================
CL_ParseLaser
=================
*/
void CL_ParseLaser (int colors)
{
	vec3_t	start;
	vec3_t	end;
	laser_t	*l;
	int		i;

	MSG_ReadPos (&net_message, start);
	MSG_ReadPos (&net_message, end);

	for (i=0, l=cl_lasers ; i< MAX_LASERS ; i++, l++)
	{
		if (l->endtime < cl.time)
		{
			l->ent.flags = RF_TRANSLUCENT | RF_BEAM;
			VectorCopy (start, l->ent.origin);
			VectorCopy (end, l->ent.oldorigin);
			l->ent.alpha = 0.30;
			l->ent.skinnum = (colors >> ((rand() % 4)*8)) & 0xff;
			l->ent.model = NULL;
			l->ent.frame = 4;
			l->endtime = cl.time + CL_FRAME_MILLISECONDS;
			return;
		}
	}
}


/*
=================
CL_ParseTEnt
=================
*/
static byte splash_color[] = {0x00, 0xe0, 0xb0, 0x50, 0xd0, 0xe0, 0xe8};
void CL_ParseTEnt (void)
{
	int		type;
	vec3_t	pos, pos2, dir, angles;
	explosion_t	*ex;
	int		cnt;
	int		color;
	int		r;
	int		ent;
   float    scale;
	type = MSG_ReadByte (&net_message);
	switch (type)
	{
	case TE_BLOOD:			// bullet hitting flesh
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		CL_BloodSplash (pos, dir, 0xe8, 60);
		break;
	case TE_BLUE_SPARKS:			// disruptor rod
		MSG_ReadPos (&net_message, pos);
		//MSG_ReadDir (&net_message, dir);
		CL_ParticleEffect_Complex (pos, vec3_origin, 0x00, 16, PARTICLE_BLUE_SPARKS);
		break;
	case TE_GUNSHOT:			// bullet hitting wall
	case TE_SPARKS:
	case TE_BULLET_SPARKS:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		if (type == TE_GUNSHOT)
			CL_ParticleEffect (pos, dir, 0, 40);
		else
			CL_ParticleEffect_Complex (pos, dir, 0x10, 6, PARTICLE_SPARKS);
		if (type != TE_SPARKS)
		{
			CL_SmokeAndFlash(pos);
			// impact sound
			cnt = rand()&15;
			if (cnt == 1)
				S_StartSound (pos, 0, 0, cl_sfx_ric1, 1, ATTN_NORM, 0);
			else if (cnt == 2)
				S_StartSound (pos, 0, 0, cl_sfx_ric2, 1, ATTN_NORM, 0);
			else if (cnt == 3)
				S_StartSound (pos, 0, 0, cl_sfx_ric3, 1, ATTN_NORM, 0);
		}
		break;
		
	case TE_SCREEN_SPARKS:
	case TE_SHIELD_SPARKS:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		if (type == TE_SCREEN_SPARKS)
			CL_ParticleEffect (pos, dir, 0xd0, 40);
		else
			CL_ParticleEffect (pos, dir, 0xb0, 40);
		//FIXME : replace or remove this sound
		S_StartSound (pos, 0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
		break;
		
	case TE_SHOTGUN:			// bullet hitting wall
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		CL_ParticleEffect (pos, dir, 0, 20);
		CL_SmokeAndFlash(pos);
		break;
	case TE_SPLASH:			// bullet hitting water
		cnt = MSG_ReadByte (&net_message);
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		r = MSG_ReadByte (&net_message);
		if (r > 6)
			color = 0x00;
		else
			color = splash_color[r];
		CL_ParticleEffect (pos, dir, color, cnt);
		if (r == SPLASH_SPARKS)
		{
			r = rand() & 3;
			if (r == 0)
				S_StartSound (pos, 0, 0, cl_sfx_spark5, 1, ATTN_STATIC, 0);
			else if (r == 1)
				S_StartSound (pos, 0, 0, cl_sfx_spark6, 1, ATTN_STATIC, 0);
			else
				S_StartSound (pos, 0, 0, cl_sfx_spark7, 1, ATTN_STATIC, 0);
		}
		break;
	case TE_LASER_SPARKS:
		cnt = MSG_ReadByte (&net_message);
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		color = MSG_ReadByte (&net_message);
		CL_ParticleEffect2 (pos, dir, color, cnt);
		break;
	case TE_BLASTER:			// blaster hitting wall
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		CL_BlasterParticles (pos, dir);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->ent.angles[0] = acos(dir[2])/M_PI*180;
		ex->ent.angles[2] = atan2(dir[1], dir[0])/M_PI*180;
		ex->type = ex_misc;
		ex->ent.flags = RF_FULLBRIGHT|RF_TRANSLUCENT;
		ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;
		ex->light = 150;
		ex->lightcolor[0] = 1;
		ex->lightcolor[1] = 1;
		ex->ent.model = cl_mod_explode;
		ex->frames = 4;
		S_StartSound (pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
		break;
		
	case TE_RAILTRAIL:			// railgun effect
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_RailTrail (pos, pos2);
		S_StartSound (pos2, 0, 0, cl_sfx_railg, 1, ATTN_NORM, 0);
		break;

	case TE_PLASMATRAIL:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_PlasmaTrail (pos, pos2);
		S_StartSound (pos2, 0, 0, cl_sfx_railg, 1, ATTN_NORM, 0);
		break;
		//	Nelno:	TE_EXPLOSION2 is now just the same as TE_EXPLOSION1 but without sound
	case TE_EXPLOSION2:
	case TE_EXPLOSION1:
	case TE_ROCKET_EXPLOSION:
	case TE_ROCKET_EXPLOSION_WATER:
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT | SPR_ALPHACHANNEL | RF_TRANSLUCENT;
		ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;
		ex->light = 200;
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.0;

		ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = 1.0;//(rand () / (RAND_MAX << 1)) + 0.75;

		ex->ent.model = cl_mod_explosion [rand () & 1];

		ex->frames = 10;
		CL_ExplosionParticles (pos);
		
		if (type != TE_EXPLOSION2)
		{
			if (type == TE_ROCKET_EXPLOSION_WATER)
				S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
			else
				S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
		}
		break;

	case TE_EXPLOSION_SMALL1:
	case TE_EXPLOSION_SMALL2:
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT | SPR_ALPHACHANNEL | RF_TRANSLUCENT;
		ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;
		ex->light = 50;
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.0;

		ex->ent.render_scale [0] = ex->ent.render_scale [1] = ex->ent.render_scale [2] = (rand () / (RAND_MAX << 1)) + 0.55;

		ex->ent.model = cl_mod_explosion [rand () & 1];

		ex->frames = 10;
		
		CL_SmallExplosionParticles (pos);

		if (type != TE_EXPLOSION_SMALL2)
		{
			if (type == TE_ROCKET_EXPLOSION_WATER)
				S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
			else
				S_StartSound (pos, 0, 0, cl_sfx_explosion [0], 1, ATTN_NORM, 0);
		}
		break;

	case TE_NOVAHIT:
		//	read position
		MSG_ReadPos (&net_message, pos);

		//	read facing angle
		angles [0] = MSG_ReadAngle16 (&net_message);
		angles [1] = MSG_ReadAngle16 (&net_message);
		angles [2] = MSG_ReadAngle16 (&net_message);

//		CL_NovaHit (pos, angles);
		CL_KcoreHit (pos, angles);
		break;

	case TE_EXPLOSION:
		//	read position
		MSG_ReadPos (&net_message, pos);

		//	read facing angle
		angles [0] = MSG_ReadAngle16 (&net_message);
		angles [1] = MSG_ReadAngle16 (&net_message);
		angles [2] = MSG_ReadAngle16 (&net_message);

      scale=MSG_ReadFloat(&net_message);

      cnt=MSG_ReadByte(&net_message);
      r=MSG_ReadLong(&net_message);

      CL_Explosion(pos,angles,scale,cnt,r);
		break;

	case TE_BFG_EXPLOSION:
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT;
		ex->start = cl.frame.servertime - CL_FRAME_MILLISECONDS;
		ex->light = 350;
		ex->lightcolor[0] = 0.0;
		ex->lightcolor[1] = 1.0;
		ex->lightcolor[2] = 0.0;
		ex->ent.model = cl_mod_bfg_explo;
		ex->ent.flags |= RF_TRANSLUCENT;
		ex->ent.alpha = 0.30;
		ex->frames = 4;
		break;

	case TE_BFG_BIGEXPLOSION:
		MSG_ReadPos (&net_message, pos);
		CL_BFGExplosionParticles (pos);
		break;

	case TE_BFG_LASER:
		CL_ParseLaser (0xd0d1d2d3);
		break;

	case TE_BUBBLETRAIL:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_BubbleTrail (pos, pos2);
		break;
	case TE_PARASITE_ATTACK:
	case TE_MEDIC_CABLE_ATTACK:
		ent = CL_ParseBeam (cl_mod_parasite_segment);
		break;

	case TE_BOSSTPORT:			// boss teleporting to station
		MSG_ReadPos (&net_message, pos);
		CL_BigTeleportParticles (pos);
		S_StartSound (pos, 0, 0, S_RegisterSound ("misc/bigtele.wav"), 1, ATTN_NONE, 0);
		break;

	case TE_GRAPPLE_CABLE:
		ent = CL_ParseBeam2 (cl_mod_grapple_cable);
		break;

	case TE_WELDING_SPARKS:
		cnt = MSG_ReadByte (&net_message);
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		color = MSG_ReadByte (&net_message);
		CL_ParticleEffect2 (pos, dir, color, cnt);

		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_flash;
		// note to self
		// we need a better no draw flag
		ex->ent.flags = RF_BEAM;
		ex->start = cl.frame.servertime - 0.1;
		ex->light = 100 + (rand()%75);
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 1.0;
		ex->lightcolor[2] = 0.3;
		ex->ent.model = cl_mod_flash;
		ex->frames = 2;
		break;

	case TE_GREENBLOOD:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		CL_ParticleEffect2 (pos, dir, 0xc0, 30);
		break;

   case TE_TRACK_ENTITY:
      CL_TrackEntityMsg();
   break;
	
	default:
		Com_Error (ERR_DROP, "CL_ParseTEnt: bad type");
	}
}

#define VectorMul(vec,val)    vec[0] *= val; vec[1] *= val; vec[2] *= val
#define VectorDiv(vec,val)    vec[0] /= val; vec[1] /= val; vec[2] /= val

//---------------------------------------------------------------------------
// CL_FindTracker()
//---------------------------------------------------------------------------
te_tracker_t *CL_FindTracker(int track_index)
{
   te_tracker_t *tracker;
   int loop;

   tracker=trackerList;
   for (loop=0; loop<TE_MAX; loop++,tracker++)
      if (tracker->track_index==track_index)
         break;

   if (loop==TE_MAX)
   {
      tracker=trackerList;
      for (loop=0; loop<TE_MAX; loop++,tracker++)
         if (!tracker->track_index)
            break;

      if (loop==TE_MAX)
         return(NULL);
   }

   tracker->track_index=track_index;
   return(tracker);
}

//---------------------------------------------------------------------------
// CL_AddTrackEnts()
//---------------------------------------------------------------------------
void CL_AddTrackEnts(void)
{
   centity_t	*owner,*track,*dstent;
   entity_t		ent;
   te_tracker_t *tracker=trackerList;
   vec3_t		origin, angles, fwd, end, shake;
   int			loop;
   trace_t		trace;

   // random shake ofs
   shake[0] = rand() & 1 ? -(rand() & 1) * .2 : (rand() & 1) * .2;
   shake[1] = rand() & 1 ? -(rand() & 1) * .2 : (rand() & 1) * .2;
   shake[2] = rand() & 1 ? -(rand() & 1) * .2 : (rand() & 1) * .2;

	for (loop=0; loop<TE_MAX; loop++,tracker++)
	{
		if (!tracker->track_index)
		 continue;

		owner=&cl_entities[tracker->src_index];
		track=&cl_entities[tracker->track_index];
		dstent=&cl_entities[tracker->dst_index];

      // light follows ent?  (length,forward,right,up hold size,r,g,b)
      if (tracker->flags & TEF_ADDLIGHT)
      {
			V_AddLight(track->current.origin,tracker->length,tracker->forward,tracker->right,tracker->up);
         continue;
      }

      // init entity
		memset(&ent,0,sizeof(ent));
      ent.flags=track->current.renderfx;

		if (tracker->src_index==cl.playernum+1)      // when src is owner, show based on refdef values
		{
			if ((cl.frame.playerstate.pmove.pm_flags & PMF_CAMERAMODE) && (tracker->flags & RF_WEAPONMODEL))
			{
				// don't draw anything
				continue;

				// was playing with shit here...
				// (showing weapon when in 3rd person view -- looks like draw order is fucked)
            // (just thought... maybe killing DEPTHHACK and/or WEAPONMODEL flags fixes it...)
				VectorCopy(owner->current.origin,origin);
				VectorCopy(owner->current.angles,angles);
			}
			else
			{
				VectorCopy(cl.refdef.vieworg,origin);
				VectorCopy(cl.refdef.viewangles,angles);
			}
		}
		else                                         // when src isn't owner, use slower, server-updated values
		{
			 VectorCopy(owner->current.origin,origin);
			 VectorCopy(owner->current.angles,angles);
			 angles[0] *= 3;
		}

		// set position  (adds forward,right,up to origin)
		AngleVectors(angles,forward,right,up);
		VectorCopy(forward,fwd);
		VectorMul(forward,tracker->forward);
		VectorMul(right,tracker->right);
		VectorMul(up,tracker->up);
		VectorAdd(origin,forward,ent.origin);
		VectorAdd(ent.origin,right,ent.origin);
		VectorAdd(ent.origin,up,ent.origin);

      // shake?
      if (track->current.renderfx & RF_SHAKE)
         VectorAdd(ent.origin,shake,ent.origin);

		// set angle and scale
		VectorCopy(angles,ent.angles);
		VectorCopy(track->current.render_scale,ent.render_scale);

      // special cases
		if (tracker->flags & (RF_BEAM | RF_LASERBEAM))
		{
         vec3_t stupid;

         // RF_BEAM only needs partial shake value
         // (this is a stupid way to do this, but I needed to add it quick)
         // (i'll change it later)
         if (track->current.renderfx & RF_SHAKE)
         {
            VectorScale(shake,.8,stupid);
            VectorSubtract(ent.origin,stupid,ent.origin);
         }

			ent.frame=track->current.frame;
			ent.skinnum = (track->current.skinnum >> ((rand() % 4)*8)) & 0xff;
			ent.model=NULL;

			//	VectorMul(fwd,tracker->length);
			//	VectorAdd(ent.origin,fwd,ent.oldorigin);

			VectorMA (ent.origin, 2000.0, fwd, end);
			trace = CL_Trace (ent.origin, NULL, NULL, end, tracker->src_index, MASK_SOLID);

	  		VectorCopy (trace.endpos, ent.oldorigin);
      	VectorToAngles (angles, trace.plane.normal);
         if (!(trace.surface->flags & SURF_SKY))
         {
   			CL_ParticleEffect_Complex (trace.endpos, fwd, 72, 50, PARTICLE_SPARKS);
			   CL_NovaHit (trace.endpos, angles);
         }

         // RF_BEAM only needs partial shake value
         // (this is a stupid way to do this, but I needed to add it quick)
         // (i'll change it later)
         if (track->current.renderfx & RF_SHAKE)
         {
            VectorAdd(ent.oldorigin,shake,ent.oldorigin);
            VectorSubtract(ent.oldorigin,stupid,ent.oldorigin);
         }
		}
		else if (tracker->flags & RF_SPOTLIGHT)
		{
			ent.frame=track->current.frame;
			ent.skinnum = (track->current.skinnum >> ((rand() % 4)*8)) & 0xff;
			ent.alpha=.80;
			ent.model=NULL;

			VectorMul(fwd,tracker->length);
			VectorAdd(ent.origin,fwd,ent.oldorigin);

			//	Nelno:	spawn a dymamic light here
		}
		else if (tracker->flags & RF_LIGHTNING)
		{
			ent.flags |= RF_BEAM;                  // for now just use a beam
			ent.frame=track->current.frame;
			ent.skinnum = (track->current.skinnum >> ((rand() % 4)*8)) & 0xff;
			ent.model=NULL;

			VectorMul(fwd,tracker->length);
			VectorAdd(ent.origin,fwd,ent.oldorigin);

			CL_ParticleEffect2 (dstent->current.origin, fwd, rand()&31, 50);
		}
		else     // nope, just standard model
		{
			ent.model=cl.model_draw[track->current.modelindex];
			ent.frame=track->current.frame;
		}

		if (tracker->flags & TEF_DSTINDEX)
			VectorCopy(dstent->current.origin,ent.oldorigin);

      ent.alpha=track->current.alpha;
		ent.flags |= tracker->flags;

		V_AddEntity(&ent);
	}
}

//---------------------------------------------------------------------------
// CL_TrackEntityMsg()
//---------------------------------------------------------------------------
void CL_TrackEntityMsg(void)
{
   te_tracker_t *tracker;
   vec3_t fru;
   long track_index;

   track_index=MSG_ReadLong(&net_message);
   if (!(tracker=CL_FindTracker(track_index)))
      return;

   switch (MSG_ReadByte(&net_message))             // read mode
   {
      case 1:                                      // new / update tracking
         tracker->flags=MSG_ReadLong(&net_message);            // flags

         if (tracker->flags & TEF_SRCINDEX)
            tracker->src_index=MSG_ReadLong(&net_message);        // src ent index

         if (tracker->flags & TEF_FRU)
         {
            MSG_ReadPos(&net_message,fru);                        // forward, right, up offsets
            tracker->forward=fru[0];
            tracker->right=fru[1];
            tracker->up=fru[2];
         }

         if (tracker->flags & TEF_DSTINDEX)
            tracker->dst_index=MSG_ReadLong(&net_message);     // dst ent index

         if (tracker->flags & TEF_DSTPOS)
            MSG_ReadPos(&net_message,tracker->dstpos);         // dst position

         if (tracker->flags & TEF_LENGTH)
            tracker->length=MSG_ReadFloat(&net_message);       // length
      break;

      case 2:                                      // kill tracking
         tracker->track_index=0;
      break;
   }
}

/*
=================
CL_AddBeams
=================
*/
void CL_AddBeams (void)
{
	int			i,j;
	beam_t		*b;
	vec3_t		dist, org;
	float		d;
	entity_t	ent;
	float		yaw, pitch;
	float		forward;
// update beams
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++)
	{
		if (!b->model || b->endtime < cl.time)
			continue;
	// if coming from the player, update the start position
		if (b->entity == cl.playernum+1)	// entity 0 is the world
		{
			VectorCopy (cl.refdef.vieworg, b->start);
			b->start[2] -= 22;	// adjust for view height
		}
		VectorAdd (b->start, b->offset, org);
	// calculate pitch and yaw
		VectorSubtract (b->end, org, dist);
		if (dist[1] == 0 && dist[0] == 0)
		{
			yaw = 0;
			if (dist[2] > 0)
				pitch = 90;
			else
				pitch = 270;
		}
		else
		{
			yaw = (int) (atan2(dist[1], dist[0]) * 180 / M_PI);
			if (yaw < 0)
				yaw += 360;
	
			forward = sqrt (dist[0]*dist[0] + dist[1]*dist[1]);
			pitch = (int) (atan2(dist[2], forward) * -180 / M_PI);
			if (pitch < 0)
				pitch += 360;
		}
	// add new entities for the beams
		d = VectorNormalize(dist);
		memset (&ent, 0, sizeof(ent));
		while (d > 0)
		{
			VectorCopy (org, ent.origin);
			ent.model = b->model;
			ent.angles[0] = pitch;
			ent.angles[1] = yaw;
			ent.angles[2] = rand()%360;
			V_AddEntity (&ent);
			for (j=0 ; j<3 ; j++)
				org[j] += dist[j]*30;
			d -= 30;
		}
	}
	
}
/*
=================
CL_AddExplosions
=================
*/
void CL_AddExplosions (void)
{
	entity_t	*ent;
	int			i;
	explosion_t	*ex;
	float		frac;
	int			f;
	memset (&ent, 0, sizeof(ent));
	for (i=0, ex=cl_explosions ; i< MAX_EXPLOSIONS ; i++, ex++)
	{

		if (ex->type == ex_free)
			continue;
		frac = (cl.time - ex->start) / CL_FRAME_MILLISECONDS;
		f = floor(frac);
		ent = &ex->ent;
		switch (ex->type)
		{
		case ex_mflash:
			if (f >= ex->frames-1)
				ex->type = ex_free;
			break;
		case ex_misc:
			if (f >= ex->frames-1)
			{
				ex->type = ex_free;
				break;
			}
			ent->alpha = 1.0 - frac/(ex->frames-1);
			break;
		case ex_flash:
			if (f >= 1)
			{
				ex->type = ex_free;
				break;
			}
			ent->alpha = 1.0;
			break;
		case ex_poly:
			if (f >= ex->frames-1)
			{
				ex->type = ex_free;
				break;
			}
			ent->alpha = (16.0 - (float)f)/16.0;
			if (f < 10)
			{
				ent->skinnum = (f>>1);
				if (ent->skinnum < 0)
					ent->skinnum = 0;
			}
			else
			{
				ent->flags |= RF_TRANSLUCENT;
				if (f < 13)
					ent->skinnum = 5;
				else
					ent->skinnum = 6;
			}
			break;
		//	Nelno:	suck me down
		case	ex_sprite:
			ent->alpha = ((ex->frames) - (float)f)/ex->frames;
         ent->alpha=.1;
			if (f >= ex->frames-1)
			{
				ex->type = ex_free;
				break;
			}
			break;

		case	ex_scale_sprite:
			//	Nelno:	only one frame, scales from large to 0.1
			ent->render_scale [0] *= ex->scale_factor;
			ent->alpha *= ex->alpha_scale;

			if (ent->render_scale [0] < ex->end_scale || ent->alpha < ex->end_alpha)
			{
				ex->type = ex_free;
				break;
			}

			ent->render_scale [1] *= ex->scale_factor;
			ent->render_scale [2] *= ex->scale_factor;
			break;

		}
		if (ex->type == ex_free)
			continue;
		if (ex->light)
		{
			V_AddLight (ent->origin, ex->light*ent->alpha,
				ex->lightcolor[0], ex->lightcolor[1], ex->lightcolor[2]);
		}
		VectorCopy (ent->origin, ent->oldorigin);
		
		if (ex->type != ex_scale_sprite)
		{
			if (f < 0)
				f = 0;
			ent->frame = ex->baseframe + f + 1;
			ent->oldframe = ex->baseframe + f;
			ent->backlerp = 1.0 - cl.lerpfrac;
		}
		else
		{
			ent->frame = 0;
			ent->oldframe = 0;
			ent->backlerp = 1.0;
		}

		V_AddEntity (ent);
	}
}

/*
=================
CL_AddLasers
=================
*/
void CL_AddLasers (void)
{
	laser_t		*l;
	int			i;

	for (i=0, l=cl_lasers ; i< MAX_LASERS ; i++, l++)
	{
		if (l->endtime >= cl.time)
			V_AddEntity (&l->ent);
	}
}


/*
=================
CL_AddTEnts
=================
*/
void CL_AddTEnts (void)
{
	CL_AddBeams ();
	CL_AddExplosions ();
	CL_AddLasers ();
}
