g_target.c File Reference

#include "g_local.h"

Go to the source code of this file.

Functions
void	Use_Target_Tent (edict_t *ent, edict_t *other, edict_t *activator)
void	SP_target_temp_entity (edict_t *ent)
void	Use_Target_Speaker (edict_t *ent, edict_t *other, edict_t *activator)
void	SP_target_speaker (edict_t *ent)
void	Use_Target_Help (edict_t *ent, edict_t *other, edict_t *activator)
void	SP_target_help (edict_t *ent)
void	use_target_secret (edict_t *ent, edict_t *other, edict_t *activator)
void	SP_target_secret (edict_t *ent)
void	use_target_goal (edict_t *ent, edict_t *other, edict_t *activator)
void	SP_target_goal (edict_t *ent)
void	target_explosion_explode (edict_t *self)
void	use_target_explosion (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_explosion (edict_t *ent)
void	use_target_changelevel (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_changelevel (edict_t *ent)
void	use_target_splash (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_splash (edict_t *self)
void	ED_CallSpawn (edict_t *ent)
void	use_target_spawner (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_spawner (edict_t *self)
void	use_target_blaster (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_blaster (edict_t *self)
void	trigger_crosslevel_trigger_use (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_crosslevel_trigger (edict_t *self)
void	target_crosslevel_target_think (edict_t *self)
void	SP_target_crosslevel_target (edict_t *self)
void	target_laser_think (edict_t *self)
void	target_laser_on (edict_t *self)
void	target_laser_off (edict_t *self)
void	target_laser_use (edict_t *self, edict_t *other, edict_t *activator)
void	target_laser_start (edict_t *self)
void	SP_target_laser (edict_t *self)
void	target_lightramp_think (edict_t *self)
void	target_lightramp_use (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_lightramp (edict_t *self)
void	target_earthquake_think (edict_t *self)
void	target_earthquake_use (edict_t *self, edict_t *other, edict_t *activator)
void	SP_target_earthquake (edict_t *self)

Function Documentation

ED_CallSpawn()

void ED_CallSpawn

(

edict_t *

ent

)

Definition at line 278 of file g_spawn.c.

{
    spawn_t *s;
    gitem_t *item;
    int     i;
 
    if (!ent->classname)
    {
        gi.dprintf ("ED_CallSpawn: NULL classname\n");
        return;
    }
 
    // check item spawn functions
    for (i=0,item=itemlist ; i<game.num_items ; i++,item++)
    {
        if (!item->classname)
            continue;
        if (!strcmp(item->classname, ent->classname))
        {   // found it
            SpawnItem (ent, item);
            return;
        }
    }
 
    // check normal spawn functions
    for (s=spawns ; s->name ; s++)
    {
        if (!strcmp(s->name, ent->classname))
        {   // found it
            s->spawn (ent);
            return;
        }
    }
    gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
}

Referenced by use_target_spawner().

SP_target_blaster()

void SP_target_blaster

(

edict_t *

self

)

Definition at line 431 of file g_target.c.

{
    self->use = use_target_blaster;
    G_SetMovedir (self->s.angles, self->movedir);
    self->noise_index = gi.soundindex ("weapons/laser2.wav");
 
    if (!self->dmg)
        self->dmg = 15;
    if (!self->speed)
        self->speed = 1000;
 
    self->svflags = SVF_NOCLIENT;
}

SP_target_changelevel()

void SP_target_changelevel

(

edict_t *

ent

)

Definition at line 302 of file g_target.c.

{
    if (!ent->map)
    {
        gi.dprintf("target_changelevel with no map at %s\n", vtos(ent->s.origin));
        G_FreeEdict (ent);
        return;
    }
 
    // ugly hack because *SOMEBODY* screwed up their map
   if((Q_stricmp(level.mapname, "fact1") == 0) && (Q_stricmp(ent->map, "fact3") == 0))
       ent->map = "fact3$secret1";
 
    ent->use = use_target_changelevel;
    ent->svflags = SVF_NOCLIENT;
}

SP_target_crosslevel_target()

void SP_target_crosslevel_target

(

edict_t *

self

)

Definition at line 478 of file g_target.c.

{
    if (! self->delay)
        self->delay = 1;
    self->svflags = SVF_NOCLIENT;
 
    self->think = target_crosslevel_target_think;
    self->nextthink = level.time + self->delay;
}

SP_target_crosslevel_trigger()

void SP_target_crosslevel_trigger

(

edict_t *

self

)

Definition at line 457 of file g_target.c.

{
    self->svflags = SVF_NOCLIENT;
    self->use = trigger_crosslevel_trigger_use;
}

SP_target_earthquake()

void SP_target_earthquake

(

edict_t *

self

)

Definition at line 793 of file g_target.c.

{
    if (!self->targetname)
        gi.dprintf("untargeted %s at %s\n", self->classname, vtos(self->s.origin));
 
    if (!self->count)
        self->count = 5;
 
    if (!self->speed)
        self->speed = 200;
 
    self->svflags |= SVF_NOCLIENT;
    self->think = target_earthquake_think;
    self->use = target_earthquake_use;
 
    self->noise_index = gi.soundindex ("world/quake.wav");
}

SP_target_explosion()

void SP_target_explosion

(

edict_t *

ent

)

Definition at line 258 of file g_target.c.

{
    ent->use = use_target_explosion;
    ent->svflags = SVF_NOCLIENT;
}

SP_target_goal()

void SP_target_goal

(

edict_t *

ent

)

Definition at line 202 of file g_target.c.

{
    if (deathmatch->value)
    {   // auto-remove for deathmatch
        G_FreeEdict (ent);
        return;
    }
 
    ent->use = use_target_goal;
    if (!st.noise)
        st.noise = "misc/secret.wav";
    ent->noise_index = gi.soundindex (st.noise);
    ent->svflags = SVF_NOCLIENT;
    level.total_goals++;
}

SP_target_help()

void SP_target_help

(

edict_t *

ent

)

Definition at line 131 of file g_target.c.

{
    if (deathmatch->value)
    {   // auto-remove for deathmatch
        G_FreeEdict (ent);
        return;
    }
 
    if (!ent->message)
    {
        gi.dprintf ("%s with no message at %s\n", ent->classname, vtos(ent->s.origin));
        G_FreeEdict (ent);
        return;
    }
    ent->use = Use_Target_Help;
}

SP_target_laser()

void SP_target_laser

(

edict_t *

self

)

Definition at line 642 of file g_target.c.

{
    // let everything else get spawned before we start firing
    self->think = target_laser_start;
    self->nextthink = level.time + 1;
}

SP_target_lightramp()

void SP_target_lightramp

(

edict_t *

self

)

Definition at line 715 of file g_target.c.

{
    if (!self->message || strlen(self->message) != 2 || self->message[0] < 'a' || self->message[0] > 'z' || self->message[1] < 'a' || self->message[1] > 'z' || self->message[0] == self->message[1])
    {
        gi.dprintf("target_lightramp has bad ramp (%s) at %s\n", self->message, vtos(self->s.origin));
        G_FreeEdict (self);
        return;
    }
 
    if (deathmatch->value)
    {
        G_FreeEdict (self);
        return;
    }
 
    if (!self->target)
    {
        gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
        G_FreeEdict (self);
        return;
    }
 
    self->svflags |= SVF_NOCLIENT;
    self->use = target_lightramp_use;
    self->think = target_lightramp_think;
 
    self->movedir[0] = self->message[0] - 'a';
    self->movedir[1] = self->message[1] - 'a';
    self->movedir[2] = (self->movedir[1] - self->movedir[0]) / (self->speed / FRAMETIME);
}

SP_target_secret()

void SP_target_secret

(

edict_t *

ent

)

Definition at line 164 of file g_target.c.

{
    if (deathmatch->value)
    {   // auto-remove for deathmatch
        G_FreeEdict (ent);
        return;
    }
 
    ent->use = use_target_secret;
    if (!st.noise)
        st.noise = "misc/secret.wav";
    ent->noise_index = gi.soundindex (st.noise);
    ent->svflags = SVF_NOCLIENT;
    level.total_secrets++;
    // map bug hack
    if (!Q_stricmp(level.mapname, "mine3") && ent->s.origin[0] == 280 && ent->s.origin[1] == -2048 && ent->s.origin[2] == -624)
        ent->message = "You have found a secret area.";
}

SP_target_spawner()

void SP_target_spawner

(

edict_t *

self

)

Definition at line 396 of file g_target.c.

{
    self->use = use_target_spawner;
    self->svflags = SVF_NOCLIENT;
    if (self->speed)
    {
        G_SetMovedir (self->s.angles, self->movedir);
        VectorScale (self->movedir, self->speed, self->movedir);
    }
}

SP_target_speaker()

void SP_target_speaker

(

edict_t *

ent

)

Definition at line 81 of file g_target.c.

{
    char    buffer[MAX_QPATH];
 
    if(!st.noise)
    {
        gi.dprintf("target_speaker with no noise set at %s\n", vtos(ent->s.origin));
        return;
    }
    if (!strstr (st.noise, ".wav"))
        Com_sprintf (buffer, sizeof(buffer), "%s.wav", st.noise);
    else
        strncpy (buffer, st.noise, sizeof(buffer));
    ent->noise_index = gi.soundindex (buffer);
 
    if (!ent->volume)
        ent->volume = 1.0;
 
    if (!ent->attenuation)
        ent->attenuation = 1.0;
    else if (ent->attenuation == -1)    // use -1 so 0 defaults to 1
        ent->attenuation = 0;
 
    // check for prestarted looping sound
    if (ent->spawnflags & 1)
        ent->s.sound = ent->noise_index;
 
    ent->use = Use_Target_Speaker;
 
    // must link the entity so we get areas and clusters so
    // the server can determine who to send updates to
    gi.linkentity (ent);
}

SP_target_splash()

void SP_target_splash

(

edict_t *

self

)

Definition at line 352 of file g_target.c.

{
    self->use = use_target_splash;
    G_SetMovedir (self->s.angles, self->movedir);
 
    if (!self->count)
        self->count = 32;
 
    self->svflags = SVF_NOCLIENT;
}

SP_target_temp_entity()

void SP_target_temp_entity

(

edict_t *

ent

)

Definition at line 34 of file g_target.c.

{
    ent->use = Use_Target_Tent;
}

target_crosslevel_target_think()

void target_crosslevel_target_think

(

edict_t *

self

)

Definition at line 469 of file g_target.c.

{
    if (self->spawnflags == (game.serverflags & SFL_CROSS_TRIGGER_MASK & self->spawnflags))
    {
        G_UseTargets (self, self);
        G_FreeEdict (self);
    }
}

Referenced by SP_target_crosslevel_target().

target_earthquake_think()

void target_earthquake_think

(

edict_t *

self

)

Definition at line 755 of file g_target.c.

{
    int     i;
    edict_t *e;
 
    if (self->last_move_time < level.time)
    {
        gi.positioned_sound (self->s.origin, self, CHAN_AUTO, self->noise_index, 1.0, ATTN_NONE, 0);
        self->last_move_time = level.time + 0.5;
    }
 
    for (i=1, e=g_edicts+i; i < globals.num_edicts; i++,e++)
    {
        if (!e->inuse)
            continue;
        if (!e->client)
            continue;
        if (!e->groundentity)
            continue;
 
        e->groundentity = NULL;
        e->velocity[0] += crandom()* 150;
        e->velocity[1] += crandom()* 150;
        e->velocity[2] = self->speed * (100.0 / e->mass);
    }
 
    if (level.time < self->timestamp)
        self->nextthink = level.time + FRAMETIME;
}

Referenced by SP_target_earthquake().

target_earthquake_use()

void target_earthquake_use	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 785 of file g_target.c.

{
    self->timestamp = level.time + self->count;
    self->nextthink = level.time + FRAMETIME;
    self->activator = activator;
    self->last_move_time = 0;
}

Referenced by SP_target_earthquake().

target_explosion_explode()

void target_explosion_explode

(

edict_t *

self

)

Definition at line 227 of file g_target.c.

{
    float       save;
 
    gi.WriteByte (svc_temp_entity);
    gi.WriteByte (TE_EXPLOSION1);
    gi.WritePosition (self->s.origin);
    gi.multicast (self->s.origin, MULTICAST_PHS);
 
    T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE);
 
    save = self->delay;
    self->delay = 0;
    G_UseTargets (self, self->activator);
    self->delay = save;
}

Referenced by use_target_explosion().

target_laser_off()

void target_laser_off

(

edict_t *

self

)

Definition at line 569 of file g_target.c.

{
    self->spawnflags &= ~1;
    self->svflags |= SVF_NOCLIENT;
    self->nextthink = 0;
}

Referenced by target_laser_start(), and target_laser_use().

target_laser_on()

void target_laser_on

(

edict_t *

self

)

Definition at line 560 of file g_target.c.

{
    if (!self->activator)
        self->activator = self;
    self->spawnflags |= 0x80000001;
    self->svflags &= ~SVF_NOCLIENT;
    target_laser_think (self);
}

Referenced by target_laser_start(), and target_laser_use().

target_laser_start()

void target_laser_start

(

edict_t *

self

)

Definition at line 585 of file g_target.c.

{
    edict_t *ent;
 
    self->movetype = MOVETYPE_NONE;
    self->solid = SOLID_NOT;
    self->s.renderfx |= RF_BEAM|RF_TRANSLUCENT;
    self->s.modelindex = 1;         // must be non-zero
 
    // set the beam diameter
    if (self->spawnflags & 64)
        self->s.frame = 16;
    else
        self->s.frame = 4;
 
    // set the color
    if (self->spawnflags & 2)
        self->s.skinnum = 0xf2f2f0f0;
    else if (self->spawnflags & 4)
        self->s.skinnum = 0xd0d1d2d3;
    else if (self->spawnflags & 8)
        self->s.skinnum = 0xf3f3f1f1;
    else if (self->spawnflags & 16)
        self->s.skinnum = 0xdcdddedf;
    else if (self->spawnflags & 32)
        self->s.skinnum = 0xe0e1e2e3;
 
    if (!self->enemy)
    {
        if (self->target)
        {
            ent = G_Find (NULL, FOFS(targetname), self->target);
            if (!ent)
                gi.dprintf ("%s at %s: %s is a bad target\n", self->classname, vtos(self->s.origin), self->target);
            self->enemy = ent;
        }
        else
        {
            G_SetMovedir (self->s.angles, self->movedir);
        }
    }
    self->use = target_laser_use;
    self->think = target_laser_think;
 
    if (!self->dmg)
        self->dmg = 1;
 
    VectorSet (self->mins, -8, -8, -8);
    VectorSet (self->maxs, 8, 8, 8);
    gi.linkentity (self);
 
    if (self->spawnflags & 1)
        target_laser_on (self);
    else
        target_laser_off (self);
}

Referenced by SP_target_laser().

target_laser_think()

void target_laser_think

(

edict_t *

self

)

Definition at line 495 of file g_target.c.

{
    edict_t *ignore;
    vec3_t  start;
    vec3_t  end;
    trace_t tr;
    vec3_t  point;
    vec3_t  last_movedir;
    int     count;
 
    if (self->spawnflags & 0x80000000)
        count = 8;
    else
        count = 4;
 
    if (self->enemy)
    {
        VectorCopy (self->movedir, last_movedir);
        VectorMA (self->enemy->absmin, 0.5, self->enemy->size, point);
        VectorSubtract (point, self->s.origin, self->movedir);
        VectorNormalize (self->movedir);
        if (!VectorCompare(self->movedir, last_movedir))
            self->spawnflags |= 0x80000000;
    }
 
    ignore = self;
    VectorCopy (self->s.origin, start);
    VectorMA (start, 2048, self->movedir, end);
    while(1)
    {
        tr = gi.trace (start, NULL, NULL, end, ignore, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_DEADMONSTER);
 
        if (!tr.ent)
            break;
 
        // hurt it if we can
        if ((tr.ent->takedamage) && !(tr.ent->flags & FL_IMMUNE_LASER))
            T_Damage (tr.ent, self, self->activator, self->movedir, tr.endpos, vec3_origin, self->dmg, 1, DAMAGE_ENERGY, MOD_TARGET_LASER);
 
        // if we hit something that's not a monster or player or is immune to lasers, we're done
        if (!(tr.ent->svflags & SVF_MONSTER) && (!tr.ent->client))
        {
            if (self->spawnflags & 0x80000000)
            {
                self->spawnflags &= ~0x80000000;
                gi.WriteByte (svc_temp_entity);
                gi.WriteByte (TE_LASER_SPARKS);
                gi.WriteByte (count);
                gi.WritePosition (tr.endpos);
                gi.WriteDir (tr.plane.normal);
                gi.WriteByte (self->s.skinnum);
                gi.multicast (tr.endpos, MULTICAST_PVS);
            }
            break;
        }
 
        ignore = tr.ent;
        VectorCopy (tr.endpos, start);
    }
 
    VectorCopy (tr.endpos, self->s.old_origin);
 
    self->nextthink = level.time + FRAMETIME;
}

Referenced by target_laser_on(), and target_laser_start().

target_laser_use()

void target_laser_use	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 576 of file g_target.c.

{
    self->activator = activator;
    if (self->spawnflags & 1)
        target_laser_off (self);
    else
        target_laser_on (self);
}

Referenced by target_laser_start().

target_lightramp_think()

void target_lightramp_think

(

edict_t *

self

)

Definition at line 656 of file g_target.c.

{
    char    style[2];
 
    style[0] = 'a' + self->movedir[0] + (level.time - self->timestamp) / FRAMETIME * self->movedir[2];
    style[1] = 0;
    gi.configstring (CS_LIGHTS+self->enemy->style, style);
 
    if ((level.time - self->timestamp) < self->speed)
    {
        self->nextthink = level.time + FRAMETIME;
    }
    else if (self->spawnflags & 1)
    {
        char    temp;
 
        temp = self->movedir[0];
        self->movedir[0] = self->movedir[1];
        self->movedir[1] = temp;
        self->movedir[2] *= -1;
    }
}

Referenced by SP_target_lightramp(), and target_lightramp_use().

target_lightramp_use()

void target_lightramp_use	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 679 of file g_target.c.

{
    if (!self->enemy)
    {
        edict_t     *e;
 
        // check all the targets
        e = NULL;
        while (1)
        {
            e = G_Find (e, FOFS(targetname), self->target);
            if (!e)
                break;
            if (strcmp(e->classname, "light") != 0)
            {
                gi.dprintf("%s at %s ", self->classname, vtos(self->s.origin));
                gi.dprintf("target %s (%s at %s) is not a light\n", self->target, e->classname, vtos(e->s.origin));
            }
            else
            {
                self->enemy = e;
            }
        }
 
        if (!self->enemy)
        {
            gi.dprintf("%s target %s not found at %s\n", self->classname, self->target, vtos(self->s.origin));
            G_FreeEdict (self);
            return;
        }
    }
 
    self->timestamp = level.time;
    target_lightramp_think (self);
}

Referenced by SP_target_lightramp().

trigger_crosslevel_trigger_use()

void trigger_crosslevel_trigger_use	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 451 of file g_target.c.

{
    game.serverflags |= self->spawnflags;
    G_FreeEdict (self);
}

Referenced by SP_target_crosslevel_trigger().

use_target_blaster()

void use_target_blaster	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 416 of file g_target.c.

{
    int effect;
 
    if (self->spawnflags & 2)
        effect = 0;
    else if (self->spawnflags & 1)
        effect = EF_HYPERBLASTER;
    else
        effect = EF_BLASTER;
 
    fire_blaster (self, self->s.origin, self->movedir, self->dmg, self->speed, EF_BLASTER, MOD_TARGET_BLASTER);
    gi.sound (self, CHAN_VOICE, self->noise_index, 1, ATTN_NORM, 0);
}

Referenced by SP_target_blaster().

use_target_changelevel()

void use_target_changelevel	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 270 of file g_target.c.

{
    if (level.intermissiontime)
        return;     // already activated
 
    if (!deathmatch->value && !coop->value)
    {
        if (g_edicts[1].health <= 0)
            return;
    }
 
    // if noexit, do a ton of damage to other
    if (deathmatch->value && !( (int)dmflags->value & DF_ALLOW_EXIT) && other != world)
    {
        T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, 10 * other->max_health, 1000, 0, MOD_EXIT);
        return;
    }
 
    // if multiplayer, let everyone know who hit the exit
    if (deathmatch->value)
    {
        if (activator && activator->client)
            gi.bprintf (PRINT_HIGH, "%s exited the level.\n", activator->client->pers.netname);
    }
 
    // if going to a new unit, clear cross triggers
    if (strstr(self->map, "*")) 
        game.serverflags &= ~(SFL_CROSS_TRIGGER_MASK);
 
    BeginIntermission (self);
}

Referenced by SP_target_changelevel().

use_target_explosion()

void use_target_explosion	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 244 of file g_target.c.

{
    self->activator = activator;
 
    if (!self->delay)
    {
        target_explosion_explode (self);
        return;
    }
 
    self->think = target_explosion_explode;
    self->nextthink = level.time + self->delay;
}

Referenced by SP_target_explosion().

use_target_goal()

void use_target_goal	(	edict_t *	ent,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 189 of file g_target.c.

{
    gi.sound (ent, CHAN_VOICE, ent->noise_index, 1, ATTN_NORM, 0);
 
    level.found_goals++;
 
    if (level.found_goals == level.total_goals)
        gi.configstring (CS_CDTRACK, "0");
 
    G_UseTargets (ent, activator);
    G_FreeEdict (ent);
}

Referenced by SP_target_goal().

Use_Target_Help()

void Use_Target_Help	(	edict_t *	ent,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 118 of file g_target.c.

{
    if (ent->spawnflags & 1)
        strncpy (game.helpmessage1, ent->message, sizeof(game.helpmessage2)-1);
    else
        strncpy (game.helpmessage2, ent->message, sizeof(game.helpmessage1)-1);
 
    game.helpchanged++;
}

Referenced by SP_target_help().

use_target_secret()

void use_target_secret	(	edict_t *	ent,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 154 of file g_target.c.

{
    gi.sound (ent, CHAN_VOICE, ent->noise_index, 1, ATTN_NORM, 0);
 
    level.found_secrets++;
 
    G_UseTargets (ent, activator);
    G_FreeEdict (ent);
}

Referenced by SP_target_secret().

use_target_spawner()

void use_target_spawner	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 380 of file g_target.c.

{
    edict_t *ent;
 
    ent = G_Spawn();
    ent->classname = self->target;
    VectorCopy (self->s.origin, ent->s.origin);
    VectorCopy (self->s.angles, ent->s.angles);
    ED_CallSpawn (ent);
    gi.unlinkentity (ent);
    KillBox (ent);
    gi.linkentity (ent);
    if (self->speed)
        VectorCopy (self->movedir, ent->velocity);
}

Referenced by SP_target_spawner().

Use_Target_Speaker()

void Use_Target_Speaker	(	edict_t *	ent,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 58 of file g_target.c.

{
    int     chan;
 
    if (ent->spawnflags & 3)
    {   // looping sound toggles
        if (ent->s.sound)
            ent->s.sound = 0;   // turn it off
        else
            ent->s.sound = ent->noise_index;    // start it
    }
    else
    {   // normal sound
        if (ent->spawnflags & 4)
            chan = CHAN_VOICE|CHAN_RELIABLE;
        else
            chan = CHAN_VOICE;
        // use a positioned_sound, because this entity won't normally be
        // sent to any clients because it is invisible
        gi.positioned_sound (ent->s.origin, ent, chan, ent->noise_index, ent->volume, ent->attenuation, 0);
    }
}

Referenced by SP_target_speaker().

use_target_splash()

void use_target_splash	(	edict_t *	self,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 338 of file g_target.c.

{
    gi.WriteByte (svc_temp_entity);
    gi.WriteByte (TE_SPLASH);
    gi.WriteByte (self->count);
    gi.WritePosition (self->s.origin);
    gi.WriteDir (self->movedir);
    gi.WriteByte (self->sounds);
    gi.multicast (self->s.origin, MULTICAST_PVS);
 
    if (self->dmg)
        T_RadiusDamage (self, activator, self->dmg, NULL, self->dmg+40, MOD_SPLASH);
}

Referenced by SP_target_splash().

Use_Target_Tent()

void Use_Target_Tent	(	edict_t *	ent,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 26 of file g_target.c.

{
    gi.WriteByte (svc_temp_entity);
    gi.WriteByte (ent->style);
    gi.WritePosition (ent->s.origin);
    gi.multicast (ent->s.origin, MULTICAST_PVS);
}

Referenced by SP_target_temp_entity().