示例#1
0
/*
=================
CL_ParseLaser
=================
*/
static void CL_ParseLaser (sizebuf_t *msg, int colors)
{
	vec3_t	start;
	vec3_t	end;
	laser_t	*l;
	int		i;

	MSG_ReadPos (msg, start);
	MSG_ReadPos (msg, 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.30f;
			l->ent.skinnum = (colors >> ((rand() % 4)*8)) & 0xff;
			l->ent.model = NULL;
			l->ent.frame = 4;
			l->endtime = cl.time + 100;
#ifdef GL_QUAKE
			AxisClear(l->ent.axis);
#endif
			return;
		}
	}
示例#2
0
void CL_ParseNuke (void)
{
	vec3_t	pos;
	int32_t		i;
	cl_sustain_t	*s, *free_sustain;

	free_sustain = NULL;
	for (i=0, s=cl_sustains; i<MAX_SUSTAINS; i++, s++)
	{
		if (s->id == 0)
		{
			free_sustain = s;
			break;
		}
	}
	if (free_sustain)
	{
		s->id = 21000;
		MSG_ReadPos (&net_message, s->org);
		s->endtime = cl.time + 1000;
		s->think = CL_Nukeblast;
		s->thinkinterval = 1;
		s->nextthink = cl.time;
	}
	else // no free sustains
	{
		// FIXME - read the stuff anyway
		MSG_ReadPos (&net_message, pos);
	}
}
示例#3
0
/*
=================
CL_ParsePlayerBeam
  - adds to the cl_playerbeam array instead of the cl_beams array
=================
*/
int32_t CL_ParsePlayerBeam (struct model_s *model)
{
	int32_t		ent;
	vec3_t	start, end, offset;
	beam_t	*b;
	int32_t		i;
	
	ent = MSG_ReadShort (&net_message);
	
	MSG_ReadPos (&net_message, start);
	MSG_ReadPos (&net_message, end);
	// PMM - network optimization
	if (model == clMedia.mod_heatbeam)
		VectorSet(offset, 2, 7, -3);
	else if (model == clMedia.mod_monster_heatbeam)
	{
		model = clMedia.mod_heatbeam;
		VectorSet(offset, 0, 0, 0);
	}
	else
		MSG_ReadPos (&net_message, offset);

//	Com_Printf ("end- %f %f %f\n", end[0], end[1], end[2]);

// override any beam with the same entity
// PMM - For player beams, we only want one per player (entity) so..
	for (i=0, b=cl_playerbeams; 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_playerbeams; i<MAX_BEAMS; i++, b++)
	{
		if (!b->model || b->endtime < cl.time)
		{
			b->entity = ent;
			b->model = model;
			b->endtime = cl.time + 100;		// PMM - this needs to be 100 to prevent multiple heatbeams
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorCopy (offset, b->offset);
			return ent;
		}
	}
	Com_Printf ("beam list overflow!\n");	
	return ent;
}
示例#4
0
 /*
  * adds to the cl_playerbeam array instead of the cl_beams array
  */
 void
 CL_ParsePlayerBeam ( struct model_s *model )
 {
   q_int32_t ent;
   vec3_t start, end, offset;
   beam_t *b;
   q_int32_t i;
   ent = MSG_ReadShort ( &net_message );
   MSG_ReadPos ( &net_message, start );
   MSG_ReadPos ( &net_message, end );

   /* network optimization */
   if ( model == cl_mod_heatbeam ) {
     VectorSet ( offset, 2, 7, -3 );
   } else if ( model == cl_mod_monster_heatbeam ) {
     model = cl_mod_heatbeam;
     VectorSet ( offset, 0, 0, 0 );
   } else {
     MSG_ReadPos ( &net_message, offset );
   }

   /* Override any beam with the same entity
      For player beams, we only want one per
      player (entity) so... */
   for ( i = 0, b = cl_playerbeams; 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;
     }
   }

   /* find a free beam */
   for ( i = 0, b = cl_playerbeams; i < MAX_BEAMS; i++, b++ ) {
     if ( !b->model || ( b->endtime < cl.time ) ) {
       b->entity = ent;
       b->model = model;
       b->endtime = cl.time + 100; /* this needs to be 100 to
                        prevent multiple heatbeams */
       VectorCopy ( start, b->start );
       VectorCopy ( end, b->end );
       VectorCopy ( offset, b->offset );
       return;
     }
   }

   Com_Printf ( "beam list overflow!\n" );
   return;
 }
