cl_tent.c File Reference

#include "client.h"

Go to the source code of this file.

Classes
struct	explosion_t
struct	beam_t
struct	laser_t

Macros
#define	MAX_EXPLOSIONS   32
#define	MAX_BEAMS   32
#define	MAX_LASERS   32

Enumerations
enum	exptype_t {   ex_free, ex_explosion, ex_misc, ex_flash,   ex_mflash, ex_poly, ex_poly2 }

Functions
void	CL_TeleportParticles (vec3_t org)
void	CL_BlasterParticles (vec3_t org, vec3_t dir)
void	CL_ExplosionParticles (vec3_t org)
void	CL_BFGExplosionParticles (vec3_t org)
void	CL_BlueBlasterParticles (vec3_t org, vec3_t dir)
void	CL_RegisterTEntSounds (void)
void	CL_RegisterTEntModels (void)
void	CL_ClearTEnts (void)
explosion_t *	CL_AllocExplosion (void)
void	CL_SmokeAndFlash (vec3_t origin)
void	CL_ParseParticles (void)
int	CL_ParseBeam (struct model_s *model)
int	CL_ParseBeam2 (struct model_s *model)
int	CL_ParsePlayerBeam (struct model_s *model)
int	CL_ParseLightning (struct model_s *model)
void	CL_ParseLaser (int colors)
void	CL_ParseSteam (void)
void	CL_ParseWidow (void)
void	CL_ParseNuke (void)
void	CL_ParseTEnt (void)
void	CL_AddBeams (void)
void	CL_AddPlayerBeams (void)
void	CL_AddExplosions (void)
void	CL_AddLasers (void)
void	CL_ProcessSustain ()
void	CL_AddTEnts (void)

Variables
explosion_t	cl_explosions [MAX_EXPLOSIONS]
beam_t	cl_beams [MAX_BEAMS]
beam_t	cl_playerbeams [MAX_BEAMS]
laser_t	cl_lasers [MAX_LASERS]
cl_sustain_t	cl_sustains [MAX_SUSTAINS]
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_plasexp
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
struct model_s *	cl_mod_plasmaexplo
struct sfx_s *	cl_sfx_lightning
struct sfx_s *	cl_sfx_disrexp
struct model_s *	cl_mod_lightning
struct model_s *	cl_mod_heatbeam
struct model_s *	cl_mod_monster_heatbeam
struct model_s *	cl_mod_explo4_big
static byte	splash_color [] = {0x00, 0xe0, 0xb0, 0x50, 0xd0, 0xe0, 0xe8}
cvar_t *	hand

Macro Definition Documentation

MAX_BEAMS

#define MAX_BEAMS   32

Definition at line 47 of file cl_tent.c.

MAX_EXPLOSIONS

#define MAX_EXPLOSIONS   32

Definition at line 43 of file cl_tent.c.

MAX_LASERS

#define MAX_LASERS   32

Definition at line 62 of file cl_tent.c.

Enumeration Type Documentation

exptype_t

enum exptype_t

Enumerator
ex_free
ex_explosion
ex_misc
ex_flash
ex_mflash
ex_poly
ex_poly2

Definition at line 24 of file cl_tent.c.

{
    ex_free, ex_explosion, ex_misc, ex_flash, ex_mflash, ex_poly, ex_poly2
} exptype_t;

Function Documentation

CL_AddBeams()

void CL_AddBeams

(

void

)

Definition at line 1206 of file cl_tent.c.

{
    int         i,j;
    beam_t      *b;
    vec3_t      dist, org;
    float       d;
    entity_t    ent;
    float       yaw, pitch;
    float       forward;
    float       len, steps;
    float       model_length;
    
// 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
        {
    // PMM - fixed to correct for pitch of 0
            if (dist[0])
                yaw = (atan2(dist[1], dist[0]) * 180 / M_PI);
            else if (dist[1] > 0)
                yaw = 90;
            else
                yaw = 270;
            if (yaw < 0)
                yaw += 360;
    
            forward = sqrt (dist[0]*dist[0] + dist[1]*dist[1]);
            pitch = (atan2(dist[2], forward) * -180.0 / M_PI);
            if (pitch < 0)
                pitch += 360.0;
        }
 
    // add new entities for the beams
        d = VectorNormalize(dist);
 
        memset (&ent, 0, sizeof(ent));
        if (b->model == cl_mod_lightning)
        {
            model_length = 35.0;
            d-= 20.0;  // correction so it doesn't end in middle of tesla
        }
        else
        {
            model_length = 30.0;
        }
        steps = ceil(d/model_length);
        len = (d-model_length)/(steps-1);
 
        // PMM - special case for lightning model .. if the real length is shorter than the model,
        // flip it around & draw it from the end to the start.  This prevents the model from going
        // through the tesla mine (instead it goes through the target)
        if ((b->model == cl_mod_lightning) && (d <= model_length))
        {
//          Com_Printf ("special case\n");
            VectorCopy (b->end, ent.origin);
            // offset to push beam outside of tesla model (negative because dist is from end to start
            // for this beam)
//          for (j=0 ; j<3 ; j++)
//              ent.origin[j] -= dist[j]*10.0;
            ent.model = b->model;
            ent.flags = RF_FULLBRIGHT;
            ent.angles[0] = pitch;
            ent.angles[1] = yaw;
            ent.angles[2] = rand()%360;
            V_AddEntity (&ent);         
            return;
        }
        while (d > 0)
        {
            VectorCopy (org, ent.origin);
            ent.model = b->model;
            if (b->model == cl_mod_lightning)
            {
                ent.flags = RF_FULLBRIGHT;
                ent.angles[0] = -pitch;
                ent.angles[1] = yaw + 180.0;
                ent.angles[2] = rand()%360;
            }
            else
            {
                ent.angles[0] = pitch;
                ent.angles[1] = yaw;
                ent.angles[2] = rand()%360;
            }
            
//          Com_Printf("B: %d -> %d\n", b->entity, b->dest_entity);
            V_AddEntity (&ent);
 
            for (j=0 ; j<3 ; j++)
                org[j] += dist[j]*len;
            d -= model_length;
        }
    }
}

