g_monster.c File Reference

#include "g_local.h"

Go to the source code of this file.

Functions
void	monster_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype)
void	monster_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype)
void	monster_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect)
void	monster_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype)
void	monster_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype)
void	monster_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype)
void	monster_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype)
static void	M_FliesOff (edict_t *self)
static void	M_FliesOn (edict_t *self)
void	M_FlyCheck (edict_t *self)
void	AttackFinished (edict_t *self, float time)
void	M_CheckGround (edict_t *ent)
void	M_CatagorizePosition (edict_t *ent)
void	M_WorldEffects (edict_t *ent)
void	M_droptofloor (edict_t *ent)
void	M_SetEffects (edict_t *ent)
void	M_MoveFrame (edict_t *self)
void	monster_think (edict_t *self)
void	monster_use (edict_t *self, edict_t *other, edict_t *activator)
void	monster_start_go (edict_t *self)
void	monster_triggered_spawn (edict_t *self)
void	monster_triggered_spawn_use (edict_t *self, edict_t *other, edict_t *activator)
void	monster_triggered_start (edict_t *self)
void	monster_death_use (edict_t *self)
qboolean	monster_start (edict_t *self)
void	walkmonster_start_go (edict_t *self)
void	walkmonster_start (edict_t *self)
void	flymonster_start_go (edict_t *self)
void	flymonster_start (edict_t *self)
void	swimmonster_start_go (edict_t *self)
void	swimmonster_start (edict_t *self)

Function Documentation

AttackFinished()

void AttackFinished	(	edict_t *	self,
		float	time
	)

Definition at line 135 of file g_monster.c.

{
    self->monsterinfo.attack_finished = level.time + time;
}

Referenced by HuntTarget().

flymonster_start()

void flymonster_start

(

edict_t *

self

)

Definition at line 715 of file g_monster.c.

{
    self->flags |= FL_FLY;
    self->think = flymonster_start_go;
    monster_start (self);
}

Referenced by SP_misc_insane(), SP_monster_boss2(), SP_monster_floater(), SP_monster_flyer(), and SP_monster_hover().

flymonster_start_go()

void flymonster_start_go

(

edict_t *

self

)

Definition at line 699 of file g_monster.c.

{
    if (!M_walkmove (self, 0, 0))
        gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin));
 
    if (!self->yaw_speed)
        self->yaw_speed = 10;
    self->viewheight = 25;
 
    monster_start_go (self);
 
    if (self->spawnflags & 2)
        monster_triggered_start (self);
}

Referenced by flymonster_start().

M_CatagorizePosition()

void M_CatagorizePosition

(

edict_t *

ent

)

Definition at line 183 of file g_monster.c.

{
    vec3_t      point;
    int         cont;
 
//
// get waterlevel
//
    point[0] = ent->s.origin[0];
    point[1] = ent->s.origin[1];
    point[2] = ent->s.origin[2] + ent->mins[2] + 1; 
    cont = gi.pointcontents (point);
 
    if (!(cont & MASK_WATER))
    {
        ent->waterlevel = 0;
        ent->watertype = 0;
        return;
    }
 
    ent->watertype = cont;
    ent->waterlevel = 1;
    point[2] += 26;
    cont = gi.pointcontents (point);
    if (!(cont & MASK_WATER))
        return;
 
    ent->waterlevel = 2;
    point[2] += 22;
    cont = gi.pointcontents (point);
    if (cont & MASK_WATER)
        ent->waterlevel = 3;
}

Referenced by M_droptofloor(), and monster_think().

M_CheckGround()

void M_CheckGround

(

edict_t *

ent

)

Definition at line 141 of file g_monster.c.

{
    vec3_t      point;
    trace_t     trace;
 
    if (ent->flags & (FL_SWIM|FL_FLY))
        return;
 
    if (ent->velocity[2] > 100)
    {
        ent->groundentity = NULL;
        return;
    }
 
// if the hull point one-quarter unit down is solid the entity is on ground
    point[0] = ent->s.origin[0];
    point[1] = ent->s.origin[1];
    point[2] = ent->s.origin[2] - 0.25;
 
    trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_MONSTERSOLID);
 
    // check steepness
    if ( trace.plane.normal[2] < 0.7 && !trace.startsolid)
    {
        ent->groundentity = NULL;
        return;
    }
 