示例#5
0
// Psychspaz's enhanced particles
int32_t CL_ParseLightning ()
{

	vec3_t start,end; // ,move,vec;
	int32_t		srcEnt, dstEnt; // , len, dec;
	
	srcEnt = MSG_ReadShort (&net_message);
	dstEnt = MSG_ReadShort (&net_message);

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

	CL_LightningBeam(start, end, srcEnt, dstEnt, 5);
		
	return srcEnt;
}
示例#6
0
/*
=================
CL_ParseBeam2
=================
*/
int32_t CL_ParseBeam2 (struct model_s *model)
{
	int32_t		ent;
	vec3_t	start, end, offset;
	beam_t	*b;
	int32_t		i;
	
	ent = MSG_ReadShort (&net_message);
	
	MSG_ReadPos (&net_message, start);
	MSG_ReadPos (&net_message, end);
	MSG_ReadPos (&net_message, offset);

//	Com_Printf ("end- %f %f %f\n", end[0], end[1], end[2]);

// 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;
}
示例#7
0
/*
=================
CL_ParseLightning
=================
*/
static int CL_ParseLightning (sizebuf_t *msg, struct model_s *model)
{
	int		srcEnt, destEnt;
	vec3_t	start, end;
	beam_t	*b;
	int		i;
	
	srcEnt = MSG_ReadShort (msg);
	destEnt = MSG_ReadShort (msg);

	MSG_ReadPos (msg, start);
	MSG_ReadPos (msg, end);

// override any beam with the same source AND destination entities
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++) {
		if (b->entity == srcEnt && b->dest_entity == destEnt)
		{
			//b->entity = srcEnt;
			//b->dest_entity = destEnt;
			b->model = model;
			b->endtime = cl.time + 200;
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorClear (b->offset);
			return srcEnt;
		}
	}

// find a free beam
	for (i=0, b=cl_beams ; i< MAX_BEAMS ; i++, b++)
	{
		if (!b->model || b->endtime < cl.time)
		{
			b->entity = srcEnt;
			b->dest_entity = destEnt;
			b->model = model;
			b->endtime = cl.time + 200;
			VectorCopy (start, b->start);
			VectorCopy (end, b->end);
			VectorClear (b->offset);
			return srcEnt;
		}
	}
	Com_Printf ("beam list overflow!\n");	
	return srcEnt;
}
示例#8
0
/*
=================
CL_ParseBeam2
=================
*/
static int CL_ParseBeam2 (sizebuf_t *msg, struct model_s *model)
{
	int		ent;
	vec3_t	start, end, offset;
	beam_t	*b;
	int		i;
	
	ent = MSG_ReadShort (msg);
	
	MSG_ReadPos (msg, start);
	MSG_ReadPos (msg, end);
	MSG_ReadPos (msg, 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;
}
示例#9
0
 /* ========================================================================= */
 q_int32_t
 CL_ParseLightning ( struct model_s *model )
 {
   q_int32_t srcEnt, destEnt;
   vec3_t start, end;
   beam_t *b;
   q_int32_t i;
   srcEnt = MSG_ReadShort ( &net_message );
   destEnt = MSG_ReadShort ( &net_message );
   MSG_ReadPos ( &net_message, start );
   MSG_ReadPos ( &net_message, end );

   /* override any beam with the same
      source AND destination entities */
   for ( i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++ ) {
     if ( ( b->entity == srcEnt ) && ( b->dest_entity == destEnt ) ) {
       b->entity = srcEnt;
       b->dest_entity = destEnt;
       b->model = model;
       b->endtime = cl.time + 200;
       VectorCopy ( start, b->start );
       VectorCopy ( end, b->end );
       VectorClear ( b->offset );
       return srcEnt;
     }
   }

   /* find a free beam */
   for ( i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++ ) {
     if ( !b->model || ( b->endtime < cl.time ) ) {
       b->entity = srcEnt;
       b->dest_entity = destEnt;
       b->model = model;
       b->endtime = cl.time + 200;
       VectorCopy ( start, b->start );
       VectorCopy ( end, b->end );
       VectorClear ( b->offset );
       return srcEnt;
     }
   }

   Com_Printf ( "beam list overflow!\n" );
   return srcEnt;
 }
示例#10
0
 /* ========================================================================= */
 void
 CL_ParseParticles ( void )
 {
   q_int32_t 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 );
 }