Referenced by CL_AddTEnts().

CL_AddExplosions()

void CL_AddExplosions

(

void

)

Definition at line 1596 of file cl_tent.c.

{
    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)/100.0;
        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;
        case ex_poly2:
            if (f >= ex->frames-1)
            {
                ex->type = ex_free;
                break;
            }
 
            ent->alpha = (5.0 - (float)f)/5.0;
            ent->skinnum = 0;
            ent->flags |= RF_TRANSLUCENT;
            break;
        default:
            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 (f < 0)
            f = 0;
        ent->frame = ex->baseframe + f + 1;
        ent->oldframe = ex->baseframe + f;
        ent->backlerp = 1.0 - cl.lerpfrac;
 
        V_AddEntity (ent);
    }
}

Referenced by CL_AddTEnts().

CL_AddLasers()

void CL_AddLasers

(

void

)

Definition at line 1702 of file cl_tent.c.

{
    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);
    }
}

Referenced by CL_AddTEnts().

CL_AddPlayerBeams()

void CL_AddPlayerBeams

(

void

)

Definition at line 1346 of file cl_tent.c.

{
    int         i,j;
    beam_t      *b;
    vec3_t      dist, org;
    float       d;
    entity_t    ent;
    float       yaw, pitch;
    float       forward;
    float       len, steps;
    int         framenum = 0;
    float       model_length;
    
    float       hand_multiplier;
    frame_t     *oldframe;
    player_state_t  *ps, *ops;
 
//PMM
    if (hand)
    {
        if (hand->value == 2)
            hand_multiplier = 0;
        else if (hand->value == 1)
            hand_multiplier = -1;
        else
            hand_multiplier = 1;
    }
    else 
    {
        hand_multiplier = 1;
    }
//PMM
 
// update beams
    for (i=0, b=cl_playerbeams ; i< MAX_BEAMS ; i++, b++)
    {
        vec3_t      f,r,u;
        if (!b->model || b->endtime < cl.time)
            continue;
 
        if(cl_mod_heatbeam && (b->model == cl_mod_heatbeam))
        {
 
            // if coming from the player, update the start position
            if (b->entity == cl.playernum+1)    // entity 0 is the world
            {   
                // set up gun position
                // code straight out of CL_AddViewWeapon
                ps = &cl.frame.playerstate;
                j = (cl.frame.serverframe - 1) & UPDATE_MASK;
                oldframe = &cl.frames[j];
                if (oldframe->serverframe != cl.frame.serverframe-1 || !oldframe->valid)
                    oldframe = &cl.frame;       // previous frame was dropped or involid
                ops = &oldframe->playerstate;
                for (j=0 ; j<3 ; j++)
                {
                    b->start[j] = cl.refdef.vieworg[j] + ops->gunoffset[j]
                        + cl.lerpfrac * (ps->gunoffset[j] - ops->gunoffset[j]);
                }
                VectorMA (b->start, (hand_multiplier * b->offset[0]), cl.v_right, org);
                VectorMA (     org, b->offset[1], cl.v_forward, org);
                VectorMA (     org, b->offset[2], cl.v_up, org);
                if ((hand) && (hand->value == 2)) {
                    VectorMA (org, -1, cl.v_up, org);
                }
                // FIXME - take these out when final
                VectorCopy (cl.v_right, r);
                VectorCopy (cl.v_forward, f);
                VectorCopy (cl.v_up, u);
 
            }
            else
                VectorCopy (b->start, org);
        }
        else
        {
            // 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);
 
//PMM
        if(cl_mod_heatbeam && (b->model == cl_mod_heatbeam) && (b->entity == cl.playernum+1))
        {
            vec_t len;
 
            len = VectorLength (dist);
            VectorScale (f, len, dist);
            VectorMA (dist, (hand_multiplier * b->offset[0]), r, dist);
            VectorMA (dist, b->offset[1], f, dist);
            VectorMA (dist, b->offset[2], u, dist);
            if ((hand) && (hand->value == 2)) {
                VectorMA (org, -1, cl.v_up, org);
            }
        }
//PMM
 
        if (dist[1] == 0 && dist[0] == 0)
        {
            yaw = 0;
            if (dist[2] > 0)
                pitch = 90;
            else
                pitch = 270;
        }
        else
        {
    // PMM - fixed to correct for pitch of 0
            if (dist[0])
                yaw = (atan2(dist[1], dist[0]) * 180 / M_PI);
            else if (dist[1] > 0)
                yaw = 90;
            else
                yaw = 270;
            if (yaw < 0)
                yaw += 360;
    
            forward = sqrt (dist[0]*dist[0] + dist[1]*dist[1]);
            pitch = (atan2(dist[2], forward) * -180.0 / M_PI);
            if (pitch < 0)
                pitch += 360.0;
        }
        
        if (cl_mod_heatbeam && (b->model == cl_mod_heatbeam))
        {
            if (b->entity != cl.playernum+1)
            {
                framenum = 2;
//              Com_Printf ("Third person\n");
                ent.angles[0] = -pitch;
                ent.angles[1] = yaw + 180.0;
                ent.angles[2] = 0;
//              Com_Printf ("%f %f - %f %f %f\n", -pitch, yaw+180.0, b->offset[0], b->offset[1], b->offset[2]);
                AngleVectors(ent.angles, f, r, u);
                    
                // if it's a non-origin offset, it's a player, so use the hardcoded player offset
                if (!VectorCompare (b->offset, vec3_origin))
                {
                    VectorMA (org, -(b->offset[0])+1, r, org);
                    VectorMA (org, -(b->offset[1]), f, org);
                    VectorMA (org, -(b->offset[2])-10, u, org);
                }
                else
                {
                    // if it's a monster, do the particle effect
                    CL_MonsterPlasma_Shell(b->start);
                }
            }
            else
            {
                framenum = 1;
            }
        }
 
        // if it's the heatbeam, draw the particle effect
        if ((cl_mod_heatbeam && (b->model == cl_mod_heatbeam) && (b->entity == cl.playernum+1)))
        {
            CL_Heatbeam (org, dist);
        }
 
    // add new entities for the beams
        d = VectorNormalize(dist);
 
        memset (&ent, 0, sizeof(ent));
        if (b->model == cl_mod_heatbeam)
        {
            model_length = 32.0;
        }
        else if (b->model == cl_mod_lightning)
        {
            model_length = 35.0;
            d-= 20.0;  // correction so it doesn't end in middle of tesla
        }
        else
        {
            model_length = 30.0;
        }
        steps = ceil(d/model_length);
        len = (d-model_length)/(steps-1);
 
        // PMM - special case for lightning model .. if the real length is shorter than the model,
        // flip it around & draw it from the end to the start.  This prevents the model from going
        // through the tesla mine (instead it goes through the target)
        if ((b->model == cl_mod_lightning) && (d <= model_length))
        {
//          Com_Printf ("special case\n");
            VectorCopy (b->end, ent.origin);
            // offset to push beam outside of tesla model (negative because dist is from end to start
            // for this beam)
//          for (j=0 ; j<3 ; j++)
//              ent.origin[j] -= dist[j]*10.0;
            ent.model = b->model;
            ent.flags = RF_FULLBRIGHT;
            ent.angles[0] = pitch;
            ent.angles[1] = yaw;
            ent.angles[2] = rand()%360;
            V_AddEntity (&ent);         
            return;
        }
        while (d > 0)
        {
            VectorCopy (org, ent.origin);
            ent.model = b->model;
            if(cl_mod_heatbeam && (b->model == cl_mod_heatbeam))
            {
//              ent.flags = RF_FULLBRIGHT|RF_TRANSLUCENT;
//              ent.alpha = 0.3;
                ent.flags = RF_FULLBRIGHT;
                ent.angles[0] = -pitch;
                ent.angles[1] = yaw + 180.0;
                ent.angles[2] = (cl.time) % 360;
//              ent.angles[2] = rand()%360;
                ent.frame = framenum;
            }
            else if (b->model == cl_mod_lightning)
            {
                ent.flags = RF_FULLBRIGHT;
                ent.angles[0] = -pitch;
                ent.angles[1] = yaw + 180.0;
                ent.angles[2] = rand()%360;
            }
            else
            {
                ent.angles[0] = pitch;
                ent.angles[1] = yaw;
                ent.angles[2] = rand()%360;
            }
            
//          Com_Printf("B: %d -> %d\n", b->entity, b->dest_entity);
            V_AddEntity (&ent);
 
            for (j=0 ; j<3 ; j++)
                org[j] += dist[j]*len;
            d -= model_length;
        }
    }
}

Referenced by CL_AddTEnts().

CL_AddTEnts()

void CL_AddTEnts

(

void

)

Definition at line 1738 of file cl_tent.c.

{
    CL_AddBeams ();
    // PMM - draw plasma beams
    CL_AddPlayerBeams ();
    CL_AddExplosions ();
    CL_AddLasers ();
    // PMM - set up sustain
    CL_ProcessSustain();
}

Referenced by CL_AddEntities().

CL_AllocExplosion()

explosion_t* CL_AllocExplosion

(

void

)

Definition at line 230 of file cl_tent.c.

{
    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];
}