//  ent->groundentity = trace.ent;
//  ent->groundentity_linkcount = trace.ent->linkcount;
//  if (!trace.startsolid && !trace.allsolid)
//      VectorCopy (trace.endpos, ent->s.origin);
    if (!trace.startsolid && !trace.allsolid)
    {
        VectorCopy (trace.endpos, ent->s.origin);
        ent->groundentity = trace.ent;
        ent->groundentity_linkcount = trace.ent->linkcount;
        ent->velocity[2] = 0;
    }
}

Referenced by G_RunFrame(), M_droptofloor(), monster_think(), and SV_Physics_Step().

M_droptofloor()

void M_droptofloor

(

edict_t *

ent

)

Definition at line 310 of file g_monster.c.

{
    vec3_t      end;
    trace_t     trace;
 
    ent->s.origin[2] += 1;
    VectorCopy (ent->s.origin, end);
    end[2] -= 256;
    
    trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID);
 
    if (trace.fraction == 1 || trace.allsolid)
        return;
 
    VectorCopy (trace.endpos, ent->s.origin);
 
    gi.linkentity (ent);
    M_CheckGround (ent);
    M_CatagorizePosition (ent);
}

Referenced by SP_misc_explobox(), and walkmonster_start_go().

M_FliesOff()

static void M_FliesOff ( edict_t *  self )

static

Definition at line 107 of file g_monster.c.

{
    self->s.effects &= ~EF_FLIES;
    self->s.sound = 0;
}

Referenced by M_FliesOn().

M_FliesOn()

static void M_FliesOn ( edict_t *  self )

static

Definition at line 113 of file g_monster.c.

{
    if (self->waterlevel)
        return;
    self->s.effects |= EF_FLIES;
    self->s.sound = gi.soundindex ("infantry/inflies1.wav");
    self->think = M_FliesOff;
    self->nextthink = level.time + 60;
}

Referenced by M_FlyCheck().

M_FlyCheck()

void M_FlyCheck

(

edict_t *

self

)

Definition at line 123 of file g_monster.c.

{
    if (self->waterlevel)
        return;
 
    if (random() > 0.5)
        return;
 
    self->think = M_FliesOn;
    self->nextthink = level.time + 5 + 10 * random();
}

Referenced by infantry_dead(), and mutant_dead().

M_MoveFrame()

void M_MoveFrame

(

edict_t *

self

)

Definition at line 361 of file g_monster.c.

{
    mmove_t *move;
    int     index;
 
    move = self->monsterinfo.currentmove;
    self->nextthink = level.time + FRAMETIME;
 
    if ((self->monsterinfo.nextframe) && (self->monsterinfo.nextframe >= move->firstframe) && (self->monsterinfo.nextframe <= move->lastframe))
    {
        self->s.frame = self->monsterinfo.nextframe;
        self->monsterinfo.nextframe = 0;
    }
    else
    {
        if (self->s.frame == move->lastframe)
        {
            if (move->endfunc)
            {
                move->endfunc (self);
 
                // regrab move, endfunc is very likely to change it
                move = self->monsterinfo.currentmove;
 
                // check for death
                if (self->svflags & SVF_DEADMONSTER)
                    return;
            }
        }
 
        if (self->s.frame < move->firstframe || self->s.frame > move->lastframe)
        {
            self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
            self->s.frame = move->firstframe;
        }
        else
        {
            if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
            {
                self->s.frame++;
                if (self->s.frame > move->lastframe)
                    self->s.frame = move->firstframe;
            }
        }
    }
 
    index = self->s.frame - move->firstframe;
    if (move->frame[index].aifunc)
        if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
            move->frame[index].aifunc (self, move->frame[index].dist * self->monsterinfo.scale);
        else
            move->frame[index].aifunc (self, 0);
 
    if (move->frame[index].thinkfunc)
        move->frame[index].thinkfunc (self);
}

Referenced by monster_think().

M_SetEffects()

void M_SetEffects

(

edict_t *

ent

)