示例#11
0
// Psychspaz's enhanced particles
void CL_ParseLaser (int32_t colors)
{
	vec3_t start,end;
	vec3_t		move;
	vec3_t		vec;
	vec3_t		point;
	float		len;
	float		dec;

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

	VectorSubtract (end, start, vec);
	len = VectorNormalize (vec);

	VectorCopy (vec, point);
	dec = 20;
	VectorScale (vec, dec, vec);
	VectorCopy (start, move);

	while (len > 0)
	{
		len -= dec;

		CL_SetupParticle (
			point[0],	point[1],	point[2],
			move[0],	move[1],	move[2],
			0,	0,	0,
			0,		0,		0,
			50,	255,	50,
			0,	0,	0,
			1,		-2.5,
			GL_SRC_ALPHA, GL_ONE,
			dec*TWOTHIRDS,		0,			
			particle_beam,
			PART_DIRECTION,
			NULL,0);

		VectorAdd (move, vec, move);
	}
}
示例#12
0
 /* ========================================================================= */
 void
 CL_ParseBeam2 ( struct model_s *model )
 {
   q_int32_t ent;
   vec3_t start, end, offset;
   beam_t *b;
   q_int32_t 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;
     }
   }

   /* 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;
     }
   }

   Com_Printf ( "beam list overflow!\n" );
   return;
 }
示例#13
0
 /* ========================================================================= */
 void
 CL_ParseLaser ( q_int32_t colors )
 {
   vec3_t start;
   vec3_t end;
   laser_t *l;
   q_int32_t 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.30f;
       l->ent.skinnum = ( colors >> ( ( randk() % 4 ) * 8 ) ) & 0xff;
       l->ent.model = NULL;
       l->ent.frame = 4;
       l->endtime = cl.time + 100;
       return;
     }
   }