Referenced by CL_ParseTEnt(), and CL_SmokeAndFlash().

CL_BFGExplosionParticles()

void CL_BFGExplosionParticles

(

vec3_t

org

)

Definition at line 2105 of file cl_fx.c.

{
    int         i, j;
    cparticle_t *p;
 
    for (i=0 ; i<256 ; i++)
    {
        if (!free_particles)
            return;
        p = free_particles;
        free_particles = p->next;
        p->next = active_particles;
        active_particles = p;
 
        p->time = cl.time;
        p->color = 0xd0 + (rand()&7);
 
        for (j=0 ; j<3 ; j++)
        {
            p->org[j] = org[j] + ((rand()%32)-16);
            p->vel[j] = (rand()%384)-192;
        }
 
        p->accel[0] = p->accel[1] = 0;
        p->accel[2] = -PARTICLE_GRAVITY;
        p->alpha = 1.0;
 
        p->alphavel = -0.8 / (0.5 + frand()*0.3);
    }
}

Referenced by CL_ParseTEnt().

CL_BlasterParticles()

void CL_BlasterParticles	(	vec3_t	org,
		vec3_t	dir
	)

Definition at line 1242 of file cl_fx.c.

{
    int         i, j;
    cparticle_t *p;
    float       d;
    int         count;
 
    count = 40;
    for (i=0 ; i<count ; i++)
    {
        if (!free_particles)
            return;
        p = free_particles;
        free_particles = p->next;
        p->next = active_particles;
        active_particles = p;
 
        p->time = cl.time;
        p->color = 0xe0 + (rand()&7);
 
        d = rand()&15;
        for (j=0 ; j<3 ; j++)
        {
            p->org[j] = org[j] + ((rand()&7)-4) + d*dir[j];
            p->vel[j] = dir[j] * 30 + crand()*40;
        }
 
        p->accel[0] = p->accel[1] = 0;
        p->accel[2] = -PARTICLE_GRAVITY;
        p->alpha = 1.0;
 
        p->alphavel = -1.0 / (0.5 + frand()*0.3);
    }
}