Definition at line 332 of file g_monster.c.

{
    ent->s.effects &= ~(EF_COLOR_SHELL|EF_POWERSCREEN);
    ent->s.renderfx &= ~(RF_SHELL_RED|RF_SHELL_GREEN|RF_SHELL_BLUE);
 
    if (ent->monsterinfo.aiflags & AI_RESURRECTING)
    {
        ent->s.effects |= EF_COLOR_SHELL;
        ent->s.renderfx |= RF_SHELL_RED;
    }
 
    if (ent->health <= 0)
        return;
 
    if (ent->powerarmor_time > level.time)
    {
        if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SCREEN)
        {
            ent->s.effects |= EF_POWERSCREEN;
        }
        else if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SHIELD)
        {
            ent->s.effects |= EF_COLOR_SHELL;
            ent->s.renderfx |= RF_SHELL_GREEN;
        }
    }
}

Referenced by monster_think().

M_WorldEffects()

void M_WorldEffects

(

edict_t *

ent

)

Definition at line 218 of file g_monster.c.

{
    int     dmg;
 
    if (ent->health > 0)
    {
        if (!(ent->flags & FL_SWIM))
        {
            if (ent->waterlevel < 3)
            {
                ent->air_finished = level.time + 12;
            }
            else if (ent->air_finished < level.time)
            {   // drown!
                if (ent->pain_debounce_time < level.time)
                {
                    dmg = 2 + 2 * floor(level.time - ent->air_finished);
                    if (dmg > 15)
                        dmg = 15;
                    T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER);
                    ent->pain_debounce_time = level.time + 1;
                }
            }
        }
        else
        {
            if (ent->waterlevel > 0)
            {
                ent->air_finished = level.time + 9;
            }
            else if (ent->air_finished < level.time)
            {   // suffocate!
                if (ent->pain_debounce_time < level.time)
                {
                    dmg = 2 + 2 * floor(level.time - ent->air_finished);
                    if (dmg > 15)
                        dmg = 15;
                    T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER);
                    ent->pain_debounce_time = level.time + 1;
                }
            }
        }
    }
    
    if (ent->waterlevel == 0)
    {
        if (ent->flags & FL_INWATER)
        {   
            gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_out.wav"), 1, ATTN_NORM, 0);
            ent->flags &= ~FL_INWATER;
        }
        return;
    }
 
    if ((ent->watertype & CONTENTS_LAVA) && !(ent->flags & FL_IMMUNE_LAVA))
    {
        if (ent->damage_debounce_time < level.time)
        {
            ent->damage_debounce_time = level.time + 0.2;
            T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 10*ent->waterlevel, 0, 0, MOD_LAVA);
        }
    }
    if ((ent->watertype & CONTENTS_SLIME) && !(ent->flags & FL_IMMUNE_SLIME))
    {
        if (ent->damage_debounce_time < level.time)
        {
            ent->damage_debounce_time = level.time + 1;
            T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 4*ent->waterlevel, 0, 0, MOD_SLIME);
        }
    }
    
    if ( !(ent->flags & FL_INWATER) )
    {   
        if (!(ent->svflags & SVF_DEADMONSTER))
        {
            if (ent->watertype & CONTENTS_LAVA)
                if (random() <= 0.5)
                    gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava1.wav"), 1, ATTN_NORM, 0);
                else
                    gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava2.wav"), 1, ATTN_NORM, 0);
            else if (ent->watertype & CONTENTS_SLIME)
                gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0);
            else if (ent->watertype & CONTENTS_WATER)
                gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0);
        }
 
        ent->flags |= FL_INWATER;
        ent->damage_debounce_time = 0;
    }
}

Referenced by monster_think().

monster_death_use()

void monster_death_use

(

edict_t *

self

)

Definition at line 511 of file g_monster.c.

{
    self->flags &= ~(FL_FLY|FL_SWIM);
    self->monsterinfo.aiflags &= AI_GOOD_GUY;
 
    if (self->item)
    {
        Drop_Item (self, self->item);
        self->item = NULL;
    }
 
    if (self->deathtarget)
        self->target = self->deathtarget;
 
    if (!self->target)
        return;
 
    G_UseTargets (self, self->enemy);
}