示例#14
0
//=============
//ROGUE
void CL_ParseSteam (void)
{
	vec3_t	pos, dir;
	int32_t		id, i;
	int32_t		r;
	int32_t		cnt;
	int32_t		color;
	int32_t		magnitude;
	cl_sustain_t	*s, *free_sustain;

	id = MSG_ReadShort (&net_message);		// an id of -1 is an instant effect
	if (id != -1) // sustains
	{
		//Com_Printf ("Sustain effect id %d\n", id);
		free_sustain = NULL;
		for (i=0, s=cl_sustains; i<MAX_SUSTAINS; i++, s++)
		{
			if (s->id == 0)
			{
				free_sustain = s;
				break;
			}
		}
		if (free_sustain)
		{
			s->id = id;
			s->count = MSG_ReadByte (&net_message);
			MSG_ReadPos (&net_message, s->org);
			MSG_ReadDir (&net_message, s->dir);
			r = MSG_ReadByte (&net_message);
			s->color = r & 0xff;
			s->magnitude = MSG_ReadShort (&net_message);
			s->endtime = cl.time + MSG_ReadLong (&net_message);
			s->think = CL_ParticleSteamEffect2;
			s->thinkinterval = 100;
			s->nextthink = cl.time;
		}
		else
		{
			//Com_Printf ("No free sustains!\n");
			// FIXME - read the stuff anyway
			cnt = MSG_ReadByte (&net_message);
			MSG_ReadPos (&net_message, pos);
			MSG_ReadDir (&net_message, dir);
			r = MSG_ReadByte (&net_message);
			magnitude = MSG_ReadShort (&net_message);
			magnitude = MSG_ReadLong (&net_message); // really interval
		}
	}
	else // instant
	{
		cnt = MSG_ReadByte (&net_message);
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		r = MSG_ReadByte (&net_message);
		magnitude = MSG_ReadShort (&net_message);
		color = r & 0xff;
		CL_ParticleSteamEffect (pos, dir,
			color8red(color), color8green(color), color8blue(color),
			-20, -20, -20, cnt, magnitude);
		//CL_ParticleSteamEffect (pos, dir, 240, 240, 240, -20, -20, -20, cnt, magnitude);
		//S_StartSound (pos,  0, 0, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
	}
}
示例#15
0
/*
==================
CL_ParseDelta

Can go from either a baseline or a previous packet_entity
==================
*/
void CL_ParseDelta (entity_state_t *from, entity_state_t *to, int number, int bits)
{
	// set everything to the state we are delta'ing from
	*to = *from;

	VectorCopy(from->origin, to->old_origin);
	to->number = number;

	if (bits & U_MODEL)
		to->modelindex = MSG_ReadByte(&net_message);

	if (bits & U_MODEL2)
		to->modelindex2 = MSG_ReadByte(&net_message);

	if (bits & U_MODEL3)
		to->modelindex3 = MSG_ReadByte(&net_message);

	if (bits & U_MODEL4)
		to->modelindex4 = MSG_ReadByte(&net_message);
		
	if (bits & U_FRAME8)
		to->frame = MSG_ReadByte(&net_message);

	if (bits & U_FRAME16)
		to->frame = MSG_ReadShort(&net_message);

	assert(to->skinnum >= 0); // jitdebug

	if ((bits & U_SKIN8) && (bits & U_SKIN16))		//used for laser colors
		to->skinnum = MSG_ReadLong(&net_message);
	else if (bits & U_SKIN8)
		to->skinnum = MSG_ReadByte(&net_message);
	else if (bits & U_SKIN16)
		to->skinnum = MSG_ReadShort(&net_message);

	assert(to->skinnum >= 0);

	if ((bits & (U_EFFECTS8|U_EFFECTS16)) == (U_EFFECTS8|U_EFFECTS16))
		to->effects = MSG_ReadLong(&net_message);
	else if (bits & U_EFFECTS8)
		to->effects = MSG_ReadByte(&net_message);
	else if (bits & U_EFFECTS16)
		to->effects = MSG_ReadShort(&net_message);

	if ((bits & (U_RENDERFX8|U_RENDERFX16)) == (U_RENDERFX8|U_RENDERFX16))
		to->renderfx = MSG_ReadLong(&net_message);
	else if (bits & U_RENDERFX8)
		to->renderfx = MSG_ReadByte(&net_message);
	else if (bits & U_RENDERFX16)
		to->renderfx = MSG_ReadShort(&net_message);

	if (bits & U_ORIGIN1)
		to->origin[0] = MSG_ReadCoord(&net_message);

	if (bits & U_ORIGIN2)
		to->origin[1] = MSG_ReadCoord(&net_message);

	if (bits & U_ORIGIN3)
		to->origin[2] = MSG_ReadCoord(&net_message);
		
	if (bits & U_ANGLE1)
		to->angles[0] = MSG_ReadAngle(&net_message);

	if (bits & U_ANGLE2)
		to->angles[1] = MSG_ReadAngle(&net_message);

	if (bits & U_ANGLE3)
		to->angles[2] = MSG_ReadAngle(&net_message);

	if (bits & U_OLDORIGIN)
		MSG_ReadPos(&net_message, to->old_origin);

	if (bits & U_SOUND)
		to->sound = MSG_ReadByte(&net_message);

	if (bits & U_EVENT)
		to->event = MSG_ReadByte(&net_message);
	else
		to->event = 0;

	if (bits & U_SOLID)
		to->solid = MSG_ReadShort(&net_message);
}
示例#16
0
void CL_ParseTEnt (void)
{
	int32_t		type;
	vec3_t	pos, pos2, dir;
	explosion_t	*ex;
	int32_t		cnt;
	int32_t		color;
	int32_t		r, i;
	int32_t		ent;
	int32_t		magnitude;

	type = MSG_ReadByte (&net_message);

	switch (type)
	{
	case TE_BLOOD:			// bullet hitting flesh
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
	// Psychospaz's enhanced particle code
		CL_BloodHit (pos, dir);
		break;

	case TE_GUNSHOT:			// bullet hitting wall
	case TE_SPARKS:
	case TE_BULLET_SPARKS:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
	// Psychospaz's enhanced particle code
		if (type == TE_BULLET_SPARKS)
			VectorScale(dir, 2, dir);
		{
			vec3_t color = { 255, 125, 10 };
			CL_ParticleEffectSparks (pos, dir, color, (type == TE_GUNSHOT)? 5 : 10);
		}

		if (type != TE_SPARKS)
		{
			CL_GunSmokeEffect (pos, dir);
			if (type == TE_GUNSHOT || type == TE_BULLET_SPARKS)
				CL_ParticleBulletDecal(pos, dir, 2.5);
			// impact sound
			cnt = rand()&15;
			if (cnt == 1)
				S_StartSound (pos, 0, 0, clMedia.sfx_ric[0], 1, ATTN_NORM, 0);
			else if (cnt == 2)
				S_StartSound (pos, 0, 0, clMedia.sfx_ric[1], 1, ATTN_NORM, 0);
			else if (cnt == 3)
				S_StartSound (pos, 0, 0, clMedia.sfx_ric[2], 1, ATTN_NORM, 0);
		}
		break;
				
	case TE_SHOTGUN:			// bullet hitting wall
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
	// Psychospaz's enhanced particle code
		CL_GunSmokeEffect (pos, dir);
		CL_ParticleBulletDecal(pos, dir, 2.8);
		{
			vec3_t color = { 200, 100, 10 };
			CL_ParticleEffectSparks (pos, dir, color, 8);
		}
		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, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
		break;

	case TE_SPLASH:			// bullet hitting water
		cnt = MSG_ReadByte (&net_message);
		cnt = min(cnt, 40); // cap at 40
		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];
		// Psychospaz's enhanced particle code
		if (r == SPLASH_SPARKS)
		{
			CL_ParticleEffectSplashSpark (pos, dir, color, cnt);
			r = rand() & 3;
			if (r == 0)
				S_StartSound (pos, 0, 0, clMedia.sfx_spark[0], 1, ATTN_STATIC, 0);
			else if (r == 1)
				S_StartSound (pos, 0, 0, clMedia.sfx_spark[1], 1, ATTN_STATIC, 0);
			else
				S_StartSound (pos, 0, 0, clMedia.sfx_spark[2], 1, ATTN_STATIC, 0);
		} else {
			CL_ParticleEffectSplash (pos, dir, color, cnt);
		}
		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_RAILTRAIL:			// railgun effect
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_RailTrail (pos, pos2, false);
		S_StartSound (pos2, 0, 0, clMedia.sfx_railg, 1, ATTN_NORM, 0);
		break;
	// 12/23/2001 - red railgun trail
	case TE_RAILTRAIL2:			// red railgun effect
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_RailTrail (pos, pos2, true);
		S_StartSound (pos2, 0, 0, clMedia.sfx_railg, 1, ATTN_NORM, 0);
		break;

	case TE_EXPLOSION2:
	case TE_GRENADE_EXPLOSION:
	case TE_GRENADE_EXPLOSION_WATER:
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT|RF_NOSHADOW; // noshadow flag
		ex->start = cl.frame.servertime - 100;
		ex->light = 350;
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.5;
		ex->ent.model = clMedia.mod_explo;
		ex->frames = 19;
		ex->baseframe = 30;
		ex->ent.angles[1] = rand() % 360;
		CL_Explosion_Sparks (pos, 16, 128);
		if (type != TE_EXPLOSION2)
			CL_Explosion_Decal (pos, 50, particle_burnmark);
		if (type == TE_GRENADE_EXPLOSION_WATER)
			S_StartSound (pos, 0, 0, clMedia.sfx_watrexp, 1, ATTN_NORM, 0);
		else
			S_StartSound (pos, 0, 0, clMedia.sfx_grenexp, 1, ATTN_NORM, 0);
		break;

		// RAFAEL
	case TE_PLASMA_EXPLOSION:
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT|RF_NOSHADOW; // noshadow flag
		ex->start = cl.frame.servertime - 100;
		ex->light = 350;
		ex->lightcolor[0] = 1.0; 
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.5;
		ex->ent.angles[1] = rand() % 360;
		ex->ent.model = clMedia.mod_explo;
		if (frand() < 0.5)
			ex->baseframe = 15;
		ex->frames = 15;
		CL_Explosion_Sparks (pos, 16, 128);
		CL_Explosion_Decal (pos, 50, particle_burnmark);
		if (cl_plasma_explo_sound->value)
			S_StartSound (pos, 0, 0, clMedia.sfx_plasexp, 1, ATTN_NORM, 0);
		else
			S_StartSound (pos, 0, 0, clMedia.sfx_rockexp, 1, ATTN_NORM, 0);
		break;

	case TE_EXPLOSION1_BIG:						// PMM
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT|RF_NOSHADOW; // noshadow flag
		ex->start = cl.frame.servertime - 100;
		ex->light = 350;
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.5;
		ex->ent.angles[1] = rand() % 360;
		ex->ent.model = clMedia.mod_explo_big;
		if (frand() < 0.5)
			ex->baseframe = 15;
		ex->frames = 15;
		CL_Explosion_Sparks (pos, 48, 128);
		S_StartSound (pos, 0, 0, clMedia.sfx_rockexp, 1, ATTN_NORM, 0);
		break;

	case TE_EXPLOSION1_NP:						// PMM
		MSG_ReadPos (&net_message, pos);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->type = ex_poly;
		ex->ent.flags = RF_FULLBRIGHT|RF_NOSHADOW; // noshadow flag
		ex->start = cl.frame.servertime - 100;
		ex->light = 350;
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.5;
		ex->ent.angles[1] = rand() % 360;
		ex->ent.model = clMedia.mod_explo;
		if (frand() < 0.5)
			ex->baseframe = 15;
		ex->frames = 15;
		CL_Explosion_Sparks (pos, 10, 128);
		S_StartSound (pos, 0, 0, clMedia.sfx_grenexp, 1, ATTN_NORM, 0);
		break;

	case TE_EXPLOSION1:
	case TE_PLAIN_EXPLOSION:
	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|RF_NOSHADOW; // noshadow flag
		ex->start = cl.frame.servertime - 100;
		ex->light = 350;
		ex->lightcolor[0] = 1.0;
		ex->lightcolor[1] = 0.5;
		ex->lightcolor[2] = 0.5;
		ex->ent.angles[1] = rand() % 360;
		ex->ent.model = clMedia.mod_explo;
		if (frand() < 0.5)
			ex->baseframe = 15;
		ex->frames = 15;
		CL_Explosion_Sparks (pos, 16, 128);
		if (type == TE_ROCKET_EXPLOSION || type == TE_ROCKET_EXPLOSION_WATER)
			CL_Explosion_Decal (pos, 50, particle_burnmark);
		if (type == TE_ROCKET_EXPLOSION_WATER)
			S_StartSound (pos, 0, 0, clMedia.sfx_watrexp, 1, ATTN_NORM, 0);
		else
			S_StartSound (pos, 0, 0, clMedia.sfx_rockexp, 1, ATTN_NORM, 0);
		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 - 100;
		ex->light = 350;
		ex->lightcolor[0] = 0.0;
		ex->lightcolor[1] = 1.0;
		ex->lightcolor[2] = 0.0;
		ex->ent.model = clMedia.mod_bfg_explo;
		ex->ent.flags |= RF_TRANSLUCENT | RF_TRANS_ADDITIVE;
		ex->ent.alpha = 0.30;
		ex->frames = 4;
		break;

	case TE_BFG_BIGEXPLOSION:
		MSG_ReadPos (&net_message, pos);
		CL_BFGExplosionParticles (pos);
		CL_Explosion_Decal (pos, 75, particle_bfgmark);
		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 (clMedia.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 (clMedia.mod_grapple_cable);
		break;

	// RAFAEL
	case TE_WELDING_SPARKS:
		cnt = MSG_ReadByte (&net_message);
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		color = MSG_ReadByte (&net_message);
	// Psychospaz's enhanced particle code
		{
			vec3_t sparkcolor = {color8red(color), color8green(color), color8blue(color)};
			CL_ParticleEffectSparks (pos, dir, sparkcolor, 40);
		}
		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 = clMedia.mod_flash;
		ex->frames = 2;
		break;

	case TE_GREENBLOOD:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
	// Psychospaz's enhanced particle code
		CL_GreenBloodHit (pos, dir);
		break;

	// RAFAEL
	case TE_TUNNEL_SPARKS:
		cnt = MSG_ReadByte (&net_message);
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		color = MSG_ReadByte (&net_message);
		CL_ParticleEffect3 (pos, dir, color, cnt);
		break;

//=============
//PGM
	// PMM -following code integrated for flechette (different color)
	case TE_BLASTER:			// blaster hitting wall
	case TE_BLASTER2:			// green blaster hitting wall
	case TE_BLUEHYPERBLASTER:	// blue blaster hitting wall
	case TE_REDBLASTER:			// red blaster hitting wall
	case TE_FLECHETTE:			// flechette hitting wall
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		ex = CL_AllocExplosion ();
		VectorCopy (pos, ex->ent.origin);
		ex->ent.angles[0] = acos(dir[2])/M_PI*180;
		if (dir[0]) // PMM - fixed to correct for pitch of 0
			ex->ent.angles[1] = atan2(dir[1], dir[0])/M_PI*180;
		else if (dir[1] > 0)
			ex->ent.angles[1] = 90;
		else if (dir[1] < 0)
			ex->ent.angles[1] = 270;
		else
			ex->ent.angles[1] = 0;

		ex->type = ex_misc;
		ex->ent.flags |= RF_FULLBRIGHT|RF_TRANSLUCENT|RF_NOSHADOW; // no shadow on these

		if (type == TE_BLASTER2)
			ex->ent.skinnum = 1;
		else if (type == TE_REDBLASTER)
			ex->ent.skinnum = 3;
		else if (type == TE_FLECHETTE || type == TE_BLUEHYPERBLASTER)
			ex->ent.skinnum = 2;
		else // TE_BLASTER
			ex->ent.skinnum = 0;

		ex->start = cl.frame.servertime - 100;
		ex->light = 150;

		if (type == TE_BLASTER2) {
			ex->lightcolor[0] = 0.15;
			ex->lightcolor[1] = 1;
			ex->lightcolor[2] = 0.15;
		}
		else if (type == TE_BLUEHYPERBLASTER) {
			ex->lightcolor[0] = 0.19;
			ex->lightcolor[1] = 0.41;
			ex->lightcolor[2] = 0.75;
		}
		else if (type == TE_REDBLASTER) {
			ex->lightcolor[0] = 0.75;
			ex->lightcolor[1] = 0.41;
			ex->lightcolor[2] = 0.19;
		}
		else if (type == TE_FLECHETTE) {
			ex->lightcolor[0] = 0.39;
			ex->lightcolor[1] = 0.61;
			ex->lightcolor[2] = 0.75;
		}
		else { // TE_BLASTER	
			ex->lightcolor[0] = 1;
			ex->lightcolor[1] = 1;
			ex->lightcolor[2] = 0;
		}

		ex->ent.model = clMedia.mod_explode;
		ex->frames = 4;
		
		// Psychospaz's enhanced particle code	
		{
			int32_t		red, green, blue, numparts;
			float	partsize = 4;
			numparts = (32 / max(cl_particle_scale->value/2, 1));
			if (type == TE_BLASTER2) {
				CL_BlasterParticles (pos, dir, numparts, partsize, 50, 235, 50, -10, 0, -10);
				red=50; green=235; blue=50; }
			else if (type == TE_BLUEHYPERBLASTER) {
				CL_BlasterParticles (pos, dir, numparts, partsize, 50, 50, 235, -10, 0, -10);
				red=50; green=50; blue=235; }
			else if (type == TE_REDBLASTER) {
				CL_BlasterParticles (pos, dir, numparts, partsize, 235, 50, 50, 0, -90, -30);
				red=235; green=50; blue=50; }
			else if (type == TE_FLECHETTE) {
 				CL_BlasterParticles (pos, dir, numparts, partsize, 100, 100, 195, -10, 0, -10);
				red=100; green=100; blue=195; }
			else { // TE_BLASTER
				CL_BlasterParticles (pos, dir, numparts, partsize, 255, 150, 50, 0, -90, -30); // was 40
				red=255; green=150; blue=50; }
			CL_ParticleBlasterDecal(pos, dir, 10, red, green, blue);
		}
		S_StartSound (pos,  0, 0, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
		break;

	// shockwave impact effect
	case TE_SHOCKSPLASH:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		// Spawn 5 rings
		for (i = 0; i < 5; i++)
		{
			ex = CL_AllocExplosion ();
			VectorMA (pos, 16.0*(i+1), dir, ex->ent.origin);
			vectoangles2(dir, ex->ent.angles);
			//VectorCopy (dir, ex->ent.angles);
			ex->type = ex_poly2;
			ex->ent.flags |= RF_FULLBRIGHT|RF_TRANSLUCENT|RF_NOSHADOW;
			ex->start = cl.frame.servertime - 100;

			ex->light = 75;
			ex->lightcolor[0] = 0.39;
			ex->lightcolor[1] = 0.61;
			ex->lightcolor[2] = 0.75;

			ex->ent.model = clMedia.mod_shocksplash;
			ex->ent.alpha = 0.70;
			ex->baseframe = 4-i;
			ex->frames = 4+i;
		}
		S_StartSound (pos,  0, 0, clMedia.sfx_shockhit, 1, ATTN_NONE, 0);
		break;

	case TE_LIGHTNING:
		// Psychospaz's enhanced particle code
		ent = CL_ParseLightning ();
		S_StartSound (NULL, ent, CHAN_WEAPON, clMedia.sfx_lightning, 1, ATTN_NORM, 0);
		break;

	case TE_DEBUGTRAIL:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_DebugTrail (pos, pos2);
		break;

	case TE_FLASHLIGHT:
		MSG_ReadPos(&net_message, pos);
		ent = MSG_ReadShort(&net_message);
		CL_Flashlight(ent, pos);
		break;

	case TE_FORCEWALL:
		MSG_ReadPos(&net_message, pos);
		MSG_ReadPos(&net_message, pos2);
		color = MSG_ReadByte (&net_message);
		CL_ForceWall(pos, pos2, color);
		break;

	case TE_HEATBEAM:
		ent = CL_ParsePlayerBeam (clMedia.mod_heatbeam);
		break;

	case TE_MONSTER_HEATBEAM:
		ent = CL_ParsePlayerBeam (clMedia.mod_monster_heatbeam);
		break;

	case TE_HEATBEAM_SPARKS:
		cnt = 50;
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		r = 8;
		magnitude = 60;
		CL_ParticleSteamEffect (pos, dir, 240, 240, 240, -20, -20, -20, cnt, magnitude);
		S_StartSound (pos,  0, 0, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
		break;
	
	case TE_HEATBEAM_STEAM:
		cnt = 20;
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
		magnitude = 60;
		CL_ParticleSteamEffect (pos, dir, 255, 150, 50, 0, -90, -30, cnt, magnitude);
		CL_ParticlePlasmaBeamDecal (pos, dir, 10); // added burnmark
		S_StartSound (pos,  0, 0, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
		break;

	case TE_STEAM:
		CL_ParseSteam();
		break;

	case TE_BUBBLETRAIL2:
		cnt = 3; // was 8
		MSG_ReadPos (&net_message, pos);
		MSG_ReadPos (&net_message, pos2);
		CL_BubbleTrail2 (pos, pos2, cnt);
		S_StartSound (pos,  0, 0, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
		break;

	case TE_MOREBLOOD:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
	// Psychospaz's enhanced particle code
		CL_BloodHit (pos, dir);
		CL_BloodHit (pos, dir);
		break;

	case TE_CHAINFIST_SMOKE:
		dir[0]=0; dir[1]=0; dir[2]=1;
		MSG_ReadPos(&net_message, pos);
	// Psychospaz's enhanced particle code
		CL_ParticleSmokeEffect (pos, dir, 8);
		break;

	case TE_ELECTRIC_SPARKS:
		MSG_ReadPos (&net_message, pos);
		MSG_ReadDir (&net_message, dir);
	// new blue electric sparks
		CL_ElectricParticles (pos, dir, 40);
		//FIXME : replace or remove this sound
		S_StartSound (pos, 0, 0, clMedia.sfx_lashit, 1, ATTN_NORM, 0);
		break;

	case TE_TRACKER_EXPLOSION:
		MSG_ReadPos (&net_message, pos);
		CL_ColorFlash (pos, 0, 150, -1, -1, -1);
	//	CL_ColorExplosionParticles (pos, 0, 1);
		CL_Tracker_Explode (pos);
		CL_Explosion_Decal (pos, 14, particle_trackermark);
		S_StartSound (pos, 0, 0, clMedia.sfx_disrexp, 1, ATTN_NORM, 0);
		break;

	case TE_TELEPORT_EFFECT:
	case TE_DBALL_GOAL:
		MSG_ReadPos (&net_message, pos);
		CL_TeleportParticles (pos);
		break;

	case TE_WIDOWBEAMOUT:
		CL_ParseWidow ();
		break;

	case TE_NUKEBLAST:
		CL_ParseNuke ();
		break;

	case TE_WIDOWSPLASH:
		MSG_ReadPos (&net_message, pos);
		CL_WidowSplash (pos);
		break;
//PGM
//==============

	default:
		Com_Error (ERR_DROP, "CL_ParseTEnt: bad type");
	}
}
示例#17
0
sizebuf_t *SV_MulticastHook(sizebuf_t *original, sizebuf_t *ext)
{
	CVec3	v1, v2;
	const char *s;

	guard(SV_MulticastHook);

	original->BeginReading();

	// check for interesting messages
	if (MSG_ReadByte(original) != svc_temp_entity)
		return original;

	ext->Clear();
	byte cmd = MSG_ReadByte(original);
	switch (cmd)
	{
	case TE_RAILTRAIL:
		{
			MSG_ReadPos(original, v1);		// start
			MSG_ReadPos(original, v2);		// end

			client_t *cl = FindClient(v1, 18*18);
			int rType = 1;
			int rColor = 0;
			if (cl)
			{
				if (s = Info_ValueForKey(cl->Userinfo, "railcolor"))
				{
					rColor = atoi(s);
					rColor = bound(rColor, 0, 7);
				}
				if (s = Info_ValueForKey(cl->Userinfo, "railtype"))
				{
					rType = atoi(s);
					rType = bound(rType, 0, 3);
				}
			}
			if (!rType) return original;	// type==0 -> original rail trail

			MSG_WriteByte(ext, svc_temp_entity);
			MSG_WriteByte(ext, TE_RAILTRAIL_EXT);
			MSG_WritePos(ext, v1);
			MSG_WritePos(ext, v2);
			MSG_WriteByte(ext, rColor);
			MSG_WriteByte(ext, rType);
		}
		return ext;

	case TE_GUNSHOT:
	case TE_SPARKS:
	case TE_BULLET_SPARKS:
		{
			if (shotLevel != 2) return original;

			MSG_ReadPos(original, v1);
			MSG_ReadDir(original, v2);

			// compute reflection vector
//			appPrintf("sp: (%g %g %g) -> (%g %g %g)\n",VECTOR_ARG(v1),VECTOR_ARG(v2));//!!
			CVec3 d;
			VectorSubtract(shotStart, shotEnd, d);
			d.NormalizeFast();
			float back = dot(d, v2);
			for (int i = 0; i < 3; i++)
				v2[i] = d[i] - 2 * (d[i] - back * v2[i]);

			MSG_WriteByte(ext, svc_temp_entity);
			MSG_WriteByte(ext, cmd);
			MSG_WritePos(ext, v1);
			MSG_WriteDir(ext, v2);
		}
		return ext;

	case TE_SPLASH:
		{
			int count = MSG_ReadByte(original);
			MSG_ReadPos(original, v1);			// pos
			int tmp = MSG_ReadByte(original);	// dir
			int type = MSG_ReadByte(original);
			if (type != SPLASH_BLUE_WATER && type != SPLASH_BROWN_WATER)
				return original;			// not bullet effect

			// find splash origin in static map splashes to avoid bullethit sounds for waterfalls etc.
			for (const originInfo_t *spl = bspfile.splashes; spl; spl = spl->next)
			{
				if (fabs(spl->origin[0] - v1[0]) < 1 &&
					fabs(spl->origin[1] - v1[1]) < 1 &&
					fabs(spl->origin[2] - v1[2]) < 1)		// dir is quantized, so - make inprecisious compare
					return original;
			}

			//?? can add ripple effect on water, water smoke
			MSG_WriteByte(ext, svc_temp_entity);
			MSG_WriteByte(ext, TE_SPLASH);
			MSG_WriteByte(ext, count);
			MSG_WritePos(ext, v1);
			MSG_WriteByte(ext, tmp);
			MSG_WriteByte(ext, type - SPLASH_BLUE_WATER + SPLASH_BULLET_BLUE_WATER);
		}
		return ext;
	}

	return original;
	unguard;
}