Referenced by CL_ParseTEnt().

CL_BlueBlasterParticles()

void CL_BlueBlasterParticles	(	vec3_t	org,
		vec3_t	dir
	)

CL_ClearTEnts()

void CL_ClearTEnts

(

void

)

Definition at line 213 of file cl_tent.c.

{
    memset (cl_beams, 0, sizeof(cl_beams));
    memset (cl_explosions, 0, sizeof(cl_explosions));
    memset (cl_lasers, 0, sizeof(cl_lasers));
 
//ROGUE
    memset (cl_playerbeams, 0, sizeof(cl_playerbeams));
    memset (cl_sustains, 0, sizeof(cl_sustains));
//ROGUE
}

Referenced by CL_ClearState().

CL_ExplosionParticles()

void CL_ExplosionParticles

(

vec3_t

org

)

Definition at line 1158 of file cl_fx.c.

{
    int         i, j;
    cparticle_t *p;
 
    for (i=0 ; i<256 ; i++)
    {
        if (!free_particles)
            return;
        p = free_particles;
        free_particles = p->next;
        p->next = active_particles;
        active_particles = p;
 
        p->time = cl.time;
        p->color = 0xe0 + (rand()&7);
 
        for (j=0 ; j<3 ; j++)
        {
            p->org[j] = org[j] + ((rand()%32)-16);
            p->vel[j] = (rand()%384)-192;
        }
 
        p->accel[0] = p->accel[1] = 0;
        p->accel[2] = -PARTICLE_GRAVITY;
        p->alpha = 1.0;
 
        p->alphavel = -0.8 / (0.5 + frand()*0.3);
    }
}

Referenced by CL_ParseTEnt().

CL_ParseBeam()

int CL_ParseBeam

(

struct model_s *

model

)

Definition at line 309 of file cl_tent.c.

{
    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;
}

Referenced by CL_ParseTEnt().

CL_ParseBeam2()

int CL_ParseBeam2

(

struct model_s *

model

)

Definition at line 357 of file cl_tent.c.

{
    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);
 
//  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;
}

Referenced by CL_ParseTEnt().

CL_ParseLaser()

void CL_ParseLaser

(

int

colors

)

Definition at line 528 of file cl_tent.c.

{
    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 + 100;
            return;
        }
    }
}

Referenced by CL_ParseTEnt().

CL_ParseLightning()

int CL_ParseLightning

(

struct model_s *

model

)

Definition at line 475 of file cl_tent.c.

{
    int     srcEnt, destEnt;
    vec3_t  start, end;
    beam_t  *b;
    int     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)
        {
//          Com_Printf("%d: OVERRIDE  %d -> %d\n", cl.time, srcEnt, 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)
        {
//          Com_Printf("%d: NORMAL  %d -> %d\n", cl.time, srcEnt, 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;
        }
    }
    Com_Printf ("beam list overflow!\n");   
    return srcEnt;
}