Referenced by Killed().

monster_fire_bfg()

void monster_fire_bfg	(	edict_t *	self,
		vec3_t	start,
		vec3_t	aimdir,
		int	damage,
		int	speed,
		int	kick,
		float	damage_radius,
		int	flashtype
	)

Definition at line 91 of file g_monster.c.

{
    fire_bfg (self, start, aimdir, damage, speed, damage_radius);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}

Referenced by jorgBFG(), and makronBFG().

monster_fire_blaster()

void monster_fire_blaster	(	edict_t *	self,
		vec3_t	start,
		vec3_t	dir,
		int	damage,
		int	speed,
		int	flashtype,
		int	effect
	)

Definition at line 51 of file g_monster.c.

{
    fire_blaster (self, start, dir, damage, speed, effect, false);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}   

Referenced by floater_fire_blaster(), flyer_fire(), hover_fire_blaster(), MakronHyperblaster(), medic_fire_blaster(), soldier_fire(), and TankBlaster().

monster_fire_bullet()

void monster_fire_bullet	(	edict_t *	self,
		vec3_t	start,
		vec3_t	dir,
		int	damage,
		int	kick,
		int	hspread,
		int	vspread,
		int	flashtype
	)

Definition at line 31 of file g_monster.c.

{
    fire_bullet (self, start, dir, damage, kick, hspread, vspread, MOD_UNKNOWN);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}

Referenced by actorMachineGun(), boss2_firebullet_left(), boss2_firebullet_right(), GunnerFire(), InfantryMachineGun(), jorg_firebullet_left(), jorg_firebullet_right(), soldier_fire(), supertankMachineGun(), and TankMachineGun().

monster_fire_grenade()

void monster_fire_grenade	(	edict_t *	self,
		vec3_t	start,
		vec3_t	aimdir,
		int	damage,
		int	speed,
		int	flashtype
	)

Definition at line 61 of file g_monster.c.

{
    fire_grenade (self, start, aimdir, damage, speed, 2.5, damage+40);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}

Referenced by GunnerGrenade().

monster_fire_railgun()

void monster_fire_railgun	(	edict_t *	self,
		vec3_t	start,
		vec3_t	aimdir,
		int	damage,
		int	kick,
		int	flashtype
	)

Definition at line 81 of file g_monster.c.

{
    fire_rail (self, start, aimdir, damage, kick);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}

Referenced by GladiatorGun(), and MakronRailgun().

monster_fire_rocket()

void monster_fire_rocket	(	edict_t *	self,
		vec3_t	start,
		vec3_t	dir,
		int	damage,
		int	speed,
		int	flashtype
	)

Definition at line 71 of file g_monster.c.

{
    fire_rocket (self, start, dir, damage, speed, damage+20, damage);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}   

Referenced by Boss2Rocket(), ChickRocket(), supertankRocket(), and TankRocket().

monster_fire_shotgun()

void monster_fire_shotgun	(	edict_t *	self,
		vec3_t	start,
		vec3_t	aimdir,
		int	damage,
		int	kick,
		int	hspread,
		int	vspread,
		int	count,
		int	flashtype
	)

Definition at line 41 of file g_monster.c.

{
    fire_shotgun (self, start, aimdir, damage, kick, hspread, vspread, count, MOD_UNKNOWN);
 
    gi.WriteByte (svc_muzzleflash2);
    gi.WriteShort (self - g_edicts);
    gi.WriteByte (flashtype);
    gi.multicast (start, MULTICAST_PVS);
}

Referenced by soldier_fire().

monster_start()

qboolean monster_start

(

edict_t *

self

)

Definition at line 534 of file g_monster.c.

{
    if (deathmatch->value)
    {
        G_FreeEdict (self);
        return false;
    }
 
    if ((self->spawnflags & 4) && !(self->monsterinfo.aiflags & AI_GOOD_GUY))
    {
        self->spawnflags &= ~4;
        self->spawnflags |= 1;
//      gi.dprintf("fixed spawnflags on %s at %s\n", self->classname, vtos(self->s.origin));
    }
 
    if (!(self->monsterinfo.aiflags & AI_GOOD_GUY))
        level.total_monsters++;
 
    self->nextthink = level.time + FRAMETIME;
    self->svflags |= SVF_MONSTER;
    self->s.renderfx |= RF_FRAMELERP;
    self->takedamage = DAMAGE_AIM;
    self->air_finished = level.time + 12;
    self->use = monster_use;
    self->max_health = self->health;
    self->clipmask = MASK_MONSTERSOLID;
 
    self->s.skinnum = 0;
    self->deadflag = DEAD_NO;
    self->svflags &= ~SVF_DEADMONSTER;
 
    if (!self->monsterinfo.checkattack)
        self->monsterinfo.checkattack = M_CheckAttack;
    VectorCopy (self->s.origin, self->s.old_origin);
 
    if (st.item)
    {
        self->item = FindItemByClassname (st.item);
        if (!self->item)
            gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item);
    }
 
    // randomize what frame they start on
    if (self->monsterinfo.currentmove)
        self->s.frame = self->monsterinfo.currentmove->firstframe + (rand() % (self->monsterinfo.currentmove->lastframe - self->monsterinfo.currentmove->firstframe + 1));
 
    return true;
}

Referenced by flymonster_start(), swimmonster_start(), and walkmonster_start().

monster_start_go()

void monster_start_go

(

edict_t *

self

)

Definition at line 583 of file g_monster.c.

{
    vec3_t  v;
 
    if (self->health <= 0)
        return;
 
    // check for target to combat_point and change to combattarget
    if (self->target)
    {
        qboolean    notcombat;
        qboolean    fixup;
        edict_t     *target;
 
        target = NULL;
        notcombat = false;
        fixup = false;
        while ((target = G_Find (target, FOFS(targetname), self->target)) != NULL)
        {
            if (strcmp(target->classname, "point_combat") == 0)
            {
                self->combattarget = self->target;
                fixup = true;
            }
            else
            {
                notcombat = true;
            }
        }
        if (notcombat && self->combattarget)
            gi.dprintf("%s at %s has target with mixed types\n", self->classname, vtos(self->s.origin));
        if (fixup)
            self->target = NULL;
    }
 
    // validate combattarget
    if (self->combattarget)
    {
        edict_t     *target;
 
        target = NULL;
        while ((target = G_Find (target, FOFS(targetname), self->combattarget)) != NULL)
        {
            if (strcmp(target->classname, "point_combat") != 0)
            {
                gi.dprintf("%s at (%i %i %i) has a bad combattarget %s : %s at (%i %i %i)\n",
                    self->classname, (int)self->s.origin[0], (int)self->s.origin[1], (int)self->s.origin[2],
                    self->combattarget, target->classname, (int)target->s.origin[0], (int)target->s.origin[1],
                    (int)target->s.origin[2]);
            }
        }
    }
 
    if (self->target)
    {
        self->goalentity = self->movetarget = G_PickTarget(self->target);
        if (!self->movetarget)
        {
            gi.dprintf ("%s can't find target %s at %s\n", self->classname, self->target, vtos(self->s.origin));
            self->target = NULL;
            self->monsterinfo.pausetime = 100000000;
            self->monsterinfo.stand (self);
        }
        else if (strcmp (self->movetarget->classname, "path_corner") == 0)
        {
            VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
            self->ideal_yaw = self->s.angles[YAW] = vectoyaw(v);
            self->monsterinfo.walk (self);
            self->target = NULL;
        }
        else
        {
            self->goalentity = self->movetarget = NULL;
            self->monsterinfo.pausetime = 100000000;
            self->monsterinfo.stand (self);
        }
    }
    else
    {
        self->monsterinfo.pausetime = 100000000;
        self->monsterinfo.stand (self);
    }
 
    self->think = monster_think;
    self->nextthink = level.time + FRAMETIME;
}

Referenced by flymonster_start_go(), monster_triggered_spawn(), swimmonster_start_go(), and walkmonster_start_go().

monster_think()

void monster_think

(

edict_t *

self

)

Definition at line 419 of file g_monster.c.