Referenced by CL_ParseTEnt().

CL_ParseNuke()

void CL_ParseNuke

(

void

)

Definition at line 652 of file cl_tent.c.

{
    vec3_t  pos;
    int     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);
    }
}

Referenced by CL_ParseTEnt().

CL_ParseParticles()

void CL_ParseParticles

(

void

)

Definition at line 289 of file cl_tent.c.

{
    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_ParsePlayerBeam()

int CL_ParsePlayerBeam

(

struct model_s *

model

)

Definition at line 411 of file cl_tent.c.

{
    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);
    // PMM - 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);
 
//  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;
}

Referenced by CL_ParseTEnt().

CL_ParseSteam()

void CL_ParseSteam

(

void

)

Definition at line 557 of file cl_tent.c.

{
    vec3_t  pos, dir;
    int     id, i;
    int     r;
    int     cnt;
    int     color;
    int     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, color, cnt, magnitude);
//      S_StartSound (pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
    }
}

Referenced by CL_ParseTEnt().

CL_ParseTEnt()

void CL_ParseTEnt

(

void

)

Definition at line 694 of file cl_tent.c.

{
    int     type;
    vec3_t  pos, pos2, dir;
    explosion_t *ex;
    int     cnt;
    int     color;
    int     r;
    int     ent;
    int     magnitude;
 
    type = MSG_ReadByte (&net_message);
 
    switch (type)
    {
    case TE_BLOOD:          // bullet hitting flesh
        MSG_ReadPos (&net_message, pos);
        MSG_ReadDir (&net_message, dir);
        CL_ParticleEffect (pos, dir, 0xe8, 60);
        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 (pos, dir, 0xe0, 6);
 
        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;
 
    // RAFAEL
    case TE_BLUEHYPERBLASTER:
        MSG_ReadPos (&net_message, pos);
        MSG_ReadPos (&net_message, dir);
        CL_BlasterParticles (pos, dir);
        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;
    // PMM - fixed to correct for pitch of 0
        if (dir[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;
        ex->start = cl.frame.servertime - 100;
        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_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;
        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 = cl_mod_explo4;
        ex->frames = 19;
        ex->baseframe = 30;
        ex->ent.angles[1] = rand() % 360;
        CL_ExplosionParticles (pos);
        if (type == TE_GRENADE_EXPLOSION_WATER)
            S_StartSound (pos, 0, 0, cl_sfx_watrexp, 1, ATTN_NORM, 0);
        else
            S_StartSound (pos, 0, 0, cl_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;
        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 = cl_mod_explo4;
        if (frand() < 0.5)
            ex->baseframe = 15;
        ex->frames = 15;
        CL_ExplosionParticles (pos);
        S_StartSound (pos, 0, 0, cl_sfx_rockexp, 1, ATTN_NORM, 0);
        break;
    
    case TE_EXPLOSION1:
    case TE_EXPLOSION1_BIG:                     // PMM
    case TE_ROCKET_EXPLOSION:
    case TE_ROCKET_EXPLOSION_WATER:
    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;
        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;
        if (type != TE_EXPLOSION1_BIG)              // PMM
            ex->ent.model = cl_mod_explo4;          // PMM
        else
            ex->ent.model = cl_mod_explo4_big;
        if (frand() < 0.5)
            ex->baseframe = 15;
        ex->frames = 15;
        if ((type != TE_EXPLOSION1_BIG) && (type != TE_EXPLOSION1_NP))      // PMM
            CL_ExplosionParticles (pos);                                    // PMM
        if (type == TE_ROCKET_EXPLOSION_WATER)
            S_StartSound (pos, 0, 0, cl_sfx_watrexp, 1, ATTN_NORM, 0);
        else
            S_StartSound (pos, 0, 0, cl_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 = 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;
 
    // 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);
        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, 0xdf, 30);
        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_BLASTER2:           // green blaster hitting wall
    case TE_FLECHETTE:          // flechette
        MSG_ReadPos (&net_message, pos);
        MSG_ReadDir (&net_message, dir);
        
        // PMM
        if (type == TE_BLASTER2)
            CL_BlasterParticles2 (pos, dir, 0xd0);
        else
            CL_BlasterParticles2 (pos, dir, 0x6f); // 75
 
        ex = CL_AllocExplosion ();
        VectorCopy (pos, ex->ent.origin);
        ex->ent.angles[0] = acos(dir[2])/M_PI*180;
    // PMM - fixed to correct for pitch of 0
        if (dir[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;
 
        // PMM
        if (type == TE_BLASTER2)
            ex->ent.skinnum = 1;
        else // flechette
            ex->ent.skinnum = 2;
 
        ex->start = cl.frame.servertime - 100;
        ex->light = 150;
        // PMM
        if (type == TE_BLASTER2)
            ex->lightcolor[1] = 1;
        else // flechette
        {
            ex->lightcolor[0] = 0.19;
            ex->lightcolor[1] = 0.41;
            ex->lightcolor[2] = 0.75;
        }
        ex->ent.model = cl_mod_explode;
        ex->frames = 4;
        S_StartSound (pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
        break;
 
 
    case TE_LIGHTNING:
        ent = CL_ParseLightning (cl_mod_lightning);
        S_StartSound (NULL, ent, CHAN_WEAPON, cl_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_PLAIN_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] = 1.0;
        ex->lightcolor[1] = 0.5;
        ex->lightcolor[2] = 0.5;
        ex->ent.angles[1] = rand() % 360;
        ex->ent.model = cl_mod_explo4;
        if (frand() < 0.5)
            ex->baseframe = 15;
        ex->frames = 15;
        if (type == TE_ROCKET_EXPLOSION_WATER)
            S_StartSound (pos, 0, 0, cl_sfx_watrexp, 1, ATTN_NORM, 0);
        else
            S_StartSound (pos, 0, 0, cl_sfx_rockexp, 1, ATTN_NORM, 0);
        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 (cl_mod_heatbeam);
        break;
 
    case TE_MONSTER_HEATBEAM:
        ent = CL_ParsePlayerBeam (cl_mod_monster_heatbeam);
        break;
 
    case TE_HEATBEAM_SPARKS:
//      cnt = MSG_ReadByte (&net_message);
        cnt = 50;
        MSG_ReadPos (&net_message, pos);
        MSG_ReadDir (&net_message, dir);
//      r = MSG_ReadByte (&net_message);
//      magnitude = MSG_ReadShort (&net_message);
        r = 8;
        magnitude = 60;
        color = r & 0xff;
        CL_ParticleSteamEffect (pos, dir, color, cnt, magnitude);
        S_StartSound (pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
        break;
    
    case TE_HEATBEAM_STEAM:
//      cnt = MSG_ReadByte (&net_message);
        cnt = 20;
        MSG_ReadPos (&net_message, pos);
        MSG_ReadDir (&net_message, dir);
//      r = MSG_ReadByte (&net_message);
//      magnitude = MSG_ReadShort (&net_message);
//      color = r & 0xff;
        color = 0xe0;
        magnitude = 60;
        CL_ParticleSteamEffect (pos, dir, color, cnt, magnitude);
        S_StartSound (pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
        break;
 
    case TE_STEAM:
        CL_ParseSteam();
        break;
 
    case TE_BUBBLETRAIL2:
//      cnt = MSG_ReadByte (&net_message);
        cnt = 8;
        MSG_ReadPos (&net_message, pos);
        MSG_ReadPos (&net_message, pos2);
        CL_BubbleTrail2 (pos, pos2, cnt);
        S_StartSound (pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
        break;
 
    case TE_MOREBLOOD:
        MSG_ReadPos (&net_message, pos);
        MSG_ReadDir (&net_message, dir);
        CL_ParticleEffect (pos, dir, 0xe8, 250);
        break;
 
    case TE_CHAINFIST_SMOKE:
        dir[0]=0; dir[1]=0; dir[2]=1;
        MSG_ReadPos(&net_message, pos);
        CL_ParticleSmokeEffect (pos, dir, 0, 20, 20);
        break;
 
    case TE_ELECTRIC_SPARKS:
        MSG_ReadPos (&net_message, pos);
        MSG_ReadDir (&net_message, dir);
//      CL_ParticleEffect (pos, dir, 109, 40);
        CL_ParticleEffect (pos, dir, 0x75, 40);
        //FIXME : replace or remove this sound
        S_StartSound (pos, 0, 0, cl_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);
        S_StartSound (pos, 0, 0, cl_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");
    }
}

Referenced by CL_ParseServerMessage().

CL_ParseWidow()

void CL_ParseWidow

(

void

)

Definition at line 619 of file cl_tent.c.

{
    vec3_t  pos;
    int     id, i;
    cl_sustain_t    *s, *free_sustain;
 
    id = MSG_ReadShort (&net_message);
 
    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;
        MSG_ReadPos (&net_message, s->org);
        s->endtime = cl.time + 2100;
        s->think = CL_Widowbeamout;
        s->thinkinterval = 1;
        s->nextthink = cl.time;
    }
    else // no free sustains
    {
        // FIXME - read the stuff anyway
        MSG_ReadPos (&net_message, pos);
    }
}

Referenced by CL_ParseTEnt().

CL_ProcessSustain()

void CL_ProcessSustain

(

)

Definition at line 1715 of file cl_tent.c.

{
    cl_sustain_t    *s;
    int             i;
 
    for (i=0, s=cl_sustains; i< MAX_SUSTAINS; i++, s++)
    {
        if (s->id)
            if ((s->endtime >= cl.time) && (cl.time >= s->nextthink))
            {
//              Com_Printf ("think %d %d %d\n", cl.time, s->nextthink, s->thinkinterval);
                s->think (s);
            }
            else if (s->endtime < cl.time)
                s->id = 0;
    }
}

Referenced by CL_AddTEnts().

CL_RegisterTEntModels()

void CL_RegisterTEntModels

(

void

)

Definition at line 172 of file cl_tent.c.

{
    cl_mod_explode = re.RegisterModel ("models/objects/explode/tris.md2");
    cl_mod_smoke = re.RegisterModel ("models/objects/smoke/tris.md2");
    cl_mod_flash = re.RegisterModel ("models/objects/flash/tris.md2");
    cl_mod_parasite_segment = re.RegisterModel ("models/monsters/parasite/segment/tris.md2");
    cl_mod_grapple_cable = re.RegisterModel ("models/ctf/segment/tris.md2");
    cl_mod_parasite_tip = re.RegisterModel ("models/monsters/parasite/tip/tris.md2");
    cl_mod_explo4 = re.RegisterModel ("models/objects/r_explode/tris.md2");
    cl_mod_bfg_explo = re.RegisterModel ("sprites/s_bfg2.sp2");
    cl_mod_powerscreen = re.RegisterModel ("models/items/armor/effect/tris.md2");
 
re.RegisterModel ("models/objects/laser/tris.md2");
re.RegisterModel ("models/objects/grenade2/tris.md2");
re.RegisterModel ("models/weapons/v_machn/tris.md2");
re.RegisterModel ("models/weapons/v_handgr/tris.md2");
re.RegisterModel ("models/weapons/v_shotg2/tris.md2");
re.RegisterModel ("models/objects/gibs/bone/tris.md2");
re.RegisterModel ("models/objects/gibs/sm_meat/tris.md2");
re.RegisterModel ("models/objects/gibs/bone2/tris.md2");
// RAFAEL
// re.RegisterModel ("models/objects/blaser/tris.md2");
 
re.RegisterPic ("w_machinegun");
re.RegisterPic ("a_bullets");
re.RegisterPic ("i_health");
re.RegisterPic ("a_grenades");
 
//ROGUE
    cl_mod_explo4_big = re.RegisterModel ("models/objects/r_explode2/tris.md2");
    cl_mod_lightning = re.RegisterModel ("models/proj/lightning/tris.md2");
    cl_mod_heatbeam = re.RegisterModel ("models/proj/beam/tris.md2");
    cl_mod_monster_heatbeam = re.RegisterModel ("models/proj/widowbeam/tris.md2");
//ROGUE
}   

Referenced by CL_PrepRefresh().

CL_RegisterTEntSounds()

void CL_RegisterTEntSounds

(

void

)

Definition at line 125 of file cl_tent.c.

{
    int     i;
    char    name[MAX_QPATH];
 
    // PMM - version stuff
//  Com_Printf ("%s\n", ROGUE_VERSION_STRING);
    // PMM
    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");
    // RAFAEL
    // cl_sfx_plasexp = S_RegisterSound ("weapons/plasexpl.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);
    }
 
//PGM
    cl_sfx_lightning = S_RegisterSound ("weapons/tesla.wav");
    cl_sfx_disrexp = S_RegisterSound ("weapons/disrupthit.wav");
    // version stuff
//  sprintf (name, "weapons/sound%d.wav", ROGUE_VERSION_ID);
//  if (name[0] == 'w')
//      name[0] = 'W';
//PGM
}   

Referenced by CL_RegisterSounds().

CL_SmokeAndFlash()

void CL_SmokeAndFlash

(

vec3_t

origin

)

Definition at line 263 of file cl_tent.c.

{
    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 - 100;
    ex->ent.model = cl_mod_smoke;
 
    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 - 100;
    ex->ent.model = cl_mod_flash;
}

Referenced by CL_ParseMuzzleFlash2(), and CL_ParseTEnt().

CL_TeleportParticles()

void CL_TeleportParticles

(

vec3_t

org

)

Definition at line 2143 of file cl_fx.c.

{
    int         i, j, k;
    cparticle_t *p;
    float       vel;
    vec3_t      dir;
 
    for (i=-16 ; i<=16 ; i+=4)
        for (j=-16 ; j<=16 ; j+=4)
            for (k=-16 ; k<=32 ; k+=4)
            {
                if (!free_particles)
                    return;
                p = free_particles;
                free_particles = p->next;
                p->next = active_particles;
                active_particles = p;
 
                p->time = cl.time;
                p->color = 7 + (rand()&7);
 
                p->alpha = 1.0;
                p->alphavel = -1.0 / (0.3 + (rand()&7) * 0.02);
                
                p->org[0] = org[0] + i + (rand()&3);
                p->org[1] = org[1] + j + (rand()&3);
                p->org[2] = org[2] + k + (rand()&3);
    
                dir[0] = j*8;
                dir[1] = i*8;
                dir[2] = k*8;
    
                VectorNormalize (dir);                      
                vel = 50 + (rand()&63);
                VectorScale (dir, vel, p->vel);
 
                p->accel[0] = p->accel[1] = 0;
                p->accel[2] = -PARTICLE_GRAVITY;
            }
}

Referenced by CL_EntityEvent(), and CL_ParseTEnt().

Variable Documentation

cl_beams

beam_t cl_beams[MAX_BEAMS]

Definition at line 57 of file cl_tent.c.

Referenced by CL_AddBeams(), CL_ClearTEnts(), CL_ParseBeam(), CL_ParseBeam2(), and CL_ParseLightning().

cl_explosions

explosion_t cl_explosions[MAX_EXPLOSIONS]

Definition at line 44 of file cl_tent.c.

Referenced by CL_AddExplosions(), CL_AllocExplosion(), and CL_ClearTEnts().

cl_lasers

laser_t cl_lasers[MAX_LASERS]

Definition at line 68 of file cl_tent.c.

Referenced by CL_AddLasers(), CL_ClearTEnts(), and CL_ParseLaser().

cl_mod_bfg_explo

struct model_s* cl_mod_bfg_explo

Definition at line 106 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_explo4

struct model_s* cl_mod_explo4

Definition at line 105 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_explo4_big

struct model_s* cl_mod_explo4_big

Definition at line 117 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_explode

struct model_s* cl_mod_explode

Definition at line 99 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_flash

struct model_s* cl_mod_flash

Definition at line 101 of file cl_tent.c.

Referenced by CL_ParseTEnt(), CL_RegisterTEntModels(), and CL_SmokeAndFlash().

cl_mod_grapple_cable

struct model_s* cl_mod_grapple_cable

Definition at line 103 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_heatbeam

struct model_s* cl_mod_heatbeam

Definition at line 115 of file cl_tent.c.

Referenced by CL_AddPlayerBeams(), CL_ParsePlayerBeam(), CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_lightning

struct model_s* cl_mod_lightning

Definition at line 114 of file cl_tent.c.

Referenced by CL_AddBeams(), CL_AddPlayerBeams(), CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_monster_heatbeam

struct model_s* cl_mod_monster_heatbeam

Definition at line 116 of file cl_tent.c.

Referenced by CL_ParsePlayerBeam(), CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_parasite_segment

struct model_s* cl_mod_parasite_segment

Definition at line 102 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntModels().

cl_mod_parasite_tip

struct model_s* cl_mod_parasite_tip

Definition at line 104 of file cl_tent.c.

Referenced by CL_RegisterTEntModels().

cl_mod_plasmaexplo

struct model_s* cl_mod_plasmaexplo

Definition at line 109 of file cl_tent.c.

cl_mod_powerscreen

struct model_s* cl_mod_powerscreen

Definition at line 107 of file cl_tent.c.

Referenced by CL_AddPacketEntities(), and CL_RegisterTEntModels().

cl_mod_smoke

struct model_s* cl_mod_smoke

Definition at line 100 of file cl_tent.c.

Referenced by CL_RegisterTEntModels(), and CL_SmokeAndFlash().

cl_playerbeams

beam_t cl_playerbeams[MAX_BEAMS]

Definition at line 59 of file cl_tent.c.

Referenced by CL_AddPlayerBeams(), CL_ClearTEnts(), and CL_ParsePlayerBeam().

cl_sfx_disrexp

struct sfx_s* cl_sfx_disrexp

Definition at line 113 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_footsteps

struct sfx_s* cl_sfx_footsteps[4]

Definition at line 97 of file cl_tent.c.

Referenced by CL_EntityEvent(), and CL_RegisterTEntSounds().

cl_sfx_grenexp

struct sfx_s* cl_sfx_grenexp

Definition at line 93 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_lashit

struct sfx_s* cl_sfx_lashit

Definition at line 87 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_lightning

struct sfx_s* cl_sfx_lightning

Definition at line 112 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_plasexp

struct sfx_s* cl_sfx_plasexp

Definition at line 96 of file cl_tent.c.

cl_sfx_railg

struct sfx_s* cl_sfx_railg

Definition at line 91 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_ric1

struct sfx_s* cl_sfx_ric1

Definition at line 84 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_ric2

struct sfx_s* cl_sfx_ric2

Definition at line 85 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_ric3

struct sfx_s* cl_sfx_ric3

Definition at line 86 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_rockexp

struct sfx_s* cl_sfx_rockexp

Definition at line 92 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_spark5

struct sfx_s* cl_sfx_spark5

Definition at line 88 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_spark6

struct sfx_s* cl_sfx_spark6

Definition at line 89 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_spark7

struct sfx_s* cl_sfx_spark7

Definition at line 90 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sfx_watrexp

struct sfx_s* cl_sfx_watrexp

Definition at line 94 of file cl_tent.c.

Referenced by CL_ParseTEnt(), and CL_RegisterTEntSounds().

cl_sustains

cl_sustain_t cl_sustains[MAX_SUSTAINS]

Definition at line 71 of file cl_tent.c.

Referenced by CL_ClearTEnts(), CL_ParseNuke(), CL_ParseSteam(), CL_ParseWidow(), and CL_ProcessSustain().

hand

cvar_t* hand

Definition at line 84 of file cl_main.c.

Referenced by CL_AddPlayerBeams(), CL_InitLocal(), and PlayerConfig_MenuInit().

splash_color

byte splash_color[] = {0x00, 0xe0, 0xb0, 0x50, 0xd0, 0xe0, 0xe8}

static

Definition at line 692 of file cl_tent.c.

Referenced by CL_ParseTEnt().