{
    M_MoveFrame (self);
    if (self->linkcount != self->monsterinfo.linkcount)
    {
        self->monsterinfo.linkcount = self->linkcount;
        M_CheckGround (self);
    }
    M_CatagorizePosition (self);
    M_WorldEffects (self);
    M_SetEffects (self);
}

Referenced by monster_start_go().

monster_triggered_spawn()

void monster_triggered_spawn

(

edict_t *

self

)

Definition at line 460 of file g_monster.c.

{
    self->s.origin[2] += 1;
    KillBox (self);
 
    self->solid = SOLID_BBOX;
    self->movetype = MOVETYPE_STEP;
    self->svflags &= ~SVF_NOCLIENT;
    self->air_finished = level.time + 12;
    gi.linkentity (self);
 
    monster_start_go (self);
 
    if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET))
    {
        FoundTarget (self);
    }
    else
    {
        self->enemy = NULL;
    }
}

Referenced by monster_triggered_spawn_use().

monster_triggered_spawn_use()

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

Definition at line 483 of file g_monster.c.

{
    // we have a one frame delay here so we don't telefrag the guy who activated us
    self->think = monster_triggered_spawn;
    self->nextthink = level.time + FRAMETIME;
    if (activator->client)
        self->enemy = activator;
    self->use = monster_use;
}

Referenced by monster_triggered_start().

monster_triggered_start()

void monster_triggered_start

(

edict_t *

self

)

Definition at line 493 of file g_monster.c.

{
    self->solid = SOLID_NOT;
    self->movetype = MOVETYPE_NONE;
    self->svflags |= SVF_NOCLIENT;
    self->nextthink = 0;
    self->use = monster_triggered_spawn_use;
}

Referenced by flymonster_start_go(), swimmonster_start_go(), and walkmonster_start_go().

monster_use()

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

Definition at line 440 of file g_monster.c.

{
    if (self->enemy)
        return;
    if (self->health <= 0)
        return;
    if (activator->flags & FL_NOTARGET)
        return;
    if (!(activator->client) && !(activator->monsterinfo.aiflags & AI_GOOD_GUY))
        return;
    
// delay reaction so if the monster is teleported, its sound is still heard
    self->enemy = activator;
    FoundTarget (self);
}

Referenced by monster_start(), monster_triggered_spawn_use(), and SP_turret_driver().

swimmonster_start()

void swimmonster_start

(

edict_t *

self

)

Definition at line 735 of file g_monster.c.

{
    self->flags |= FL_SWIM;
    self->think = swimmonster_start_go;
    monster_start (self);
}

Referenced by SP_monster_flipper().

swimmonster_start_go()

void swimmonster_start_go

(

edict_t *

self

)

Definition at line 723 of file g_monster.c.

{
    if (!self->yaw_speed)
        self->yaw_speed = 10;
    self->viewheight = 10;
 
    monster_start_go (self);
 
    if (self->spawnflags & 2)
        monster_triggered_start (self);
}

Referenced by swimmonster_start().

walkmonster_start()

void walkmonster_start

(

edict_t *

self

)

Definition at line 692 of file g_monster.c.

{
    self->think = walkmonster_start_go;
    monster_start (self);
}

Referenced by SP_misc_actor(), SP_misc_insane(), SP_monster_berserk(), SP_monster_brain(), SP_monster_chick(), SP_monster_gladiator(), SP_monster_gunner(), SP_monster_infantry(), SP_monster_jorg(), SP_monster_makron(), SP_monster_medic(), SP_monster_mutant(), SP_monster_parasite(), SP_monster_soldier_x(), SP_monster_supertank(), and SP_monster_tank().

walkmonster_start_go()

void walkmonster_start_go

(

edict_t *

self

)

Definition at line 671 of file g_monster.c.

{
    if (!(self->spawnflags & 2) && level.time < 1)
    {
        M_droptofloor (self);
 
        if (self->groundentity)
            if (!M_walkmove (self, 0, 0))
                gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin));
    }
    
    if (!self->yaw_speed)
        self->yaw_speed = 20;
    self->viewheight = 25;
 
    monster_start_go (self);
 
    if (self->spawnflags & 2)
        monster_triggered_start (self);
}

Referenced by walkmonster_start().